player_control: removed the global variable "pc"

Allocate a player_control object where needed, and pass it around.
Each "client" object is associated with a "player_control" instance.

This prepares multi-player support.

12 files changed, 224 insertions, 158 deletions

diff --git a/src/playlist.c b/src/playlist.c
index 4a1e54814..d45e7622a 100644
--- a/src/playlist.c
+++ b/src/playlist.c
@@ -75,7 +75,8 @@ playlist_finish(struct playlist *playlist)
  * Queue a song, addressed by its order number.
  */
 static void
-playlist_queue_song_order(struct playlist *playlist, unsigned order)
+playlist_queue_song_order(struct playlist *playlist, struct player_control *pc,
+			  unsigned order)
 {
 	struct song *song;
 	char *uri;
@@ -89,16 +90,16 @@ playlist_queue_song_order(struct playlist *playlist, unsigned order)
 	g_debug("queue song %i:\"%s\"", playlist->queued, uri);
 	g_free(uri);
 
-	pc_enqueue_song(song);
+	pc_enqueue_song(pc, song);
 }
 
 /**
  * Called if the player thread has started playing the "queued" song.
  */
 static void
-playlist_song_started(struct playlist *playlist)
+playlist_song_started(struct playlist *playlist, struct player_control *pc)
 {
-	assert(pc.next_song == NULL);
+	assert(pc->next_song == NULL);
 	assert(playlist->queued >= -1);
 
 	/* queued song has started: copy queued to current,
@@ -110,11 +111,13 @@ playlist_song_started(struct playlist *playlist)
 
 	/* Pause if we are in single mode. */
 	if(playlist->queue.single && !playlist->queue.repeat) {
-		pc_set_pause(true);
+		pc_set_pause(pc, true);
 	}
 
 	if(playlist->queue.consume)
-		playlist_delete(playlist, queue_order_to_position(&playlist->queue, current));
+		playlist_delete(playlist, pc,
+				queue_order_to_position(&playlist->queue,
+							current));
 
 	idle_add(IDLE_PLAYER);
 }
@@ -129,7 +132,9 @@ playlist_get_queued_song(struct playlist *playlist)
 }
 
 void
-playlist_update_queued_song(struct playlist *playlist, const struct song *prev)
+playlist_update_queued_song(struct playlist *playlist,
+			    struct player_control *pc,
+			    const struct song *prev)
 {
 	int next_order;
 	const struct song *next_song;
@@ -170,20 +175,21 @@ playlist_update_queued_song(struct playlist *playlist, const struct song *prev)
 
 	if (prev != NULL && next_song != prev) {
 		/* clear the currently queued song */
-		pc_cancel();
+		pc_cancel(pc);
 		playlist->queued = -1;
 	}
 
 	if (next_order >= 0) {
 		if (next_song != prev)
-			playlist_queue_song_order(playlist, next_order);
+			playlist_queue_song_order(playlist, pc, next_order);
 		else
 			playlist->queued = next_order;
 	}
 }
 
 void
-playlist_play_order(struct playlist *playlist, int orderNum)
+playlist_play_order(struct playlist *playlist, struct player_control *pc,
+		    int orderNum)
 {
 	struct song *song;
 	char *uri;
@@ -197,46 +203,46 @@ playlist_play_order(struct playlist *playlist, int orderNum)
 	g_debug("play %i:\"%s\"", orderNum, uri);
 	g_free(uri);
 
-	pc_play(song);
+	pc_play(pc, song);
 	playlist->current = orderNum;
 }
 
 static void
-playlist_resume_playback(struct playlist *playlist);
+playlist_resume_playback(struct playlist *playlist, struct player_control *pc);
 
 /**
  * This is the "PLAYLIST" event handler.  It is invoked by the player
  * thread whenever it requests a new queued song, or when it exits.
  */
 void
-playlist_sync(struct playlist *playlist)
+playlist_sync(struct playlist *playlist, struct player_control *pc)
 {
 	if (!playlist->playing)
 		/* this event has reached us out of sync: we aren't
 		   playing anymore; ignore the event */
 		return;
 
-	player_lock();
-	enum player_state pc_state = pc_get_state();
-	const struct song *pc_next_song = pc.next_song;
-	player_unlock();
+	player_lock(pc);
+	enum player_state pc_state = pc_get_state(pc);
+	const struct song *pc_next_song = pc->next_song;
+	player_unlock(pc);
 
 	if (pc_state == PLAYER_STATE_STOP)
 		/* the player thread has stopped: check if playback
 		   should be restarted with the next song.  That can
 		   happen if the playlist isn't filling the queue fast
 		   enough */
-		playlist_resume_playback(playlist);
+		playlist_resume_playback(playlist, pc);
 	else {
 		/* check if the player thread has already started
 		   playing the queued song */
 		if (pc_next_song == NULL && playlist->queued != -1)
-			playlist_song_started(playlist);
+			playlist_song_started(playlist, pc);
 
 		/* make sure the queued song is always set (if
 		   possible) */
-		if (pc.next_song == NULL && playlist->queued < 0)
-			playlist_update_queued_song(playlist, NULL);
+		if (pc->next_song == NULL && playlist->queued < 0)
+			playlist_update_queued_song(playlist, pc, NULL);
 	}
 }
 
@@ -245,14 +251,14 @@ playlist_sync(struct playlist *playlist)
  * decide whether to re-start playback
  */
 static void
-playlist_resume_playback(struct playlist *playlist)
+playlist_resume_playback(struct playlist *playlist, struct player_control *pc)
 {
 	enum player_error error;
 
 	assert(playlist->playing);
-	assert(pc_get_state() == PLAYER_STATE_STOP);
+	assert(pc_get_state(pc) == PLAYER_STATE_STOP);
 
-	error = pc_get_error();
+	error = pc_get_error(pc);
 	if (error == PLAYER_ERROR_NOERROR)
 		playlist->error_count = 0;
 	else
@@ -263,10 +269,10 @@ playlist_resume_playback(struct playlist *playlist)
 	    playlist->error_count >= queue_length(&playlist->queue))
 		/* too many errors, or critical error: stop
 		   playback */
-		playlist_stop(playlist);
+		playlist_stop(playlist, pc);
 	else
 		/* continue playback at the next song */
-		playlist_next(playlist);
+		playlist_next(playlist, pc);
 }
 
 bool
@@ -294,7 +300,8 @@ playlist_get_consume(const struct playlist *playlist)
 }
 
 void
-playlist_set_repeat(struct playlist *playlist, bool status)
+playlist_set_repeat(struct playlist *playlist, struct player_control *pc,
+		    bool status)
 {
 	if (status == playlist->queue.repeat)
 		return;
@@ -303,7 +310,7 @@ playlist_set_repeat(struct playlist *playlist, bool status)
 
 	/* if the last song is currently being played, the "next song"
 	   might change when repeat mode is toggled */
-	playlist_update_queued_song(playlist,
+	playlist_update_queued_song(playlist, pc,
 				    playlist_get_queued_song(playlist));
 
 	idle_add(IDLE_OPTIONS);
@@ -321,7 +328,8 @@ playlist_order(struct playlist *playlist)
 }
 
 void
-playlist_set_single(struct playlist *playlist, bool status)
+playlist_set_single(struct playlist *playlist, struct player_control *pc,
+		    bool status)
 {
 	if (status == playlist->queue.single)
 		return;
@@ -330,7 +338,7 @@ playlist_set_single(struct playlist *playlist, bool status)
 
 	/* if the last song is currently being played, the "next song"
 	   might change when single mode is toggled */
-	playlist_update_queued_song(playlist,
+	playlist_update_queued_song(playlist, pc,
 				    playlist_get_queued_song(playlist));
 
 	idle_add(IDLE_OPTIONS);
@@ -347,7 +355,8 @@ playlist_set_consume(struct playlist *playlist, bool status)
 }
 
 void
-playlist_set_random(struct playlist *playlist, bool status)
+playlist_set_random(struct playlist *playlist, struct player_control *pc,
+		    bool status)
 {
 	const struct song *queued;
 
@@ -384,7 +393,7 @@ playlist_set_random(struct playlist *playlist, bool status)
 	} else
 		playlist_order(playlist);
 
-	playlist_update_queued_song(playlist, queued);
+	playlist_update_queued_song(playlist, pc, queued);
 
 	idle_add(IDLE_OPTIONS);
 }
diff --git a/src/playlist.h b/src/playlist.h
index 3ba90ff91..e1e6eff85 100644
--- a/src/playlist.h
+++ b/src/playlist.h
@@ -26,6 +26,8 @@
 
 #define PLAYLIST_COMMENT	'#'
 
+struct player_control;
+
 enum playlist_result {
 	PLAYLIST_RESULT_SUCCESS,
 	PLAYLIST_RESULT_ERRNO,
@@ -111,7 +113,7 @@ playlist_get_queue(const struct playlist *playlist)
 }
 
 void
-playlist_clear(struct playlist *playlist);
+playlist_clear(struct playlist *playlist, struct player_control *pc);
 
 #ifndef WIN32
 /**
@@ -119,20 +121,21 @@ playlist_clear(struct playlist *playlist);
  * but only if the file's owner is equal to the specified uid.
  */
 enum playlist_result
-playlist_append_file(struct playlist *playlist, const char *path, int uid,
-		     unsigned *added_id);
+playlist_append_file(struct playlist *playlist, struct player_control *pc,
+		     const char *path, int uid, unsigned *added_id);
 #endif
 
 enum playlist_result
-playlist_append_uri(struct playlist *playlist, const char *file,
-		    unsigned *added_id);
+playlist_append_uri(struct playlist *playlist, struct player_control *pc,
+		    const char *file, unsigned *added_id);
 
 enum playlist_result
-playlist_append_song(struct playlist *playlist,
+playlist_append_song(struct playlist *playlist, struct player_control *pc,
 		  struct song *song, unsigned *added_id);
 
 enum playlist_result
-playlist_delete(struct playlist *playlist, unsigned song);
+playlist_delete(struct playlist *playlist, struct player_control *pc,
+		unsigned song);
 
 /**
  * Deletes a range of songs from the playlist.
@@ -141,64 +144,77 @@ playlist_delete(struct playlist *playlist, unsigned song);
  * @param end the position after the last song to delete
  */
 enum playlist_result
-playlist_delete_range(struct playlist *playlist, unsigned start, unsigned end);
+playlist_delete_range(struct playlist *playlist, struct player_control *pc,
+		      unsigned start, unsigned end);
 
 enum playlist_result
-playlist_delete_id(struct playlist *playlist, unsigned song);
+playlist_delete_id(struct playlist *playlist, struct player_control *pc,
+		   unsigned song);
 
 void
-playlist_stop(struct playlist *playlist);
+playlist_stop(struct playlist *playlist, struct player_control *pc);
 
 enum playlist_result
-playlist_play(struct playlist *playlist, int song);
+playlist_play(struct playlist *playlist, struct player_control *pc,
+	      int song);
 
 enum playlist_result
-playlist_play_id(struct playlist *playlist, int song);
+playlist_play_id(struct playlist *playlist, struct player_control *pc,
+		 int song);
 
 void
-playlist_next(struct playlist *playlist);
+playlist_next(struct playlist *playlist, struct player_control *pc);
 
 void
-playlist_sync(struct playlist *playlist);
+playlist_sync(struct playlist *playlist, struct player_control *pc);
 
 void
-playlist_previous(struct playlist *playlist);
+playlist_previous(struct playlist *playlist, struct player_control *pc);
 
 void
-playlist_shuffle(struct playlist *playlist, unsigned start, unsigned end);
+playlist_shuffle(struct playlist *playlist, struct player_control *pc,
+		 unsigned start, unsigned end);
 
 void
-playlist_delete_song(struct playlist *playlist, const struct song *song);
+playlist_delete_song(struct playlist *playlist, struct player_control *pc,
+		     const struct song *song);
 
 enum playlist_result
-playlist_move_range(struct playlist *playlist, unsigned start, unsigned end, int to);
+playlist_move_range(struct playlist *playlist, struct player_control *pc,
+		    unsigned start, unsigned end, int to);
 
 enum playlist_result
-playlist_move_id(struct playlist *playlist, unsigned id, int to);
+playlist_move_id(struct playlist *playlist, struct player_control *pc,
+		 unsigned id, int to);
 
 enum playlist_result
-playlist_swap_songs(struct playlist *playlist, unsigned song1, unsigned song2);
+playlist_swap_songs(struct playlist *playlist, struct player_control *pc,
+		    unsigned song1, unsigned song2);
 
 enum playlist_result
-playlist_swap_songs_id(struct playlist *playlist, unsigned id1, unsigned id2);
+playlist_swap_songs_id(struct playlist *playlist, struct player_control *pc,
+		       unsigned id1, unsigned id2);
 
 bool
 playlist_get_repeat(const struct playlist *playlist);
 
 void
-playlist_set_repeat(struct playlist *playlist, bool status);
+playlist_set_repeat(struct playlist *playlist, struct player_control *pc,
+		    bool status);
 
 bool
 playlist_get_random(const struct playlist *playlist);
 
 void
-playlist_set_random(struct playlist *playlist, bool status);
+playlist_set_random(struct playlist *playlist, struct player_control *pc,
+		    bool status);
 
 bool
 playlist_get_single(const struct playlist *playlist);
 
 void
-playlist_set_single(struct playlist *playlist, bool status);
+playlist_set_single(struct playlist *playlist, struct player_control *pc,
+		    bool status);
 
 bool
 playlist_get_consume(const struct playlist *playlist);
@@ -222,10 +238,11 @@ unsigned long
 playlist_get_version(const struct playlist *playlist);
 
 enum playlist_result
-playlist_seek_song(struct playlist *playlist, unsigned song, float seek_time);
+playlist_seek_song(struct playlist *playlist, struct player_control *pc,
+		   unsigned song, float seek_time);
 
 enum playlist_result
-playlist_seek_song_id(struct playlist *playlist,
+playlist_seek_song_id(struct playlist *playlist, struct player_control *pc,
 		       unsigned id, float seek_time);
 
 void
diff --git a/src/playlist_control.c b/src/playlist_control.c
index ce9bc8442..c3592dab0 100644
--- a/src/playlist_control.c
+++ b/src/playlist_control.c
@@ -32,7 +32,8 @@
 #undef G_LOG_DOMAIN
 #define G_LOG_DOMAIN "playlist"
 
-void playlist_stop(struct playlist *playlist)
+void
+playlist_stop(struct playlist *playlist, struct player_control *pc)
 {
 	if (!playlist->playing)
 		return;
@@ -40,7 +41,7 @@ void playlist_stop(struct playlist *playlist)
 	assert(playlist->current >= 0);
 
 	g_debug("stop");
-	pc_stop();
+	pc_stop(pc);
 	playlist->queued = -1;
 	playlist->playing = false;
 
@@ -62,11 +63,13 @@ void playlist_stop(struct playlist *playlist)
 	}
 }
 
-enum playlist_result playlist_play(struct playlist *playlist, int song)
+enum playlist_result
+playlist_play(struct playlist *playlist, struct player_control *pc,
+	      int song)
 {
 	unsigned i = song;
 
-	pc_clear_error();
+	pc_clear_error(pc);
 
 	if (song == -1) {
 		/* play any song ("current" song, or the first song */
@@ -77,7 +80,7 @@ enum playlist_result playlist_play(struct playlist *playlist, int song)
 		if (playlist->playing) {
 			/* already playing: unpause playback, just in
 			   case it was paused, and return */
-			pc_set_pause(false);
+			pc_set_pause(pc, false);
 			return PLAYLIST_RESULT_SUCCESS;
 		}
 
@@ -109,28 +112,29 @@ enum playlist_result playlist_play(struct playlist *playlist, int song)
 	playlist->stop_on_error = false;
 	playlist->error_count = 0;
 
-	playlist_play_order(playlist, i);
+	playlist_play_order(playlist, pc, i);
 	return PLAYLIST_RESULT_SUCCESS;
 }
 
 enum playlist_result
-playlist_play_id(struct playlist *playlist, int id)
+playlist_play_id(struct playlist *playlist, struct player_control *pc,
+		 int id)
 {
 	int song;
 
 	if (id == -1) {
-		return playlist_play(playlist, id);
+		return playlist_play(playlist, pc, id);
 	}
 
 	song = queue_id_to_position(&playlist->queue, id);
 	if (song < 0)
 		return PLAYLIST_RESULT_NO_SUCH_SONG;
 
-	return playlist_play(playlist, song);
+	return playlist_play(playlist, pc, song);
 }
 
 void
-playlist_next(struct playlist *playlist)
+playlist_next(struct playlist *playlist, struct player_control *pc)
 {
 	int next_order;
 	int current;
@@ -149,7 +153,7 @@ playlist_next(struct playlist *playlist)
 	next_order = queue_next_order(&playlist->queue, playlist->current);
 	if (next_order < 0) {
 		/* no song after this one: stop playback */
-		playlist_stop(playlist);
+		playlist_stop(playlist, pc);
 
 		/* reset "current song" */
 		playlist->current = -1;
@@ -170,15 +174,18 @@ playlist_next(struct playlist *playlist)
 			   discard them anyway */
 		}
 
-		playlist_play_order(playlist, next_order);
+		playlist_play_order(playlist, pc, next_order);
 	}
 
 	/* Consume mode removes each played songs. */
 	if(playlist->queue.consume)
-		playlist_delete(playlist, queue_order_to_position(&playlist->queue, current));
+		playlist_delete(playlist, pc,
+				queue_order_to_position(&playlist->queue,
+							current));
 }
 
-void playlist_previous(struct playlist *playlist)
+void
+playlist_previous(struct playlist *playlist, struct player_control *pc)
 {
 	if (!playlist->playing)
 		return;
@@ -187,21 +194,22 @@ void playlist_previous(struct playlist *playlist)
 
 	if (playlist->current > 0) {
 		/* play the preceding song */
-		playlist_play_order(playlist,
+		playlist_play_order(playlist, pc,
 				    playlist->current - 1);
 	} else if (playlist->queue.repeat) {
 		/* play the last song in "repeat" mode */
-		playlist_play_order(playlist,
+		playlist_play_order(playlist, pc,
 				    queue_length(&playlist->queue) - 1);
 	} else {
 		/* re-start playing the current song if it's
 		   the first one */
-		playlist_play_order(playlist, playlist->current);
+		playlist_play_order(playlist, pc, playlist->current);
 	}
 }
 
 enum playlist_result
-playlist_seek_song(struct playlist *playlist, unsigned song, float seek_time)
+playlist_seek_song(struct playlist *playlist, struct player_control *pc,
+		   unsigned song, float seek_time)
 {
 	const struct song *queued;
 	unsigned i;
@@ -217,7 +225,7 @@ playlist_seek_song(struct playlist *playlist, unsigned song, float seek_time)
 	else
 		i = song;
 
-	pc_clear_error();
+	pc_clear_error(pc);
 	playlist->stop_on_error = true;
 	playlist->error_count = 0;
 
@@ -225,29 +233,30 @@ playlist_seek_song(struct playlist *playlist, unsigned song, float seek_time)
 		/* seeking is not within the current song - first
 		   start playing the new song */
 
-		playlist_play_order(playlist, i);
+		playlist_play_order(playlist, pc, i);
 		queued = NULL;
 	}
 
-	success = pc_seek(queue_get_order(&playlist->queue, i), seek_time);
+	success = pc_seek(pc, queue_get_order(&playlist->queue, i), seek_time);
 	if (!success) {
-		playlist_update_queued_song(playlist, queued);
+		playlist_update_queued_song(playlist, pc, queued);
 
 		return PLAYLIST_RESULT_NOT_PLAYING;
 	}
 
 	playlist->queued = -1;
-	playlist_update_queued_song(playlist, NULL);
+	playlist_update_queued_song(playlist, pc, NULL);
 
 	return PLAYLIST_RESULT_SUCCESS;
 }
 
 enum playlist_result
-playlist_seek_song_id(struct playlist *playlist, unsigned id, float seek_time)
+playlist_seek_song_id(struct playlist *playlist, struct player_control *pc,
+		      unsigned id, float seek_time)
 {
 	int song = queue_id_to_position(&playlist->queue, id);
 	if (song < 0)
 		return PLAYLIST_RESULT_NO_SUCH_SONG;
 
-	return playlist_seek_song(playlist, song, seek_time);
+	return playlist_seek_song(playlist, pc, song, seek_time);
 }
diff --git a/src/playlist_edit.c b/src/playlist_edit.c
index c54b72750..e61c2a603 100644
--- a/src/playlist_edit.c
+++ b/src/playlist_edit.c
@@ -43,16 +43,17 @@ static void playlist_increment_version(struct playlist *playlist)
 	idle_add(IDLE_PLAYLIST);
 }
 
-void playlist_clear(struct playlist *playlist)
+void
+playlist_clear(struct playlist *playlist, struct player_control *pc)
 {
-	playlist_stop(playlist);
+	playlist_stop(playlist, pc);
 
 	/* make sure there are no references to allocated songs
 	   anymore */
 	for (unsigned i = 0; i < queue_length(&playlist->queue); i++) {
 		const struct song *song = queue_get(&playlist->queue, i);
 		if (!song_in_database(song))
-			pc_song_deleted(song);
+			pc_song_deleted(pc, song);
 	}
 
 	queue_clear(&playlist->queue);
@@ -64,8 +65,8 @@ void playlist_clear(struct playlist *playlist)
 
 #ifndef WIN32
 enum playlist_result
-playlist_append_file(struct playlist *playlist, const char *path, int uid,
-		     unsigned *added_id)
+playlist_append_file(struct playlist *playlist, struct player_control *pc,
+		     const char *path, int uid, unsigned *added_id)
 {
 	int ret;
 	struct stat st;
@@ -87,12 +88,12 @@ playlist_append_file(struct playlist *playlist, const char *path, int uid,
 	if (song == NULL)
 		return PLAYLIST_RESULT_NO_SUCH_SONG;
 
-	return playlist_append_song(playlist, song, added_id);
+	return playlist_append_song(playlist, pc, song, added_id);
 }
 #endif
 
 enum playlist_result
-playlist_append_song(struct playlist *playlist,
+playlist_append_song(struct playlist *playlist, struct player_control *pc,
 		  struct song *song, unsigned *added_id)
 {
 	const struct song *queued;
@@ -121,7 +122,7 @@ playlist_append_song(struct playlist *playlist,
 
 	playlist_increment_version(playlist);
 
-	playlist_update_queued_song(playlist, queued);
+	playlist_update_queued_song(playlist, pc, queued);
 
 	if (added_id)
 		*added_id = id;
@@ -145,8 +146,8 @@ song_by_uri(const char *uri)
 }
 
 enum playlist_result
-playlist_append_uri(struct playlist *playlist, const char *uri,
-		    unsigned *added_id)
+playlist_append_uri(struct playlist *playlist, struct player_control *pc,
+		    const char *uri, unsigned *added_id)
 {
 	struct song *song;
 
@@ -156,11 +157,12 @@ playlist_append_uri(struct playlist *playlist, const char *uri,
 	if (song == NULL)
 		return PLAYLIST_RESULT_NO_SUCH_SONG;
 
-	return playlist_append_song(playlist, song, added_id);
+	return playlist_append_song(playlist, pc, song, added_id);
 }
 
 enum playlist_result
-playlist_swap_songs(struct playlist *playlist, unsigned song1, unsigned song2)
+playlist_swap_songs(struct playlist *playlist, struct player_control *pc,
+		    unsigned song1, unsigned song2)
 {
 	const struct song *queued;
 
@@ -192,13 +194,14 @@ playlist_swap_songs(struct playlist *playlist, unsigned song1, unsigned song2)
 
 	playlist_increment_version(playlist);
 
-	playlist_update_queued_song(playlist, queued);
+	playlist_update_queued_song(playlist, pc, queued);
 
 	return PLAYLIST_RESULT_SUCCESS;
 }
 
 enum playlist_result
-playlist_swap_songs_id(struct playlist *playlist, unsigned id1, unsigned id2)
+playlist_swap_songs_id(struct playlist *playlist, struct player_control *pc,
+		       unsigned id1, unsigned id2)
 {
 	int song1 = queue_id_to_position(&playlist->queue, id1);
 	int song2 = queue_id_to_position(&playlist->queue, id2);
@@ -206,12 +209,12 @@ playlist_swap_songs_id(struct playlist *playlist, unsigned id1, unsigned id2)
 	if (song1 < 0 || song2 < 0)
 		return PLAYLIST_RESULT_NO_SUCH_SONG;
 
-	return playlist_swap_songs(playlist, song1, song2);
+	return playlist_swap_songs(playlist, pc, song1, song2);
 }
 
 static void
-playlist_delete_internal(struct playlist *playlist, unsigned song,
-			 const struct song **queued_p)
+playlist_delete_internal(struct playlist *playlist, struct player_control *pc,
+			 unsigned song, const struct song **queued_p)
 {
 	unsigned songOrder;
 
@@ -220,11 +223,11 @@ playlist_delete_internal(struct playlist *playlist, unsigned song,
 	songOrder = queue_position_to_order(&playlist->queue, song);
 
 	if (playlist->playing && playlist->current == (int)songOrder) {
-		bool paused = pc_get_state() == PLAYER_STATE_PAUSE;
+		bool paused = pc_get_state(pc) == PLAYER_STATE_PAUSE;
 
 		/* the current song is going to be deleted: stop the player */
 
-		pc_stop();
+		pc_stop(pc);
 		playlist->playing = false;
 
 		/* see which song is going to be played instead */
@@ -236,11 +239,11 @@ playlist_delete_internal(struct playlist *playlist, unsigned song,
 
 		if (playlist->current >= 0 && !paused)
 			/* play the song after the deleted one */
-			playlist_play_order(playlist, playlist->current);
+			playlist_play_order(playlist, pc, playlist->current);
 		else
 			/* no songs left to play, stop playback
 			   completely */
-			playlist_stop(playlist);
+			playlist_stop(playlist, pc);
 
 		*queued_p = NULL;
 	} else if (playlist->current == (int)songOrder)
@@ -251,7 +254,7 @@ playlist_delete_internal(struct playlist *playlist, unsigned song,
 	/* now do it: remove the song */
 
 	if (!song_in_database(queue_get(&playlist->queue, song)))
-		pc_song_deleted(queue_get(&playlist->queue, song));
+		pc_song_deleted(pc, queue_get(&playlist->queue, song));
 
 	queue_delete(&playlist->queue, song);
 
@@ -263,7 +266,8 @@ playlist_delete_internal(struct playlist *playlist, unsigned song,
 }
 
 enum playlist_result
-playlist_delete(struct playlist *playlist, unsigned song)
+playlist_delete(struct playlist *playlist, struct player_control *pc,
+		unsigned song)
 {
 	const struct song *queued;
 
@@ -272,16 +276,17 @@ playlist_delete(struct playlist *playlist, unsigned song)
 
 	queued = playlist_get_queued_song(playlist);
 
-	playlist_delete_internal(playlist, song, &queued);
+	playlist_delete_internal(playlist, pc, song, &queued);
 
 	playlist_increment_version(playlist);
-	playlist_update_queued_song(playlist, queued);
+	playlist_update_queued_song(playlist, pc, queued);
 
 	return PLAYLIST_RESULT_SUCCESS;
 }
 
 enum playlist_result
-playlist_delete_range(struct playlist *playlist, unsigned start, unsigned end)
+playlist_delete_range(struct playlist *playlist, struct player_control *pc,
+		      unsigned start, unsigned end)
 {
 	const struct song *queued;
 
@@ -297,37 +302,39 @@ playlist_delete_range(struct playlist *playlist, unsigned start, unsigned end)
 	queued = playlist_get_queued_song(playlist);
 
 	do {
-		playlist_delete_internal(playlist, --end, &queued);
+		playlist_delete_internal(playlist, pc, --end, &queued);
 	} while (end != start);
 
 	playlist_increment_version(playlist);
-	playlist_update_queued_song(playlist, queued);
+	playlist_update_queued_song(playlist, pc, queued);
 
 	return PLAYLIST_RESULT_SUCCESS;
 }
 
 enum playlist_result
-playlist_delete_id(struct playlist *playlist, unsigned id)
+playlist_delete_id(struct playlist *playlist, struct player_control *pc,
+		   unsigned id)
 {
 	int song = queue_id_to_position(&playlist->queue, id);
 	if (song < 0)
 		return PLAYLIST_RESULT_NO_SUCH_SONG;
 
-	return playlist_delete(playlist, song);
+	return playlist_delete(playlist, pc, song);
 }
 
 void
-playlist_delete_song(struct playlist *playlist, const struct song *song)
+playlist_delete_song(struct playlist *playlist, struct player_control *pc,
+		     const struct song *song)
 {
 	for (int i = queue_length(&playlist->queue) - 1; i >= 0; --i)
 		if (song == queue_get(&playlist->queue, i))
-			playlist_delete(playlist, i);
+			playlist_delete(playlist, pc, i);
 
-	pc_song_deleted(song);
+	pc_song_deleted(pc, song);
 }
 
 enum playlist_result
-playlist_move_range(struct playlist *playlist,
+playlist_move_range(struct playlist *playlist, struct player_control *pc,
 		    unsigned start, unsigned end, int to)
 {
 	const struct song *queued;
@@ -382,23 +389,25 @@ playlist_move_range(struct playlist *playlist,
 
 	playlist_increment_version(playlist);
 
-	playlist_update_queued_song(playlist, queued);
+	playlist_update_queued_song(playlist, pc, queued);
 
 	return PLAYLIST_RESULT_SUCCESS;
 }
 
 enum playlist_result
-playlist_move_id(struct playlist *playlist, unsigned id1, int to)
+playlist_move_id(struct playlist *playlist, struct player_control *pc,
+		 unsigned id1, int to)
 {
 	int song = queue_id_to_position(&playlist->queue, id1);
 	if (song < 0)
 		return PLAYLIST_RESULT_NO_SUCH_SONG;
 
-	return playlist_move_range(playlist, song, song+1, to);
+	return playlist_move_range(playlist, pc, song, song+1, to);
 }
 
 void
-playlist_shuffle(struct playlist *playlist, unsigned start, unsigned end)
+playlist_shuffle(struct playlist *playlist, struct player_control *pc,
+		 unsigned start, unsigned end)
 {
 	const struct song *queued;
 
@@ -440,5 +449,5 @@ playlist_shuffle(struct playlist *playlist, unsigned start, unsigned end)
 
 	playlist_increment_version(playlist);
 
-	playlist_update_queued_song(playlist, queued);
+	playlist_update_queued_song(playlist, pc, queued);
 }
diff --git a/src/playlist_global.c b/src/playlist_global.c
index 2833b62ed..1ff9f8f21 100644
--- a/src/playlist_global.c
+++ b/src/playlist_global.c
@@ -26,6 +26,7 @@
 #include "playlist.h"
 #include "playlist_state.h"
 #include "event_pipe.h"
+#include "main.h"
 
 struct playlist g_playlist;
 
@@ -38,7 +39,7 @@ playlist_tag_event(void)
 static void
 playlist_event(void)
 {
-	playlist_sync(&g_playlist);
+	playlist_sync(&g_playlist, global_player_control);
 }
 
 void
diff --git a/src/playlist_internal.h b/src/playlist_internal.h
index 9d205188f..173ff9cea 100644
--- a/src/playlist_internal.h
+++ b/src/playlist_internal.h
@@ -27,6 +27,8 @@
 
 #include "playlist.h"
 
+struct player_control;
+
 /**
  * Returns the song object which is currently queued.  Returns none if
  * there is none (yet?) or if MPD isn't playing.
@@ -44,9 +46,11 @@ playlist_get_queued_song(struct playlist *playlist);
  */
 void
 playlist_update_queued_song(struct playlist *playlist,
+			    struct player_control *pc,
 			    const struct song *prev);
 
 void
-playlist_play_order(struct playlist *playlist, int orderNum);
+playlist_play_order(struct playlist *playlist, struct player_control *pc,
+		    int orderNum);
 
 #endif
diff --git a/src/playlist_queue.c b/src/playlist_queue.c
index 43621da9f..e0730fd08 100644
--- a/src/playlist_queue.c
+++ b/src/playlist_queue.c
@@ -27,7 +27,8 @@
 
 enum playlist_result
 playlist_load_into_queue(const char *uri, struct playlist_provider *source,
-			 struct playlist *dest, bool secure)
+			 struct playlist *dest, struct player_control *pc,
+			 bool secure)
 {
 	enum playlist_result result;
 	struct song *song;
@@ -38,7 +39,7 @@ playlist_load_into_queue(const char *uri, struct playlist_provider *source,
 		if (song == NULL)
 			continue;
 
-		result = playlist_append_song(dest, song, NULL);
+		result = playlist_append_song(dest, pc, song, NULL);
 		if (result != PLAYLIST_RESULT_SUCCESS) {
 			if (!song_in_database(song))
 				song_free(song);
@@ -53,7 +54,9 @@ playlist_load_into_queue(const char *uri, struct playlist_provider *source,
 }
 
 enum playlist_result
-playlist_open_into_queue(const char *uri, struct playlist *dest, bool secure)
+playlist_open_into_queue(const char *uri,
+			 struct playlist *dest, struct player_control *pc,
+			 bool secure)
 {
 	struct input_stream *is;
 	struct playlist_provider *playlist = playlist_open_any(uri, &is);
@@ -61,7 +64,7 @@ playlist_open_into_queue(const char *uri, struct playlist *dest, bool secure)
 		return PLAYLIST_RESULT_NO_SUCH_LIST;
 
 	enum playlist_result result =
-		playlist_load_into_queue(uri, playlist, dest, secure);
+		playlist_load_into_queue(uri, playlist, dest, pc, secure);
 	playlist_plugin_close(playlist);
 
 	if (is != NULL)
diff --git a/src/playlist_queue.h b/src/playlist_queue.h
index 9ffa51198..9c706898e 100644
--- a/src/playlist_queue.h
+++ b/src/playlist_queue.h
@@ -40,14 +40,17 @@ struct playlist;
  */
 enum playlist_result
 playlist_load_into_queue(const char *uri, struct playlist_provider *source,
-			 struct playlist *dest, bool secure);
+			 struct playlist *dest, struct player_control *pc,
+			 bool secure);
 
 /**
  * Opens a playlist with a playlist plugin and append to the specified
  * play queue.
  */
 enum playlist_result
-playlist_open_into_queue(const char *uri, struct playlist *dest, bool secure);
+playlist_open_into_queue(const char *uri,
+			 struct playlist *dest, struct player_control *pc,
+			 bool secure);
 
 #endif
 
diff --git a/src/playlist_save.c b/src/playlist_save.c
index 8ddc93ec9..d983b2d3c 100644
--- a/src/playlist_save.c
+++ b/src/playlist_save.c
@@ -109,7 +109,8 @@ spl_save_playlist(const char *name_utf8, const struct playlist *playlist)
 }
 
 enum playlist_result
-playlist_load_spl(struct playlist *playlist, const char *name_utf8)
+playlist_load_spl(struct playlist *playlist, struct player_control *pc,
+		  const char *name_utf8)
 {
 	GPtrArray *list;
 
@@ -119,7 +120,7 @@ playlist_load_spl(struct playlist *playlist, const char *name_utf8)
 
 	for (unsigned i = 0; i < list->len; ++i) {
 		const char *temp = g_ptr_array_index(list, i);
-		if ((playlist_append_uri(playlist, temp, NULL)) != PLAYLIST_RESULT_SUCCESS) {
+		if ((playlist_append_uri(playlist, pc, temp, NULL)) != PLAYLIST_RESULT_SUCCESS) {
 			/* for windows compatibility, convert slashes */
 			char *temp2 = g_strdup(temp);
 			char *p = temp2;
@@ -128,7 +129,7 @@ playlist_load_spl(struct playlist *playlist, const char *name_utf8)
 					*p = '/';
 				p++;
 			}
-			if ((playlist_append_uri(playlist, temp, NULL)) != PLAYLIST_RESULT_SUCCESS) {
+			if ((playlist_append_uri(playlist, pc, temp, NULL)) != PLAYLIST_RESULT_SUCCESS) {
 				g_warning("can't add file \"%s\"", temp2);
 			}
 			g_free(temp2);
diff --git a/src/playlist_save.h b/src/playlist_save.h
index a0131cf7f..441ac6b84 100644
--- a/src/playlist_save.h
+++ b/src/playlist_save.h
@@ -49,6 +49,7 @@ spl_save_playlist(const char *name_utf8, const struct playlist *playlist);
  * playlist.
  */
 enum playlist_result
-playlist_load_spl(struct playlist *playlist, const char *name_utf8);
+playlist_load_spl(struct playlist *playlist, struct player_control *pc,
+		  const char *name_utf8);
 
 #endif
diff --git a/src/playlist_state.c b/src/playlist_state.c
index bb9897e01..2a2228d05 100644
--- a/src/playlist_state.c
+++ b/src/playlist_state.c
@@ -53,11 +53,12 @@
 #define PLAYLIST_BUFFER_SIZE	2*MPD_PATH_MAX
 
 void
-playlist_state_save(FILE *fp, const struct playlist *playlist)
+playlist_state_save(FILE *fp, const struct playlist *playlist,
+		    struct player_control *pc)
 {
 	struct player_status player_status;
 
-	pc_get_status(&player_status);
+	pc_get_status(pc, &player_status);
 
 	fputs(PLAYLIST_STATE_FILE_STATE, fp);
 
@@ -89,10 +90,11 @@ playlist_state_save(FILE *fp, const struct playlist *playlist)
 	fprintf(fp, PLAYLIST_STATE_FILE_CONSUME "%i\n",
 		playlist->queue.consume);
 	fprintf(fp, PLAYLIST_STATE_FILE_CROSSFADE "%i\n",
-		(int)(pc_get_cross_fade()));
-	fprintf(fp, PLAYLIST_STATE_FILE_MIXRAMPDB "%f\n", pc_get_mixramp_db());
+		(int)(pc_get_cross_fade(pc)));
+	fprintf(fp, PLAYLIST_STATE_FILE_MIXRAMPDB "%f\n",
+		pc_get_mixramp_db(pc));
 	fprintf(fp, PLAYLIST_STATE_FILE_MIXRAMPDELAY "%f\n",
-		pc_get_mixramp_delay());
+		pc_get_mixramp_delay(pc));
 	fputs(PLAYLIST_STATE_FILE_PLAYLIST_BEGIN "\n", fp);
 	queue_save(fp, &playlist->queue);
 	fputs(PLAYLIST_STATE_FILE_PLAYLIST_END "\n", fp);
@@ -123,7 +125,7 @@ playlist_state_load(FILE *fp, GString *buffer, struct playlist *playlist)
 
 bool
 playlist_state_restore(const char *line, FILE *fp, GString *buffer,
-		       struct playlist *playlist)
+		       struct playlist *playlist, struct player_control *pc)
 {
 	int current = -1;
 	int seek_time = 0;
@@ -148,16 +150,16 @@ playlist_state_restore(const char *line, FILE *fp, GString *buffer,
 			if (strcmp
 			    (&(line[strlen(PLAYLIST_STATE_FILE_REPEAT)]),
 			     "1") == 0) {
-				playlist_set_repeat(playlist, true);
+				playlist_set_repeat(playlist, pc, true);
 			} else
-				playlist_set_repeat(playlist, false);
+				playlist_set_repeat(playlist, pc, false);
 		} else if (g_str_has_prefix(line, PLAYLIST_STATE_FILE_SINGLE)) {
 			if (strcmp
 			    (&(line[strlen(PLAYLIST_STATE_FILE_SINGLE)]),
 			     "1") == 0) {
-				playlist_set_single(playlist, true);
+				playlist_set_single(playlist, pc, true);
 			} else
-				playlist_set_single(playlist, false);
+				playlist_set_single(playlist, pc, false);
 		} else if (g_str_has_prefix(line, PLAYLIST_STATE_FILE_CONSUME)) {
 			if (strcmp
 			    (&(line[strlen(PLAYLIST_STATE_FILE_CONSUME)]),
@@ -166,11 +168,14 @@ playlist_state_restore(const char *line, FILE *fp, GString *buffer,
 			} else
 				playlist_set_consume(playlist, false);
 		} else if (g_str_has_prefix(line, PLAYLIST_STATE_FILE_CROSSFADE)) {
-			pc_set_cross_fade(atoi(line + strlen(PLAYLIST_STATE_FILE_CROSSFADE)));
+			pc_set_cross_fade(pc,
+					  atoi(line + strlen(PLAYLIST_STATE_FILE_CROSSFADE)));
 		} else if (g_str_has_prefix(line, PLAYLIST_STATE_FILE_MIXRAMPDB)) {
-			pc_set_mixramp_db(atof(line + strlen(PLAYLIST_STATE_FILE_MIXRAMPDB)));
+			pc_set_mixramp_db(pc,
+					  atof(line + strlen(PLAYLIST_STATE_FILE_MIXRAMPDB)));
 		} else if (g_str_has_prefix(line, PLAYLIST_STATE_FILE_MIXRAMPDELAY)) {
-			pc_set_mixramp_delay(atof(line + strlen(PLAYLIST_STATE_FILE_MIXRAMPDELAY)));
+			pc_set_mixramp_delay(pc,
+					     atof(line + strlen(PLAYLIST_STATE_FILE_MIXRAMPDELAY)));
 		} else if (g_str_has_prefix(line, PLAYLIST_STATE_FILE_RANDOM)) {
 			random_mode =
 				strcmp(line + strlen(PLAYLIST_STATE_FILE_RANDOM),
@@ -185,7 +190,7 @@ playlist_state_restore(const char *line, FILE *fp, GString *buffer,
 		}
 	}
 
-	playlist_set_random(playlist, random_mode);
+	playlist_set_random(playlist, pc, random_mode);
 
 	if (!queue_is_empty(&playlist->queue)) {
 		if (!queue_valid_position(&playlist->queue, current))
@@ -195,28 +200,29 @@ playlist_state_restore(const char *line, FILE *fp, GString *buffer,
 		   called here, after the audio output states were
 		   restored, before playback begins */
 		if (state != PLAYER_STATE_STOP)
-			pc_update_audio();
+			pc_update_audio(pc);
 
 		if (state == PLAYER_STATE_STOP /* && config_option */)
 			playlist->current = current;
 		else if (seek_time == 0)
-			playlist_play(playlist, current);
+			playlist_play(playlist, pc, current);
 		else
-			playlist_seek_song(playlist, current, seek_time);
+			playlist_seek_song(playlist, pc, current, seek_time);
 
 		if (state == PLAYER_STATE_PAUSE)
-			pc_pause();
+			pc_pause(pc);
 	}
 
 	return true;
 }
 
 unsigned
-playlist_state_get_hash(const struct playlist *playlist)
+playlist_state_get_hash(const struct playlist *playlist,
+			struct player_control *pc)
 {
 	struct player_status player_status;
 
-	pc_get_status(&player_status);
+	pc_get_status(pc, &player_status);
 
 	return playlist->queue.version ^
 		(player_status.state != PLAYER_STATE_STOP
@@ -226,7 +232,7 @@ playlist_state_get_hash(const struct playlist *playlist)
 		 ? (queue_order_to_position(&playlist->queue,
 					    playlist->current) << 16)
 		 : 0) ^
-		((int)pc_get_cross_fade() << 20) ^
+		((int)pc_get_cross_fade(pc) << 20) ^
 		(player_status.state << 24) ^
 		(playlist->queue.random << 27) ^
 		(playlist->queue.repeat << 28) ^
diff --git a/src/playlist_state.h b/src/playlist_state.h
index 8ca3657f2..c4ce0fcb0 100644
--- a/src/playlist_state.h
+++ b/src/playlist_state.h
@@ -30,13 +30,15 @@
 #include <stdio.h>
 
 struct playlist;
+struct player_control;
 
 void
-playlist_state_save(FILE *fp, const struct playlist *playlist);
+playlist_state_save(FILE *fp, const struct playlist *playlist,
+		    struct player_control *pc);
 
 bool
 playlist_state_restore(const char *line, FILE *fp, GString *buffer,
-		       struct playlist *playlist);
+		       struct playlist *playlist, struct player_control *pc);
 
 /**
  * Generates a hash number for the current state of the playlist and
@@ -45,6 +47,7 @@ playlist_state_restore(const char *line, FILE *fp, GString *buffer,
  * be saved.
  */
 unsigned
-playlist_state_get_hash(const struct playlist *playlist);
+playlist_state_get_hash(const struct playlist *playlist,
+			struct player_control *pc);
 
 #endif