Merge lp:~victored/noise/gapless-playback into lp:~elementary-apps/noise/trunk

[Victor Martinez]

- Gapless playback implementation will be added soon.
- Required infrastructure changes are being performed at this moment.
- Proposed just to get a diff. Feel free to provide feedback but keep in mind code still needs cleanup.

== BUILD

Configure with 'cmake .. -DBUILD_PLUGINS=OFF' since plugins haven't been updated yet.

== REGRESSIONS

- Fix automatic scrolling to current media and properly refresh list view [GenericList]
- Automatically switch to next media after the previous one ends. This chaining and playback control was part of LibraryWindow. Move it to PlaybackManager and integrate gapless playback.

[lp:~victored/noise/gapless-playback]

1801. By Victor Martinez on 2015-04-26

Cleanup & notify when media changes

1802. By Victor Martinez on 2015-04-26

reset timeout ID properly after removing source func

1803. By Victor Martinez on 2015-04-27

correct a few runtime warnings

1804. By Victor Martinez on 2015-04-27

Move some functions to Noise.Pipeline to avoid duplicating code in plugins

1805. By Victor Martinez on 2015-04-27

Code cleanup

[Victor Martinez (victored)]

Gapless playback is kinda broken for MP3/AAC on playbin for GStreamer 1.0. Might want to look into workarounds if we want this feature to ever land any time soon.

Unmerged revisions

1805. By Victor Martinez on 2015-04-27

Code cleanup

1804. By Victor Martinez on 2015-04-27

Move some functions to Noise.Pipeline to avoid duplicating code in plugins

1803. By Victor Martinez on 2015-04-27

correct a few runtime warnings

1802. By Victor Martinez on 2015-04-26

reset timeout ID properly after removing source func

1801. By Victor Martinez on 2015-04-26

Cleanup & notify when media changes

1800. By Victor Martinez on 2015-04-26

Playback: move playback logic and control away from LibraryWindow.vala.

Configure with 'cmake .. -DBUILD_PLUGINS=OFF' since plugins haven't been updated yet.

1799. By Victor Martinez on 2015-04-26

Playback: make sure no playback logic code happens on LibraryWindow.

Make wider use of PlaybackManager API. LibraryWindow will be another client of playback manager and will update its widgets accordingly as the playback class notifies status changes have occured.

=== modified file 'core/GStreamer/Equalizer.vala'
--- core/GStreamer/Equalizer.vala	2015-02-26 16:44:26 +0000
+++ core/GStreamer/Equalizer.vala	2015-04-27 05:07:36 +0000
@@ -62,12 +62,12 @@
 		band.set("gain", gain);
 	}
 
-	private static Gee.TreeSet<EqualizerPreset> ? default_presets = null;
+	private static Gee.ArrayList<EqualizerPreset> ? default_presets = null;
 	public static Gee.Collection<EqualizerPreset> get_default_presets () {
 		if (default_presets != null)
 			return default_presets;
 
-		default_presets = new Gee.TreeSet<EqualizerPreset> ();
+		default_presets = new Gee.ArrayList<EqualizerPreset> ();
 
 		default_presets.add (new EqualizerPreset.with_gains (_("Flat"), {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}));
 		default_presets.add (new EqualizerPreset.with_gains (_("Classical"), {0, 0, 0, 0, 0, 0, -40, -40, -40, -50}));

=== modified file 'core/GStreamer/Pipeline.vala'
--- core/GStreamer/Pipeline.vala	2013-11-15 15:54:19 +0000
+++ core/GStreamer/Pipeline.vala	2015-04-27 05:07:36 +0000
@@ -28,78 +28,147 @@
  * Authored by: Scott Ringwelski <[e-mail]>
  */
 
-public class Noise.Pipeline : GLib.Object {
-    public Gst.Pipeline pipe;
-    public Equalizer eq;
-    
-    public dynamic Gst.Bus bus;
-    public Gst.Pad pad;
-    
-    public dynamic Gst.Element audiosink;
-    public dynamic Gst.Element audiosinkqueue;
-    public dynamic Gst.Element eq_audioconvert;
-    public dynamic Gst.Element eq_audioconvert2; 
-     
-    public dynamic Gst.Element playbin;
-    public dynamic Gst.Element audiotee;
-    public dynamic Gst.Element audiobin;
-    public dynamic Gst.Element preamp;
-    
+public abstract class Noise.Pipeline : Object, PlaybackBackend {
+    private Gst.Pipeline pipe;
+    private Equalizer eq;
+    private Gst.Pad pad;
+
+    private dynamic Gst.Element playbin;
+    private dynamic Gst.Element audiosink;
+    private dynamic Gst.Element audiosinkqueue;
+    private dynamic Gst.Element eq_audioconvert;
+    private dynamic Gst.Element eq_audioconvert2; 
+    private dynamic Gst.Element audiotee;
+    private dynamic Gst.Element audiobin;
+    private dynamic Gst.Element preamp;
+
     public Pipeline() {
-        
-        pipe = new Gst.Pipeline("pipeline");
+        pipe = new Gst.Pipeline ("pipeline");
         playbin = Gst.ElementFactory.make ("playbin", "play");
-        
-        audiosink = Gst.ElementFactory.make("autoaudiosink", "audio-sink");
-        
-        audiobin = new Gst.Bin("audiobin"); // this holds the real primary sink
-        
-        audiotee = Gst.ElementFactory.make("tee", null);
-        audiosinkqueue = Gst.ElementFactory.make("queue", null);
-        
-        eq = new Equalizer();
-        if(eq.element != null) {
-            eq_audioconvert = Gst.ElementFactory.make("audioconvert", null);
-            eq_audioconvert2 = Gst.ElementFactory.make("audioconvert", null);
-            preamp = Gst.ElementFactory.make("volume", "preamp");
-            
-            ((Gst.Bin)audiobin).add_many(eq.element, eq_audioconvert, eq_audioconvert2, preamp);
+        audiosink = Gst.ElementFactory.make ("autoaudiosink", "audio-sink");
+        audiobin = new Gst.Bin ("audiobin"); // this holds the real primary sink
+        audiotee = Gst.ElementFactory.make ("tee", null);
+        audiosinkqueue = Gst.ElementFactory.make ("queue", null);
+        eq = new Equalizer ();
+
+        if (eq.element != null) {
+            eq_audioconvert = Gst.ElementFactory.make ("audioconvert", null);
+            eq_audioconvert2 = Gst.ElementFactory.make ("audioconvert", null);
+            preamp = Gst.ElementFactory.make ("volume", "preamp");
+
+            ((Gst.Bin) audiobin).add_many (eq.element, eq_audioconvert, eq_audioconvert2, preamp);
         }
-        
-        ((Gst.Bin)audiobin).add_many(audiotee, audiosinkqueue, audiosink);
+
+        ((Gst.Bin) audiobin).add_many (audiotee, audiosinkqueue, audiosink);
         
         audiobin.add_pad (new Gst.GhostPad ("sink", audiotee.get_static_pad ("sink")));
         
         if (eq.element != null)
-            audiosinkqueue.link_many(eq_audioconvert, preamp, eq.element, eq_audioconvert2, audiosink);
+            audiosinkqueue.link_many (eq_audioconvert, preamp, eq.element, eq_audioconvert2, audiosink);
         else
-            audiosinkqueue.link_many(audiosink); // link the queue with the real audio sink
+            audiosinkqueue.link_many (audiosink); // link the queue with the real audio sink
         
-        playbin.set("audio-sink", audiobin); 
-        bus = playbin.get_bus();
+        playbin.set ("audio-sink", audiobin); 
         
         // Link the first tee pad to the primary audio sink queue
         Gst.Pad sinkpad = audiosinkqueue.get_static_pad ("sink");
         pad = audiotee.get_request_pad ("src_%u");
-        audiotee.set("alloc-pad", pad);
-        pad.link(sinkpad);
-    }
-
-    public void enableEqualizer() {
-        if (eq.element != null) {
-            audiosinkqueue.unlink (audiosink); // link the queue with the real audio sink
-            audiosinkqueue.link_many(eq_audioconvert, preamp, eq.element, eq_audioconvert2, audiosink);
-        }
-    }
-    
-    public void disableEqualizer() {
-        if (eq.element != null) {
-            audiosinkqueue.unlink (eq_audioconvert);
-            audiosinkqueue.unlink (preamp);
-            audiosinkqueue.unlink (eq.element);
-            audiosinkqueue.unlink (eq_audioconvert2);
-            audiosinkqueue.unlink (audiosink);
-            audiosinkqueue.link_many(audiosink); // link the queue with the real audio sink
-        }
+        audiotee.set ("alloc-pad", pad);
+        pad.link (sinkpad);
+
+        playbin.get_bus ().add_watch (Priority.HIGH, bus_callback);
+        playbin.about_to_finish.connect (on_about_to_finish);
+    }
+
+    protected abstract bool bus_callback (Gst.Bus bus, Gst.Message message);
+
+    private void on_about_to_finish () {
+        // propagate signal in a MT-safe way
+        var message = new Gst.Message.application (playbin,
+            new Gst.Structure.empty ("about-to-finish"));
+        playbin.post_message (message);
+    }
+
+    public void seek_simple (int64 pos) {
+        playbin.seek_simple (Gst.Format.TIME, Gst.SeekFlags.FLUSH, pos);
+    }
+
+    public string? get_current_uri () {
+        return playbin.current_uri;
+    }
+
+    public void set_uri (string uri) {
+        message ("Playbin new URI: %s", uri);
+        playbin.uri = uri;
+    }
+
+    public void play () {
+        set_state (Gst.State.PLAYING);
+    }
+    
+    public void pause () {
+        set_state (Gst.State.PAUSED);
+    }
+    
+    private void set_state (Gst.State s) {
+        playbin.set_state (s);
+    }
+
+    public void set_position (int64 pos) {
+        playbin.seek (1.0, Gst.Format.TIME, Gst.SeekFlags.FLUSH, Gst.SeekType.SET,
+                      pos, Gst.SeekType.NONE, get_duration ());
+    }
+    
+    public int64 get_position () {
+        int64 rv = (int64) 0;
+        Gst.Format f = Gst.Format.TIME;
+        
+        playbin.query_position (f, out rv);
+        
+        return rv;
+    }
+    
+    public int64 get_duration () {
+        int64 rv = (int64)0;
+        Gst.Format f = Gst.Format.TIME;
+        
+        playbin.query_duration (f, out rv);
+        
+        return rv;
+    }
+
+    public void enable_equalizer () {
+        if (eq.element == null)
+            return;
+
+        // link the queue with the real audio sink
+        audiosinkqueue.unlink (audiosink);
+        audiosinkqueue.link_many (eq_audioconvert, preamp, eq.element, eq_audioconvert2, audiosink);
+    }
+
+    public void set_equalizer_gain (int index, int val) {
+        eq.setGain (index, val);
+    }
+
+    public void disable_equalizer () {
+        if (eq.element == null)
+            return;
+
+        audiosinkqueue.unlink (eq_audioconvert);
+        audiosinkqueue.unlink (preamp);
+        audiosinkqueue.unlink (eq.element);
+        audiosinkqueue.unlink (eq_audioconvert2);
+        audiosinkqueue.unlink (audiosink);
+
+        // link the queue with the real audio sink
+        audiosinkqueue.link_many (audiosink);
+    }
+
+    public void set_volume (double val) {
+        playbin.volume = val;
+    }
+
+    public double get_volume () {
+        return playbin.volume;
     }
 }

=== modified file 'core/GStreamer/Playback.vala'
--- core/GStreamer/Playback.vala	2013-10-11 11:58:03 +0000
+++ core/GStreamer/Playback.vala	2015-04-27 05:07:36 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: vala; indent-tabs-mode: nil; tab-width: 4 -*-
 /*-
- * Copyright (c) 2012-2013 Noise Developers (http://launchpad.net/noise)
+ * Copyright (c) 2012-2015 Noise Developers (http://launchpad.net/noise)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ -28,27 +28,27 @@
  * Authored by: Corentin Noël <[e-mail]>
  */
 
-public interface Noise.Playback : GLib.Object {
-
+public interface Noise.Playback : Noise.PlaybackBackend {
     public abstract Gee.Collection<string> get_supported_uri ();
+    public abstract void set_media (Media media);
+    public abstract void set_next_media (Media media);
+}
 
+public interface Noise.PlaybackBackend : Object {
     /* 
      * Signals
      */
-
-    public signal void end_of_stream ();
-    public signal void current_position_update (int64 position);
+    public signal void about_to_finish (string uri_about_to_finish);
+    public signal void end_of_stream (string uri_finished, string? next_uri);
     public signal void media_not_found ();
     public signal void error_occured ();
 
     /* 
      * Basic playback functions
      */
-
     public abstract void play ();
     public abstract void pause ();
     public abstract void set_state (Gst.State s);
-    public abstract void set_media (Media media);
     public abstract void set_position (int64 pos);
     public abstract int64 get_position ();
     public abstract int64 get_duration ();
@@ -58,10 +58,7 @@
     /* 
      * Extra stuff
      */
-
-    public abstract bool update_position ();
     public abstract void enable_equalizer ();
     public abstract void disable_equalizer ();
     public abstract void set_equalizer_gain (int index, int val);
-
 }

=== modified file 'core/LibraryWindowInterface.vala'
--- core/LibraryWindowInterface.vala	2015-02-24 18:16:35 +0000
+++ core/LibraryWindowInterface.vala	2015-04-27 05:07:36 +0000
@@ -29,7 +29,7 @@
  */
 
 public interface Noise.LibraryWindowInterface : Object {
-    public abstract async void update_sensitivities ();
+    public abstract void update_sensitivities ();
     public signal void add_preference_page (Noise.SettingsWindow.NoteBook_Page widget);
     public signal void source_list_added (GLib.Object o, int view_number);
     

=== modified file 'core/Media.vala'
--- core/Media.vala	2015-02-24 00:04:03 +0000
+++ core/Media.vala	2015-04-27 05:07:36 +0000
@@ -29,6 +29,7 @@
  *              Victor Eduardo <[e-mail]>
  */
 public class Noise.Media : Object {
+    public signal void updated ();
 
     /// Used for unknown titles, artists, or album names.
     protected static string UNKNOWN = _("Unknown");
@@ -190,10 +191,12 @@
 
     public Media (string uri) {
         this.uri = uri;
+        this.notify.connect (() => updated ());
     }
 
     public Media.from_file (File file) {
         this.file = file;
+        this.notify.connect (() => updated ());
     }
 
     public Media copy () {

=== modified file 'core/Player.vala'
--- core/Player.vala	2013-02-26 21:56:08 +0000
+++ core/Player.vala	2015-04-27 05:07:36 +0000
@@ -28,9 +28,33 @@
  * Authored by: Victor Eduardo <[e-mail]>
  */
 
+public enum Noise.PlaybackStatus {
+    STOPPED,
+    PAUSED,
+    PLAYING;
+    
+    public bool is_playing () {
+        return this == PLAYING;
+    }
+
+    public bool is_paused () {
+        return this == PAUSED;
+    }
+
+    public bool is_stopped () {
+        return this == STOPPED;
+    }
+}
+
 public interface Noise.Player : Object {
-
-    public abstract void add_playback (Noise.Playback p);
+    // XXX should be internal
+    public signal void current_cleared ();
+    public signal void queue_cleared  ();
+    public signal void media_queued (Gee.Collection<Media> queued);
+
+    public signal void status_change (Media? current_media, PlaybackStatus status);
+
+    //public abstract void add_playback (Noise.Playback p);
 
     public enum Shuffle {
         OFF,
@@ -45,5 +69,5 @@
         ALL
     }
 
-    // TODO: ...
+    public abstract void play_pause ();
 }

=== modified file 'core/Settings.vala'
--- core/Settings.vala	2015-02-26 16:44:26 +0000
+++ core/Settings.vala	2015-04-27 05:07:36 +0000
@@ -114,7 +114,7 @@
         }
 
         public Gee.Collection<Noise.EqualizerPreset> getPresets () {
-            var presets_data = new Gee.TreeSet<string> ();
+            var presets_data = new Gee.ArrayList<string> ();
             
             if (custom_presets != null) {
                 for (int i = 0; i < custom_presets.length; i++) {
@@ -122,7 +122,7 @@
                 }
             }
             
-            var rv = new Gee.TreeSet<Noise.EqualizerPreset>();
+            var rv = new Gee.ArrayList<Noise.EqualizerPreset>();
             
             foreach (var preset_str in presets_data) {
                 rv.add (new Noise.EqualizerPreset.from_string (preset_str));

=== modified file 'src/GStreamer/Streamer.vala'
--- src/GStreamer/Streamer.vala	2015-03-01 16:43:54 +0000
+++ src/GStreamer/Streamer.vala	2015-04-27 05:07:36 +0000
@@ -20,30 +20,14 @@
  * Boston, MA 02111-1307, USA.
  */
 
-public class Noise.Streamer : Noise.Playback, GLib.Object {
-    Noise.Pipeline pipe;
+public class Noise.Streamer : Pipeline, Playback {
+    private InstallGstreamerPluginsDialog dialog;
+    private string? last_played_uri;
+    private string? last_queued_uri;
 
-    InstallGstreamerPluginsDialog dialog;
-    
-    public Gst.Element cdda;
-    public bool set_resume_pos;
-    
-    /* Signals are now in the Playback interface !
-    public signal void end_of_stream ();
-    public signal void current_position_update (int64 position);
-    public signal void media_not_found ();
-    public signal void error_occured (); */
-    
     public Streamer () {
-        pipe = new Noise.Pipeline();
-
-        pipe.bus.add_watch (GLib.Priority.DEFAULT, bus_callback);
-        //pipe.playbin.about_to_finish.connect(about_to_finish);
-        
-
-        Timeout.add (200, update_position);
     }
-    
+
     public Gee.Collection<string> get_supported_uri () {
         var uris = new Gee.LinkedList<string> ();
         uris.add ("file://");
@@ -52,136 +36,67 @@
         return uris;
     }
 
-    public bool update_position () {
-        if(set_resume_pos || (App.player.current_media != null && get_position() >= (int64)(App.player.current_media.resume_pos - 1) * 1000000000)) {
-            set_resume_pos = true;
-            current_position_update(get_position());
-        }
-        else if (App.player.current_media != null) {
-            pipe.playbin.seek_simple(Gst.Format.TIME, Gst.SeekFlags.FLUSH, (int64)App.player.current_media.resume_pos * 1000000000);
-        }
-        
-        return true;
-    }
-    
-    /* Basic playback functions */
-    public void play () {
-        set_state (Gst.State.PLAYING);
-    }
-    
-    public void pause () {
-        set_state (Gst.State.PAUSED);
-    }
-    
-    public void set_state (Gst.State s) {
-        pipe.playbin.set_state (s);
-    }
-    
+    public void set_next_media (Media next) {
+        assert (last_played_uri != null);
+        debug ("set_next_media");
+        last_queued_uri = next.uri;
+        set_uri (last_queued_uri);
+    }
+
     public void set_media (Media media) {
         set_state (Gst.State.READY);
-        debug ("set uri to %s\n", media.uri);
-        //pipe.playbin.uri = uri.replace("#", "%23");
-        pipe.playbin.set_property ("uri", media.uri.replace("#", "%23"));
-
-        set_state (Gst.State.PLAYING);
-        
-        debug ("setURI seeking to %d\n", App.player.current_media.resume_pos);
-        pipe.playbin.seek_simple (Gst.Format.TIME, Gst.SeekFlags.FLUSH, (int64)App.player.current_media.resume_pos * 1000000000);
-        
+
+        last_played_uri = media.uri;
+        last_queued_uri = null;
+
+        debug ("set_media: %s", last_played_uri);
+        set_uri (last_played_uri);
+
         play ();
-    }
-    
-    public void set_position (int64 pos) {
-        pipe.playbin.seek (1.0,
-        Gst.Format.TIME, Gst.SeekFlags.FLUSH,
-        Gst.SeekType.SET, pos,
-        Gst.SeekType.NONE, get_duration ());
-    }
-    
-    public int64 get_position () {
-        int64 rv = (int64)0;
-        Gst.Format f = Gst.Format.TIME;
-        
-        pipe.playbin.query_position (f, out rv);
-        
-        return rv;
-    }
-    
-    public int64 get_duration () {
-        int64 rv = (int64)0;
-        Gst.Format f = Gst.Format.TIME;
-        
-        pipe.playbin.query_duration (f, out rv);
-        
-        return rv;
-    }
-    
-    public void set_volume (double val) {
-        pipe.playbin.set_property ("volume", val);
-    }
-    
-    public double get_volume () {
-        var val = GLib.Value (typeof(double));
-        pipe.playbin.get_property ("volume", ref val);
-        return (double)val;
-    }
-    
-    /* Extra stuff */
-    public void enable_equalizer () {
-        pipe.enableEqualizer ();
-    }
-    
-    public void disable_equalizer() {
-        pipe.disableEqualizer ();
-    }
-    
-    public void set_equalizer_gain (int index, int val) {
-        pipe.eq.setGain (index, val);
+
+        debug ("set_media seeking to %d", App.player.current_media.resume_pos);
+        seek_simple ((int64) App.player.current_media.resume_pos * 1000000000);
     }
     
     /* Callbacks */
-    private bool bus_callback (Gst.Bus bus, Gst.Message message) {
+    protected override bool bus_callback (Gst.Bus bus, Gst.Message message) {
         switch (message.type) {
-        case Gst.MessageType.ERROR:
-            GLib.Error err;
-            string debug;
-            message.parse_error (out err, out debug);
-            warning ("Error: %s\n", err.message);
-            error_occured();
-            break;
-        case Gst.MessageType.ELEMENT:
-            if(message.get_structure() != null && Gst.PbUtils.is_missing_plugin_message(message) && (dialog == null || !dialog.visible)) {
-                dialog = new InstallGstreamerPluginsDialog(message);
-            }
-            break;
-        case Gst.MessageType.EOS:
-            end_of_stream ();
-            break;
-        case Gst.MessageType.STATE_CHANGED:
-            Gst.State oldstate;
-            Gst.State newstate;
-            Gst.State pending;
-            message.parse_state_changed (out oldstate, out newstate,
-                                         out pending);
-
-            if(newstate != Gst.State.PLAYING)
-                break;
-            
-            
-            break;
-        case Gst.MessageType.TAG:
-            Gst.TagList tag_list;
-            
-            message.parse_tag (out tag_list);
-            if (tag_list != null) {
-                if (tag_list.get_tag_size (Gst.Tags.TITLE) > 0) {
-                    string title = "";
-                    tag_list.get_string (Gst.Tags.TITLE, out title);
-                }
-            }
-            break;
-        default:
-            break;
+            case Gst.MessageType.ERROR:
+                GLib.Error err;
+                string debug;
+                message.parse_error (out err, out debug);
+                warning ("Error: %s\n", err.message);
+                error_occured ();
+                break;
+
+            case Gst.MessageType.APPLICATION:
+                unowned Gst.Structure structure = message.get_structure ();
+                if (structure != null && structure.get_name () == "about-to-finish")
+                    about_to_finish (last_played_uri);
+
+                break;
+
+            case Gst.MessageType.ELEMENT:
+                if (message.get_structure () == null || dialog != null || dialog.visible)
+                    break;
+
+                if (Gst.PbUtils.is_missing_plugin_message (message))
+                    dialog = new InstallGstreamerPluginsDialog (message);
+
+                break;
+
+            case Gst.MessageType.EOS:
+                end_of_stream (last_played_uri, last_queued_uri);
+
+                last_played_uri = last_queued_uri;
+                last_queued_uri = null;
+
+                break;
+
+            case Gst.MessageType.TAG:
+            case Gst.MessageType.STATE_CHANGED:
+            default:
+                break;
         }
  
         return true;

=== modified file 'src/LibraryWindow.vala'
--- src/LibraryWindow.vala	2015-03-01 16:43:54 +0000
+++ src/LibraryWindow.vala	2015-04-27 05:07:36 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: vala; indent-tabs-mode: nil; tab-width: 4 -*-
 /*-
- * Copyright (c) 2012 Noise Developers (http://launchpad.net/noise)
+ * Copyright (c) 2012-2015 Noise Developers (http://launchpad.net/noise)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -22,7 +22,6 @@
  */
 
 public class Noise.LibraryWindow : LibraryWindowInterface, Gtk.Window {
-    public signal void playPauseChanged ();
     public signal void close_subwindows ();
 
     public Noise.LocalLibrary library_manager { get { return (Noise.LocalLibrary)libraries_manager.local_library; } }
@@ -72,6 +71,7 @@
     private Settings.Main main_settings;
 
     private Cancellable notification_cancellable;
+    private unowned Media current_media;
 
     PreferencesWindow? preferences = null;
 
@@ -101,24 +101,8 @@
         device_manager.device_name_changed.connect (change_device_name);
         device_manager.device_removed.connect (remove_device);
 
-        App.player.player.end_of_stream.connect (end_of_stream);
-        App.player.player.current_position_update.connect (current_position_update);
-        App.player.player.error_occured.connect (error_occured);
-        App.player.media_played.connect_after (media_played);
-        App.player.playback_stopped.connect (playback_stopped);
-        App.player.playback_started.connect (playback_started);
-        App.player.playback_paused.connect (playback_paused);
-        App.player.changing_player.connect (() => {
-            App.player.player.end_of_stream.disconnect (end_of_stream);
-            App.player.player.current_position_update.disconnect (current_position_update);
-            App.player.player.error_occured.disconnect (error_occured);
-        });
-        App.player.player_changed.connect (() => {
-            App.player.player.end_of_stream.connect (end_of_stream);
-            App.player.player.current_position_update.connect (current_position_update);
-            App.player.player.error_occured.connect (error_occured);
-        });
-        
+        App.player.status_change.connect (on_playback_status_change);
+
         NotificationManager.get_default ().show_alert.connect (doAlert);
         
         match_playlists = new Gee.HashMap<unowned Playlist, int> ();
@@ -126,7 +110,6 @@
         match_playlist_entry = new Gee.HashMap<unowned Playlist, SourceListEntry> ();
         match_tvs = new Gee.HashMap<Playlist, TreeViewSetup> ();
 
-
         // init some booleans
         if (this.library_manager.get_medias ().size > 0) {
             App.player.clearCurrent();
@@ -134,15 +117,67 @@
             // make sure we don't re-count stats
             if (main_settings.last_media_position > 5)
                 media_considered_previewed = true;
-            if(main_settings.last_media_position > 30)
+            if (main_settings.last_media_position > 30)
                 media_considered_played = true;
-            if(App.player.current_media != null && (double)(main_settings.last_media_position/(double)App.player.current_media.length) > 0.90)
-                added_to_play_count = true;
-        }
-
-        /*if(!File.new_for_path(settings.getMusicFolder()).query_exists() && settings.getMusicFolder() != "") {
-            doAlert("Music folder not mounted", "Your music folder is not mounted. Please mount your music folder before using Noise.");
-        }*/
+        }
+    }
+
+    private void on_playback_status_change (Media? current_media, PlaybackStatus status) {
+        if (this.current_media != current_media) {
+            this.current_media = current_media;
+            //reset the media position
+            topDisplay.set_media (App.player.current_media);
+
+            //reset some booleans
+            tested_for_video = false;
+            media_considered_previewed = false;
+            media_considered_played = false;
+            added_to_play_count = false;
+            media_half_played_sended = false;
+
+            /* XXX
+            Timeout.add (3000, () => {
+                if (App.player.current_media != null && App.player.current_media == m) {
+                    new Thread<void*> (null, () => {
+                        update_media_info (App.player.current_media);
+                        return null;
+                    });
+                }
+                
+                return false;
+            });
+            */
+        }
+
+        switch (status) {
+            case PlaybackStatus.STOPPED:
+                playButton.set_image (new Gtk.Image.from_icon_name ("media-playback-start-symbolic", Gtk.IconSize.LARGE_TOOLBAR));
+                //reset some booleans
+                tested_for_video = false;
+                media_considered_previewed = false;
+                media_considered_played = false;
+                added_to_play_count = false;
+
+                debug ("playback stopped");
+            break;
+
+            case PlaybackStatus.PLAYING:
+                playButton.set_image (new Gtk.Image.from_icon_name ("media-playback-pause-symbolic", Gtk.IconSize.LARGE_TOOLBAR));
+                playButton.set_tooltip_text (_("Pause"));
+                debug ("playback started");
+            break;
+
+            case PlaybackStatus.PAUSED:
+                playButton.set_image (new Gtk.Image.from_icon_name ("media-playback-start-symbolic", Gtk.IconSize.LARGE_TOOLBAR));
+                playButton.set_tooltip_text (_("Play"));
+                debug ("playback paused");
+            break;
+
+            default:
+                assert_not_reached ();
+        }
+
+        update_sensitivities ();
     }
 
     private void change_view (Widgets.ViewSelector.Mode mode) {
@@ -162,7 +197,7 @@
 
         if (!modifiers_active && search_field_has_focus) {
             if (event.keyval == Gdk.Key.space && !searchField.has_focus && !source_list_view.editing) {
-                play_media (); // toggle play/pause
+                play_pause (); // toggle play/pause
                 return true;
             }
 
@@ -485,7 +520,7 @@
         source_list_view.playlist_import_clicked.connect ( () => {
             try {
                 PlaylistsUtils.import_from_playlist_file_info(Noise.PlaylistsUtils.get_playlists_to_import (), library_manager);
-                update_sensitivities.begin ();
+                update_sensitivities ();
             } catch (GLib.Error e) {
                 warning (e.message);
             }
@@ -501,7 +536,7 @@
 
         load_playlists ();
         //sideTree.resetView ();
-        update_sensitivities_sync (); // we need to do this synchronously to avoid weird initial states
+        update_sensitivities();
 
         // Now set the selected view
         viewSelector.selected = (Widgets.ViewSelector.Mode) Settings.SavedState.get_default ().view_mode;
@@ -526,9 +561,9 @@
         }
 
         /* Connect events to functions */
-        previousButton.clicked.connect (() => {play_previous_media ();});
-        playButton.clicked.connect (() => {play_media ();});
-        nextButton.clicked.connect (() => {play_next_media ();});
+        previousButton.clicked.connect (() => play_previous_media ());
+        playButton.clicked.connect (() => play_pause ());
+        nextButton.clicked.connect (() => play_next_media ());
 
         searchField.activate.connect (searchFieldActivate);
         searchField.search_changed.connect (() => {if (searchField.text_length != 1) libraries_manager.search_for_string (searchField.get_text ());});
@@ -536,14 +571,6 @@
         libraries_manager.search_for_string (main_settings.search_string);
 
         debug ("DONE WITH USER INTERFACE");
-
-        int last_playing_id = main_settings.last_media_playing;
-
-        if (last_playing_id > 0) {
-            var last_playing_media = library_manager.media_from_id (last_playing_id);
-            if (last_playing_media != null && last_playing_media.file.query_exists ())
-                App.player.playMedia (last_playing_media, true);
-        }
     }
 
     /**
@@ -602,7 +629,12 @@
 #endif
     }
 
-    public async void show_notification_from_media_async (Media media) {
+    private void notify_current_media () {
+        if (App.player.current_media != null)
+            show_notification_from_media (App.player.current_media);
+    }
+
+    public void show_notification_from_media (Media media) {
         if (media == null)
             return;
 
@@ -629,12 +661,6 @@
         }
     }
 
-    private async void notify_current_media_async () {
-        if (App.player.current_media != null)
-            yield show_notification_from_media_async (App.player.current_media);
-    }
-
-
     /**
      * Sets the given view as the active item
      */
@@ -711,21 +737,12 @@
         entry.badge = new_badge;
     }
 
-    /**
+    /** 
      * Updating the interface
      */
 
-    private bool update_sensitivities_pending = false;
-
-    public async void update_sensitivities () {
-        if (update_sensitivities_pending)
-            return;
-
-        update_sensitivities_pending = true;
-        update_sensitivities_sync ();
-        update_sensitivities_pending = false;
-    }
-    private void update_sensitivities_sync () {
+    // XXX should be private!
+    public void update_sensitivities () {
         debug ("UPDATE SENSITIVITIES");
 
         bool folder_set = library_manager.main_directory_set;
@@ -744,7 +761,7 @@
         // hide playlists when media list is empty
         source_list_view.change_playlist_category_visibility (have_media);
 
-        if(!media_active || have_media && !App.player.playing)
+        if (!media_active || have_media && !App.player.playback_status.is_playing ())
             playButton.set_image (new Gtk.Image.from_icon_name ("media-playback-start-symbolic", Gtk.IconSize.LARGE_TOOLBAR));
 
         bool show_info_panel = Settings.SavedState.get_default ().more_visible && info_panel.can_show_up;
@@ -964,63 +981,9 @@
         spe.show ();
     }
 
-    /** This should be used whenever a call to play a new media is made
-     *
-     * XXX: this doesn't belong here, but to the playback manager
-     * @param s The media that is now playing
-     */
-    public void media_played (Media m) {
-        //reset the media position
-        topDisplay.set_media (App.player.current_media);
-
-        //reset some booleans
-        tested_for_video = false;
-        media_considered_previewed = false;
-        media_considered_played = false;
-        added_to_play_count = false;
-        media_half_played_sended = false;
-        
-        update_sensitivities.begin ();
-
-        Timeout.add (3000, () => {
-            if (App.player.current_media != null && App.player.current_media == m) {
-                new Thread<void*> (null, () => {
-                    update_media_info (App.player.current_media);
-                    return null;
-                });
-            }
-            
-            return false;
-        });
-    }
-
-
-    public virtual void playback_stopped (int was_playing) {
-        playButton.set_image (new Gtk.Image.from_icon_name ("media-playback-start-symbolic", Gtk.IconSize.LARGE_TOOLBAR));
-        //reset some booleans
-        tested_for_video = false;
-        media_considered_previewed = false;
-        media_considered_played = false;
-        added_to_play_count = false;
-
-        update_sensitivities.begin ();
-
-        debug ("playback stopped");
-    }
-    
-    public virtual void playback_started () {
-        playButton.set_image (new Gtk.Image.from_icon_name ("media-playback-pause-symbolic", Gtk.IconSize.LARGE_TOOLBAR));
-        playButton.set_tooltip_text (_("Pause"));
-        debug ("playback started");
-    }
-    
-    public virtual void playback_paused () {
-        playButton.set_image (new Gtk.Image.from_icon_name ("media-playback-start-symbolic", Gtk.IconSize.LARGE_TOOLBAR));
-        playButton.set_tooltip_text (_("Play"));
-        debug ("playback paused");
-    }
-
-    public virtual void play_media (bool inhibit_notifications = false) {
+    public void play_pause (bool inhibit_notifications = false) {
+#if REMEMBER_TO_MOVE_THIS_CODE_TO_PLAYBACK_MANAGER
+
         if(App.player.current_media == null) {
             debug("No media is currently playing. Starting from the top\n");
 
@@ -1028,19 +991,22 @@
             App.player.start_playback ();
 
             if (!inhibit_notifications)
-                notify_current_media_async.begin ();
+                notify_current_media ();
         } else {
-            if(App.player.playing) {
+            if (App.player.playing) {
                 App.player.pause_playback ();
             } else {
                 App.player.start_playback ();
             }
+        
         }
+#endif
 
-        playPauseChanged();
+        App.player.play_pause ();
     }
 
-    public virtual void play_next_media (bool inhibit_notifications = false) {
+    public void play_next_media (bool inhibit_notifications = false) {
+#if REMEMBER_TO_MOVE_THIS_CODE_TO_PLAYBACK_MANAGER
         // if not 90% done, skip it
         if(!added_to_play_count) {
             App.player.current_media.skip_count++;
@@ -1060,31 +1026,44 @@
         /* test to stop playback/reached end */
         if(m == null) {
             App.player.stop_playback ();
-            update_sensitivities.begin ();
+            update_sensitivities ();
             return;
         }
+#endif
+        // no need to do UI work here. PlaybackManager will notify us through status_change.
+        App.player.getNext (true);
 
         if (!inhibit_notifications)
-            notify_current_media_async.begin ();
+            notify_current_media ();
     }
 
-    public virtual void play_previous_media (bool inhibit_notifications = false) {
-        if (App.player.player.get_position () < 5000000000) {
+    public void play_previous_media (bool inhibit_notifications = false) {
+#if REMEMBER_TO_MOVE_THIS_CODE_TO_PLAYBACK_MANAGER
+
+        if (App.player.get_position () < 5000000000) {
             bool play = true;
             var prev = App.player.getPrevious(true);
 
             /* test to stop playback/reached end */
             if(prev == null) {
                 App.player.stop_playback ();
-                update_sensitivities.begin ();
+                update_sensitivities ();
                 return;
             } else if (play && !inhibit_notifications) {
-                notify_current_media_async.begin ();
+                notify_current_media ();
             }
         } else
             topDisplay.change_value (Gtk.ScrollType.NONE, 0);
+#endif
+
+        // no need to do UI work here. PlaybackManager will notify us through status_change.
+        App.player.getPrevious (true);
+
+        if (!inhibit_notifications)
+            notify_current_media ();
     }
 
+
     public virtual void fileImportMusicClick () {
         if(!library_manager.doing_file_operations()) {
 
@@ -1109,7 +1088,7 @@
 
             if (GLib.File.new_for_path (main_settings.music_folder).query_exists ()) {
                 library_manager.add_folder_to_library (folders);
-                update_sensitivities.begin ();
+                update_sensitivities ();
             }
         } else {
             debug("Can't add to library.. already doing file operations\n");
@@ -1145,79 +1124,6 @@
         }
     }
 
-    public virtual void end_of_stream() {
-        play_next_media ();
-    }
-
-    public virtual void error_occured () {
-        if(App.player.current_media != null) {
-            play_media ();
-        }
-    }
-
-    public virtual void current_position_update (int64 position) {
-        if (App.player.current_media == null)
-            return;
-
-        double sec = ((double)position/1000000000);
-        double media_length = ((double)App.player.current_media.length/1000);
-
-        if(App.player.file_player.set_resume_pos)
-            App.player.current_media.resume_pos = (int)sec;
-
-        // at about 3 seconds, update last fm. we wait to avoid excessive querying last.fm for info
-        if(sec > 3 && !media_considered_previewed) {
-            media_considered_previewed = true;
-            update_media_info (App.player.current_media);
-        }
-
-        //at 30 seconds in, we consider the media as played
-        if(sec > 30 && !media_considered_played) {
-            media_considered_played = true;
-            App.player.current_media.last_played = (int)time_t();
-
-            library_manager.update_media (App.player.current_media, false, false);
-
-            // add to the already played list
-            if(!App.player.history_playlist.medias.contains (App.player.current_media)) {
-                var temp_media = new Gee.TreeSet<Media>();
-                temp_media.add (App.player.current_media);
-                App.player.history_playlist.add_medias (temp_media);
-            }
-
-#if HAVE_ZEITGEIST
-            var event = new Zeitgeist.Event.full (Zeitgeist.ZG_ACCESS_EVENT,
-                                                   Zeitgeist.ZG_SCHEDULED_ACTIVITY, "app://%s".printf (App.instance.get_desktop_file_name ()),
-                                                   new Zeitgeist.Subject.full(App.player.current_media.uri,
-                                                                               Zeitgeist.NFO_AUDIO,
-                                                                               Zeitgeist.NFO_FILE_DATA_OBJECT,
-                                                                               "text/plain", "",
-                                                                               App.player.current_media.title, ""));
-            new Zeitgeist.Log ().insert_events_no_reply(event);
-#endif
-        }
-
-        if((sec/media_length > 0.50) && (media_half_played_sended == false)) {
-            media_half_played (App.player.current_media);
-            media_half_played_sended = true;
-        }
-
-        // at 80% done with media, add 1 to play count
-        if(sec/media_length > 0.80 && !added_to_play_count) {
-            added_to_play_count = true;
-            App.player.current_media.play_count++;
-            library_manager.update_media (App.player.current_media, false, false);
-        }
-    }
-
-    public void media_not_found(int id) {
-// XXX FIXME TODO Don't depend on ids
-#if 0
-        var not_found = new FileNotFoundDialog(library_manager, this, id);
-        not_found.show();
-#endif
-    }
-
     public void searchFieldActivate() {
         var vw = view_container.get_current_view ();
 
@@ -1253,14 +1159,17 @@
     }
 
     private void on_quit () {
+        int last_media_position = (int) ((double) App.player.get_position () / Numeric.NANO_INV);
+
         // Save media position and info
-        main_settings.last_media_position = (int)((double)App.player.player.get_position
-        ()/Numeric.NANO_INV);
-        if(App.player.current_media != null) {
-            App.player.current_media.resume_pos = (int)((double)App.player.player.get_position()/Numeric.NANO_INV);
+        main_settings.last_media_position = last_media_position;
+
+        if (App.player.current_media != null) {
+            App.player.current_media.resume_pos = last_media_position;
             library_manager.update_media (App.player.current_media, false, false);
         }
-        App.player.player.pause();
+
+        App.player.pause_playback ();
 
         // Now set the selected view
         var saved_state = Settings.SavedState.get_default ();
@@ -1293,7 +1202,7 @@
      * This doesn't apply to calls to App.instance.quit ()
      */
     public override bool delete_event (Gdk.EventAny event) {
-        bool playing = App.player.current_media != null && App.player.playing;
+        bool playing = App.player.current_media != null && App.player.playback_status.is_playing ();
 
         // if playing a song, don't allow closing
         if (!main_settings.close_while_playing && playing) {

=== modified file 'src/LocalBackend/LocalLibrary.vala'
--- src/LocalBackend/LocalLibrary.vala	2015-03-01 16:43:54 +0000
+++ src/LocalBackend/LocalLibrary.vala	2015-04-27 05:07:36 +0000
@@ -162,7 +162,7 @@
 
             App.player.reset_already_played ();
             // FIXME: these are library window's internals. Shouldn't be here
-            App.main_window.update_sensitivities.begin ();
+            App.main_window.update_sensitivities ();
             App.player.stop_playback ();
 
             set_music_folder_thread.begin (folder);
@@ -227,7 +227,7 @@
 
     public void rescan_music_folder () {
         if (start_file_operations (_("Rescanning music for changes. This may take a while…"))) {
-            App.main_window.update_sensitivities.begin ();
+            App.main_window.update_sensitivities ();
             rescan_music_folder_async.begin ();
         }
     }
@@ -298,7 +298,7 @@
         if (open_media_list.size > 0) {
             if (!App.player.playing) {
                 App.player.playMedia (open_media_list.first (), false);
-                App.main_window.play_media ();
+                //XXX not needed App.main_window.play_media ();
             } else {
                 string primary_text = _("Added to your queue:");
 
@@ -726,7 +726,7 @@
 
         NotificationManager.get_default ().update_progress (message, 0.0);
         _doing_file_operations = true;
-        App.main_window.update_sensitivities.begin ();
+        App.main_window.update_sensitivities ();
         file_operations_started ();
         return true;
     }

=== modified file 'src/Objects/MediaKeyListener.vala'
--- src/Objects/MediaKeyListener.vala	2013-12-01 14:35:04 +0000
+++ src/Objects/MediaKeyListener.vala	2015-04-27 05:07:36 +0000
@@ -77,7 +77,7 @@
             App.main_window.play_previous_media ();
         }
         else if(key == "Play") {
-            App.main_window.play_media ();
+            App.main_window.play_pause ();
         }
         else if(key == "Next") {
             App.main_window.play_next_media ();

=== modified file 'src/PlaybackManager.vala'
--- src/PlaybackManager.vala	2015-03-23 04:51:51 +0000
+++ src/PlaybackManager.vala	2015-04-27 05:07:36 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: vala; indent-tabs-mode: nil; tab-width: 4 -*-
 /*-
- * Copyright (c) 2012-2013 Noise Developers (http://launchpad.net/noise)
+ * Copyright (c) 2012-2015 Noise Developers (http://launchpad.net/noise)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ -27,27 +27,13 @@
  *
  * Authored by: Scott Ringwelski <[e-mail]>
  *              Corentin Noël <[e-mail]>
+ *              Victor Martinez <[e-mail]>
  */
 
-public class Noise.PlaybackManager : Object, Noise.Player {
-
-    // TODO: Have a correct implementation based on playlists.
-    //        Show the next 2 medias in the queue when shuffle mode is enabled and create a playlist to remember shuffled songs
-    //        Get the current filter (search, playlist) to be able to store and set it back when restart.
-
-    public signal void current_cleared ();
-
-    public signal void queue_cleared  ();
-    public signal void media_queued (Gee.Collection<Media> queued);
-
-    public signal void media_played (Media played_media);
-    public signal void playback_stopped (int was_playing);
-    public signal void playback_started ();
-    public signal void playback_paused ();
-    public signal void changing_player ();
-    public signal void player_changed ();
-
+public class Noise.PlaybackManager : Object, Player {
+    /*
     private Gee.TreeSet<unowned Noise.Playback> playbacks = new Gee.TreeSet<unowned Noise.Playback> ();
+    */
 
     // id, media of current media.
     private Gee.HashMap<int, Media> _current = new Gee.HashMap<int, Media>();
@@ -55,16 +41,18 @@
     //list of id's yet to be played while on shuffle
     private Gee.HashMap<int, Media> _current_shuffled = new Gee.HashMap<int, Media>();
 
-    public StaticPlaylist queue_playlist = new StaticPlaylist ();
-    public StaticPlaylist history_playlist = new StaticPlaylist ();
+    public StaticPlaylist queue_playlist { get; private set; default = new StaticPlaylist (); }
+    public StaticPlaylist history_playlist { get; private set; default = new StaticPlaylist (); }
 
     // TODO: REWRITE IT USING THE LIBRARY
-    public Library library { get { return libraries_manager.local_library; } }
+    // public Library library { get { return libraries_manager.local_library; } }
 
     private int _current_index;
     private int _current_shuffled_index;
 
-    public bool playing { get; private set; default = false; }
+    [Deprecated (replacement = "playback_status.is_playing ()")]
+    public bool playing { get; private set; default = false; }   
+
     private double saved_volume = 1;
     public double volume {
         get{
@@ -76,28 +64,48 @@
         }
     }
 
-    bool _playing_queued_song;
-
-    public int next_gapless_id;
-
-    public Noise.Streamer file_player;
-    public Noise.Playback player;
-    public Noise.Media current_media { private set; get; }
+    private bool _playing_queued_song;
+
+    public Media current_media { get; private set; }
+    public PlaybackStatus playback_status { get; private set; }
+    private Media? next;
+    private int next_gapless_id;
+    private Streamer file_player;
+    private Playback player;
 
     public PlaybackManager () {
         file_player = new Streamer ();
-        playbacks.add (file_player);
+        // XXX playbacks.add (file_player);
         player = file_player;
         history_playlist.name = _("History");
         history_playlist.read_only = true;
         queue_playlist.name = C_("Name of the playlist", "Queue");
         queue_playlist.read_only = true;
         queue_playlist.allow_duplicate = true;
+
+        player.about_to_finish.connect (media_about_to_finish);
+        player.end_of_stream.connect (media_finished_playing);
     }
 
-    public void add_playback (Noise.Playback playback) {
+/* 
+    public void add_playback (Playback playback) {
         playbacks.add (playback);
     }
+*/
+    private void playback_stopped (int was_playing) {
+        playback_status = PlaybackStatus.STOPPED;
+        status_change (current_media, playback_status);
+    }
+
+    private void playback_started () {
+        playback_status = PlaybackStatus.PLAYING;
+        status_change (current_media, playback_status);
+    }
+
+    private void playback_paused () {
+        playback_status = PlaybackStatus.PAUSED;
+        status_change (current_media, playback_status);
+    }
 
     /*
      * Queue Stuff
@@ -112,17 +120,18 @@
         media_queued (to_queue);
     }
 
+    // TODO deprecate to get rid of circular library dependency
     public void queue_media_by_id (Gee.Collection<int> ids) {
-        queue_media (library.medias_from_ids (ids));
+        queue_media (libraries_manager.local_library.medias_from_ids (ids));
     }
 
-
     public void unqueue_media (Gee.Collection<Media> to_unqueue) {
         queue_playlist.remove_medias (to_unqueue);
     }
 
+    // TODO deprecate to get rid of circular library dependency
     public void unqueue_media_by_id (Gee.Collection<int> ids) {
-        unqueue_media (library.medias_from_ids (ids));        
+        unqueue_media (libraries_manager.local_library.medias_from_ids (ids));        
     }
 
     public Media peek_queue () {
@@ -269,7 +278,61 @@
             }
         }
     }
-    
+
+    public int64 get_position () {
+        return player.get_position ();
+    }
+
+    public void set_position (int64 pos) {
+        player.set_position (pos);
+    }
+
+    public void set_equalizer_gain (int index, int gain) {
+        player.set_equalizer_gain (index, gain);
+    }
+
+    public void play_pause () {
+        if (current_media == null) {
+            debug("No media is currently playing. Starting from the top\n");
+            getNext (true);
+            start_playback ();
+        } else if (playing) {
+            pause_playback ();
+        } else {
+            start_playback ();
+        }
+    }
+
+    private void media_about_to_finish (string about_to_finish_uri) {
+        debug ("About to finish: %s", about_to_finish_uri);
+
+        next = getNext (false);
+
+        if (next != null)
+            player.set_next_media (next);
+        else
+            debug ("No next media.");
+    }
+
+    private void media_finished_playing (string? finished_uri, string? new_uri) {
+        debug ("Finished playing: %s", finished_uri);
+
+        if (next != null && new_uri != next.uri)
+            critical ("Next song does not match URI!");
+
+        // notify media's changed
+        media_played (next);
+    }
+
+    // For gapless playback reasons, this function is only called when the streamer
+    // actually starts playing the media
+    private void media_played (Media? media) {
+        debug ("== MEDIA_PLAYED: %s", media.title);
+        current_media = media;
+        next = null;
+        status_change (current_media, playback_status);
+    }
+
     public Media? getNext(bool play) {
         Media? rv = null;
         
@@ -280,7 +343,8 @@
             _playing_queued_song = true;
         } else if (main_settings.shuffle_mode != Noise.Settings.Shuffle.OFF) {
             if (_current_shuffled.is_empty ) {
-                foreach (Media s in library.get_medias ())
+                // XXX dont depend on library! get a playlist instead
+                foreach (Media s in libraries_manager.local_library.get_medias ())
                     addToCurrent (s);    //first initialize the current selection the reshuffle it
                 reshuffle ();
             }
@@ -371,7 +435,8 @@
                 
                 rv = _current.get (_current_index);
             } else {
-                foreach (Media s in library.get_medias ()) {
+                // XXX dont depend on library! get a playlist instead
+                foreach (Media s in libraries_manager.local_library.get_medias ()) {
                     addToCurrent(s);
                 }
                 
@@ -394,7 +459,8 @@
         var main_settings = Settings.Main.get_default ();
         if(main_settings.shuffle_mode != Noise.Settings.Shuffle.OFF) {
             if (_current_shuffled.is_empty)
-                foreach (Media s in library.get_medias ())
+                // XXX dont depend on library! get a playlist instead
+                foreach (Media s in libraries_manager.local_library.get_medias ())
                     addToCurrent (s);    //first initialize the current selection the reshuffle it
                 reshuffle ();
             _playing_queued_song = false;
@@ -460,7 +526,8 @@
                 
                 rv = _current.get(_current_index);
             } else {
-                foreach(Media s in library.get_medias ())
+                // XXX dont depend on library! get a playlist instead
+                foreach(Media s in libraries_manager.local_library.get_medias ())
                     addToCurrent(s);
                 
                 _current_index = _current.size - 1;
@@ -498,7 +565,8 @@
                 return;
             }
         }
-        
+
+        /* XXX no multiple streamers for now
         var found = false;
         lock (playbacks) {
             foreach (var playback in playbacks) {
@@ -519,12 +587,14 @@
                 }
             }
         }
+
         if (found == false) {
             m.unique_status_image = Icons.PROCESS_ERROR.render(Gtk.IconSize.MENU);
             getNext(true);
             return;
         }
-        
+        */
+
         // check that the file exists
         if (! m.file.query_exists ()) {
             m.unique_status_image = Icons.PROCESS_ERROR.render(Gtk.IconSize.MENU);
@@ -549,11 +619,11 @@
         else {
             next_gapless_id = 0;
         }
-        
+
         //pause if paused
         if (!playing)
             player.pause ();
-        
+
         //update settings
         if (m.rowid >= 0)
             Settings.Main.get_default ().last_media_playing = m.rowid;
@@ -574,7 +644,9 @@
                     int delta_s = (int)player_duration_s - (int)(m.length / Numeric.MILI_INV);
                     if (Math.fabs ((double)delta_s) > 3) {
                         m.length = (uint)(player_duration_s * Numeric.MILI_INV);
-                        library.update_media (m, false, false);
+
+                        // XXX dont depend on library! get a playlist instead
+                        libraries_manager.local_library.update_media (m, false, false);
                     }
                 }
             }

=== modified file 'src/Views/ListView/Lists/GenericList.vala'
--- src/Views/ListView/Lists/GenericList.vala	2015-03-01 16:43:54 +0000
+++ src/Views/ListView/Lists/GenericList.vala	2015-04-27 05:07:36 +0000
@@ -38,6 +38,8 @@
 
     protected CellDataFunctionHelper cell_data_helper;
 
+    private unowned Media current_media;
+
     public GenericList (ViewWrapper view_wrapper, TreeViewSetup tvs) {
         var types = new Gee.LinkedList<Type> ();
         foreach (var type in ListColumn.get_all ())
@@ -93,7 +95,15 @@
         parent_wrapper.library.media_updated.connect (media_updated);
 
         App.player.current_cleared.connect (current_cleared);
-        App.player.media_played.connect (media_played);
+        App.player.status_change.connect (on_playback_status_change);
+    }
+
+    private void on_playback_status_change (Media? current_media, PlaybackStatus status) {
+        if (this.current_media == current_media)
+            return;
+
+        this.current_media = current_media;
+        media_played (current_media);
     }
 
     protected abstract void mediaRemoveClicked ();
@@ -276,8 +286,8 @@
         // Now play the song
         App.player.playMedia (m, false);
 
-        if (!App.player.playing) {
-            App.main_window.play_media ();
+        if (!App.player.playback_status.is_playing ()) {
+            App.main_window.play_pause ();
         }
     }
 

=== modified file 'src/Widgets/EqualizerPopover.vala'
--- src/Widgets/EqualizerPopover.vala	2014-03-23 22:17:09 +0000
+++ src/Widgets/EqualizerPopover.vala	2015-04-27 05:07:36 +0000
@@ -191,7 +191,7 @@
 	}
 
 	private void apply_equalizer_gain (int index, int val) {
-		App.player.player.set_equalizer_gain (index, val);
+		App.player.set_equalizer_gain (index, val);
 	}
 
 	private void apply_automatic_gains () {
@@ -420,4 +420,4 @@
 	private void remove_preset_clicked () {
 		preset_combo.removeCurrentPreset ();
 	}
-}
\ No newline at end of file
+}

=== modified file 'src/Widgets/InfoPanel.vala'
--- src/Widgets/InfoPanel.vala	2015-03-01 16:43:54 +0000
+++ src/Widgets/InfoPanel.vala	2015-04-27 05:07:36 +0000
@@ -23,7 +23,6 @@
 public class Noise.InfoPanel : Gtk.EventBox {
     public signal void to_update();
 
-    public unowned Media current_media { get { return App.player.current_media; } }
     public bool can_show_up { get { return App.player.current_media != null; } }
 
     private Gtk.Label title;
@@ -36,15 +35,13 @@
     private Gtk.Grid container;
     
     private const string TITLE_MARKUP = "<span size=\"large\"><b>%s</b></span>";
-
+    private unowned Media current_media;
 
     public InfoPanel () {
-
         buildUI();
 
-        App.player.media_played.connect_after (on_media_updated);
-        libraries_manager.local_library.media_updated.connect_after (on_media_updated);
-        NotificationManager.get_default ().update_track.connect (on_media_updated);
+        App.player.status_change.connect_after (on_media_changed);
+        NotificationManager.get_default ().update_track.connect (update_current_media);
         CoverartCache.instance.changed.connect_after (update_cover_art);
     }
     
@@ -116,7 +113,22 @@
         to_update ();
     }
 
-    private void on_media_updated () {
+    private void on_media_changed (Media? current_media, PlaybackStatus status) {
+        if (this.current_media == current_media)
+            return;
+    
+        // unset previous media
+        if (this.current_media != null)
+            this.current_media.updated.disconnect (update_current_media);
+
+        // change media to new one
+        this.current_media = current_media;
+        current_media.updated.connect (update_current_media);
+
+        update_current_media ();
+    }
+
+    private void update_current_media () {
         update_visibilities ();
         update_metadata ();
         update_cover_art ();

=== modified file 'src/Widgets/TopDisplay.vala'
--- src/Widgets/TopDisplay.vala	2015-03-12 02:43:20 +0000
+++ src/Widgets/TopDisplay.vala	2015-04-27 05:07:36 +0000
@@ -21,6 +21,8 @@
  */
 
 public class Noise.TopDisplay : Gtk.Stack {
+    private const int PLAYBACK_POSITION_REFRESH_HZ = 5;
+
     MusicListView list_view;
 
     Gtk.Grid empty_grid;
@@ -42,6 +44,8 @@
     private bool is_seeking = false;
     private uint change_timeout_id = 0;
     private uint progress_timeout_id = 0;
+    private uint playback_timeout_id = 0;
+    private unowned Media current_media;
 
     public signal void scale_value_changed (Gtk.ScrollType scroll, double val);
 
@@ -123,16 +127,6 @@
         scale.value_changed.connect (value_changed);
         scale.change_value.connect (change_value);
 
-        App.player.player.current_position_update.connect (player_position_update);
-
-        App.player.changing_player.connect (() => {
-            App.player.player.current_position_update.disconnect (player_position_update);
-        });
-
-        App.player.player_changed.connect (() => {
-            App.player.player.current_position_update.connect (player_position_update);
-        });
-
         var notification_manager = NotificationManager.get_default ();
         notification_manager.update_progress.connect ((message, progress) => {
             set_progress_value (progress);
@@ -144,7 +138,7 @@
             track_label.set_markup (message);
         });
 
-        libraries_manager.local_library.media_updated.connect (media_updated);
+        start_polling_position ();
     }
 
     public override void get_preferred_width (out int minimum_width, out int natural_width) {
@@ -181,7 +175,6 @@
             return true;
         }
 
-        App.player.player.current_position_update.disconnect (player_position_update);
         is_seeking = true;
         change_value (Gtk.ScrollType.NONE, get_current_time ());
 
@@ -230,8 +223,19 @@
         rightTime.set_text (TimeUtils.pretty_length_from_ms (media_duration_secs - elapsed_secs));
     }
 
+    private void start_polling_position () {
+        playback_timeout_id = Timeout.add (1000 / PLAYBACK_POSITION_REFRESH_HZ, update_time_position);
+    }
+
+    private void stop_polling_position () {
+        if (playback_timeout_id > 0)
+            Source.remove (playback_timeout_id);
+
+        playback_timeout_id = 0;
+    }
+
     public virtual bool change_value (Gtk.ScrollType scroll, double val) {
-        App.player.player.current_position_update.disconnect(player_position_update);
+        stop_polling_position ();
         scale.set_value(val);
         scale_value_changed(scroll, val);
 
@@ -240,8 +244,8 @@
 
         change_timeout_id = Timeout.add (300, () => {
             if (!is_seeking) {
-                App.player.player.set_position((int64) TimeUtils.miliseconds_to_nanoseconds ((uint) val));
-                App.player.player.current_position_update.connect(player_position_update);
+                App.player.set_position ((int64) TimeUtils.miliseconds_to_nanoseconds ((uint) val));
+                start_polling_position ();
             }
 
             change_timeout_id = 0;
@@ -251,14 +255,22 @@
         return false;
     }
 
-    public virtual void player_position_update (int64 position) {
-        if (App.player.current_media != null) {
-            scale.set_value ((double) TimeUtils.nanoseconds_to_miliseconds (position));
-        }
+    public virtual bool update_time_position () {
+        int64 position = App.player.get_position ();
+        scale.set_value ((double) TimeUtils.nanoseconds_to_miliseconds (position));
+        return true;
     }
 
-    public void set_media (Media current_media) {
+    public void set_media (Media? current_media) {
+        // unset previous media
+        if (this.current_media != null)
+            this.current_media.updated.disconnect (update_current_media);
+
+        this.current_media = current_media;
+        current_media.updated.connect (update_current_media);
+        
         update_current_media ();
+
         // If the media changes while an action is goind, show it for 5 seconds then come back to the action.
         if (progressbar.fraction >= 0.0 && progressbar.fraction < 1.0) {
             progress_timeout_id = Timeout.add (300, () => {
@@ -269,12 +281,6 @@
         }
     }
 
-    private void media_updated (Gee.Collection<int> ids) {
-        if (App.player.current_media != null && ids.contains (App.player.current_media.rowid)) {
-            update_current_media ();
-        }
-    }
-
     private void update_current_media () {
         var notification_manager = NotificationManager.get_default ();
         if (App.player.current_media == null)
@@ -285,6 +291,7 @@
         if (m == null)
             return;
 
+        // XXX does this belong here?
         notification_manager.update_track (m.get_title_markup ());
         set_max_time ((double) m.length);
         set_visible_child (time_eventbox);