PlayerControl: use strictly typed enums

src/PlayerCommands.cxx

@@ -124,13 +124,13 @@ handle_status(Client *client,
 	const auto player_status = client->player_control->GetStatus();
 
 	switch (player_status.state) {
-	case PLAYER_STATE_STOP:
+	case PlayerState::STOP:
 		state = "stop";
 		break;
-	case PLAYER_STATE_PAUSE:
+	case PlayerState::PAUSE:
 		state = "pause";
 		break;
-	case PLAYER_STATE_PLAY:
+	case PlayerState::PLAY:
 		state = "play";
 		break;
 	}
@@ -168,7 +168,7 @@ handle_status(Client *client,
 			      song, playlist.PositionToId(song));
 	}
 
-	if (player_status.state != PLAYER_STATE_STOP) {
+	if (player_status.state != PlayerState::STOP) {
 		client_printf(client,
 			      COMMAND_STATUS_TIME ": %i:%i\n"
 			      "elapsed: %1.3f\n"

src/PlayerControl.cxx

@@ -32,9 +32,9 @@ player_control::player_control(unsigned _buffer_chunks,
 	:buffer_chunks(_buffer_chunks),
 	 buffered_before_play(_buffered_before_play),
 	 thread(nullptr),
-	 command(PLAYER_COMMAND_NONE),
-	 state(PLAYER_STATE_STOP),
-	 error_type(PLAYER_ERROR_NONE),
+	 command(PlayerCommand::NONE),
+	 state(PlayerState::STOP),
+	 error_type(PlayerError::NONE),
 	 next_song(nullptr),
 	 cross_fade_seconds(0),
 	 mixramp_db(0),
@@ -63,8 +63,8 @@ player_control::Play(Song *song)
 
 	Lock();
 
-	if (state != PLAYER_STATE_STOP)
-		SynchronousCommand(PLAYER_COMMAND_STOP);
+	if (state != PlayerState::STOP)
+		SynchronousCommand(PlayerCommand::STOP);
 
 	assert(next_song == nullptr);
 
@@ -78,14 +78,14 @@ player_control::Play(Song *song)
 void
 player_control::Cancel()
 {
-	LockSynchronousCommand(PLAYER_COMMAND_CANCEL);
+	LockSynchronousCommand(PlayerCommand::CANCEL);
 	assert(next_song == NULL);
 }
 
 void
 player_control::Stop()
 {
-	LockSynchronousCommand(PLAYER_COMMAND_CLOSE_AUDIO);
+	LockSynchronousCommand(PlayerCommand::CLOSE_AUDIO);
 	assert(next_song == nullptr);
 
 	idle_add(IDLE_PLAYER);
@@ -94,7 +94,7 @@ player_control::Stop()
 void
 player_control::UpdateAudio()
 {
-	LockSynchronousCommand(PLAYER_COMMAND_UPDATE_AUDIO);
+	LockSynchronousCommand(PlayerCommand::UPDATE_AUDIO);
 }
 
 void
@@ -102,7 +102,7 @@ player_control::Kill()
 {
 	assert(thread != NULL);
 
-	LockSynchronousCommand(PLAYER_COMMAND_EXIT);
+	LockSynchronousCommand(PlayerCommand::EXIT);
 	g_thread_join(thread);
 	thread = NULL;
 
@@ -112,8 +112,8 @@ player_control::Kill()
 void
 player_control::PauseLocked()
 {
-	if (state != PLAYER_STATE_STOP) {
-		SynchronousCommand(PLAYER_COMMAND_PAUSE);
+	if (state != PlayerState::STOP) {
+		SynchronousCommand(PlayerCommand::PAUSE);
 		idle_add(IDLE_PLAYER);
 	}
 }
@@ -132,15 +132,15 @@ player_control::SetPause(bool pause_flag)
 	Lock();
 
 	switch (state) {
-	case PLAYER_STATE_STOP:
+	case PlayerState::STOP:
 		break;
 
-	case PLAYER_STATE_PLAY:
+	case PlayerState::PLAY:
 		if (pause_flag)
 			PauseLocked();
 		break;
 
-	case PLAYER_STATE_PAUSE:
+	case PlayerState::PAUSE:
 		if (!pause_flag)
 			PauseLocked();
 		break;
@@ -163,11 +163,11 @@ player_control::GetStatus()
 	player_status status;
 
 	Lock();
-	SynchronousCommand(PLAYER_COMMAND_REFRESH);
+	SynchronousCommand(PlayerCommand::REFRESH);
 
 	status.state = state;
 
-	if (state != PLAYER_STATE_STOP) {
+	if (state != PlayerState::STOP) {
 		status.bit_rate = bit_rate;
 		status.audio_format = audio_format;
 		status.total_time = total_time;
@@ -180,9 +180,9 @@ player_control::GetStatus()
 }
 
 void
-player_control::SetError(player_error type, Error &&_error)
+player_control::SetError(PlayerError type, Error &&_error)
 {
-	assert(type != PLAYER_ERROR_NONE);
+	assert(type != PlayerError::NONE);
 	assert(_error.IsDefined());
 
 	error_type = type;
@@ -194,8 +194,8 @@ player_control::ClearError()
 {
 	Lock();
 
-	if (error_type != PLAYER_ERROR_NONE) {
-	    error_type = PLAYER_ERROR_NONE;
+	if (error_type != PlayerError::NONE) {
+	    error_type = PlayerError::NONE;
 	    error.Clear();
 	}
 
@@ -206,7 +206,7 @@ char *
 player_control::GetErrorMessage() const
 {
 	Lock();
-	char *message = error_type != PLAYER_ERROR_NONE
+	char *message = error_type != PlayerError::NONE
 		? g_strdup(error.GetMessage())
 		: NULL;
 	Unlock();
@@ -235,7 +235,7 @@ player_control::Seek(Song *song, float seek_time)
 
 	next_song = song;
 	seek_where = seek_time;
-	SynchronousCommand(PLAYER_COMMAND_SEEK);
+	SynchronousCommand(PlayerCommand::SEEK);
 	Unlock();
 
 	assert(next_song == nullptr);

src/PlayerControl.hxx

@@ -29,62 +29,61 @@
 
 #include <stdint.h>
 
-struct decoder_control;
 struct Song;
 
-enum player_state {
-	PLAYER_STATE_STOP = 0,
-	PLAYER_STATE_PAUSE,
-	PLAYER_STATE_PLAY
+enum class PlayerState : uint8_t {
+	STOP,
+	PAUSE,
+	PLAY
 };
 
-enum player_command {
-	PLAYER_COMMAND_NONE = 0,
-	PLAYER_COMMAND_EXIT,
-	PLAYER_COMMAND_STOP,
-	PLAYER_COMMAND_PAUSE,
-	PLAYER_COMMAND_SEEK,
-	PLAYER_COMMAND_CLOSE_AUDIO,
+enum class PlayerCommand : uint8_t {
+	NONE,
+	EXIT,
+	STOP,
+	PAUSE,
+	SEEK,
+	CLOSE_AUDIO,
 
 	/**
 	 * At least one audio_output.enabled flag has been modified;
 	 * commit those changes to the output threads.
 	 */
-	PLAYER_COMMAND_UPDATE_AUDIO,
+	UPDATE_AUDIO,
 
 	/** player_control.next_song has been updated */
-	PLAYER_COMMAND_QUEUE,
+	QUEUE,
 
 	/**
 	 * cancel pre-decoding player_control.next_song; if the player
 	 * has already started playing this song, it will completely
 	 * stop
 	 */
-	PLAYER_COMMAND_CANCEL,
+	CANCEL,
 
 	/**
 	 * Refresh status information in the #player_control struct,
 	 * e.g. elapsed_time.
 	 */
-	PLAYER_COMMAND_REFRESH,
+	REFRESH,
 };
 
-enum player_error {
-	PLAYER_ERROR_NONE = 0,
+enum class PlayerError : uint8_t {
+	NONE,
 
 	/**
 	 * The decoder has failed to decode the song.
 	 */
-	PLAYER_ERROR_DECODER,
+	DECODER,
 
 	/**
 	 * The audio output has failed.
 	 */
-	PLAYER_ERROR_OUTPUT,
+	OUTPUT,
 };
 
 struct player_status {
-	enum player_state state;
+	PlayerState state;
 	uint16_t bit_rate;
 	AudioFormat audio_format;
 	float total_time;
@@ -117,16 +116,16 @@ struct player_control {
 	 */
 	Cond client_cond;
 
-	enum player_command command;
-	enum player_state state;
+	PlayerCommand command;
+	PlayerState state;
 
-	enum player_error error_type;
+	PlayerError error_type;
 
 	/**
 	 * The error that occurred in the player thread.  This
 	 * attribute is only valid if #error is not
-	 * #PLAYER_ERROR_NONE.  The object must be freed when this
-	 * object transitions back to #PLAYER_ERROR_NONE.
+	 * #PlayerError::NONE.  The object must be freed when this
+	 * object transitions back to #PlayerError::NONE.
 	 */
 	Error error;
 
@@ -236,9 +235,9 @@ struct player_control {
 	 * object.
 	 */
 	void CommandFinished() {
-		assert(command != PLAYER_COMMAND_NONE);
+		assert(command != PlayerCommand::NONE);
 
-		command = PLAYER_COMMAND_NONE;
+		command = PlayerCommand::NONE;
 		ClientSignal();
 	}
 
@@ -250,7 +249,7 @@ private:
 	 * object.
 	 */
 	void WaitCommandLocked() {
-		while (command != PLAYER_COMMAND_NONE)
+		while (command != PlayerCommand::NONE)
 			ClientWait();
 	}
 
@@ -261,8 +260,8 @@ private:
 	 * To be called from the main thread.  Caller must lock the
 	 * object.
 	 */
-	void SynchronousCommand(player_command cmd) {
-		assert(command == PLAYER_COMMAND_NONE);
+	void SynchronousCommand(PlayerCommand cmd) {
+		assert(command == PlayerCommand::NONE);
 
 		command = cmd;
 		Signal();
@@ -276,7 +275,7 @@ private:
 	 * To be called from the main thread.  This method locks the
 	 * object.
 	 */
-	void LockSynchronousCommand(player_command cmd) {
+	void LockSynchronousCommand(PlayerCommand cmd) {
 		Lock();
 		SynchronousCommand(cmd);
 		Unlock();
@@ -290,7 +289,7 @@ public:
 	void Play(Song *song);
 
 	/**
-	 * see PLAYER_COMMAND_CANCEL
+	 * see PlayerCommand::CANCEL
 	 */
 	void Cancel();
 
@@ -312,7 +311,7 @@ public:
 	gcc_pure
 	player_status GetStatus();
 
-	player_state GetState() const {
+	PlayerState GetState() const {
 		return state;
 	}
 
@@ -321,10 +320,10 @@ public:
 	 *
 	 * Caller must lock the object.
 	 *
-	 * @param type the error type; must not be #PLAYER_ERROR_NONE
+	 * @param type the error type; must not be #PlayerError::NONE
 	 * @param error detailed error information; must be defined.
 	 */
-	void SetError(player_error type, Error &&error);
+	void SetError(PlayerError type, Error &&error);
 
 	void ClearError();
 
@@ -335,7 +334,7 @@ public:
 	 */
 	char *GetErrorMessage() const;
 
-	player_error GetErrorType() const {
+	PlayerError GetErrorType() const {
 		return error_type;
 	}
 
@@ -349,7 +348,7 @@ private:
 		assert(next_song == nullptr);
 
 		next_song = song;
-		SynchronousCommand(PLAYER_COMMAND_QUEUE);
+		SynchronousCommand(PlayerCommand::QUEUE);
 	}
 
 public:

src/PlayerThread.cxx

@@ -205,7 +205,7 @@ struct player {
 	}
 
 	/**
-	 * This is the handler for the #PLAYER_COMMAND_SEEK command.
+	 * This is the handler for the #PlayerCommand::SEEK command.
 	 *
 	 * The player lock is not held.
 	 */
@@ -281,11 +281,11 @@ player_command_finished(player_control &pc)
 void
 player::StartDecoder(MusicPipe &_pipe)
 {
-	assert(queued || pc.command == PLAYER_COMMAND_SEEK);
+	assert(queued || pc.command == PlayerCommand::SEEK);
 	assert(pc.next_song != nullptr);
 
 	unsigned start_ms = pc.next_song->start_ms;
-	if (pc.command == PLAYER_COMMAND_SEEK)
+	if (pc.command == PlayerCommand::SEEK)
 		start_ms += (unsigned)(pc.seek_where * 1000);
 
 	dc.Start(pc.next_song->DupDetached(),
@@ -313,7 +313,7 @@ player::StopDecoder()
 bool
 player::WaitForDecoder()
 {
-	assert(queued || pc.command == PLAYER_COMMAND_SEEK);
+	assert(queued || pc.command == PlayerCommand::SEEK);
 	assert(pc.next_song != nullptr);
 
 	queued = false;
@@ -321,7 +321,7 @@ player::WaitForDecoder()
 	Error error = dc.LockGetError();
 	if (error.IsDefined()) {
 		pc.Lock();
-		pc.SetError(PLAYER_ERROR_DECODER, std::move(error));
+		pc.SetError(PlayerError::DECODER, std::move(error));
 
 		pc.next_song->Free();
 		pc.next_song = nullptr;
@@ -383,8 +383,8 @@ bool
 player::OpenOutput()
 {
 	assert(play_audio_format.IsDefined());
-	assert(pc.state == PLAYER_STATE_PLAY ||
-	       pc.state == PLAYER_STATE_PAUSE);
+	assert(pc.state == PlayerState::PLAY ||
+	       pc.state == PlayerState::PAUSE);
 
 	Error error;
 	if (audio_output_all_open(play_audio_format, buffer, error)) {
@@ -392,7 +392,7 @@ player::OpenOutput()
 		paused = false;
 
 		pc.Lock();
-		pc.state = PLAYER_STATE_PLAY;
+		pc.state = PlayerState::PLAY;
 		pc.Unlock();
 
 		idle_add(IDLE_PLAYER);
@@ -408,8 +408,8 @@ player::OpenOutput()
 		paused = true;
 
 		pc.Lock();
-		pc.SetError(PLAYER_ERROR_OUTPUT, std::move(error));
-		pc.state = PLAYER_STATE_PAUSE;
+		pc.SetError(PlayerError::OUTPUT, std::move(error));
+		pc.state = PlayerState::PAUSE;
 		pc.Unlock();
 
 		idle_add(IDLE_PLAYER);
@@ -431,7 +431,7 @@ player::CheckDecoderStartup()
 		dc.Unlock();
 
 		pc.Lock();
-		pc.SetError(PLAYER_ERROR_DECODER, std::move(error));
+		pc.SetError(PlayerError::DECODER, std::move(error));
 		pc.Unlock();
 
 		return false;
@@ -589,20 +589,20 @@ inline void
 player::ProcessCommand()
 {
 	switch (pc.command) {
-	case PLAYER_COMMAND_NONE:
-	case PLAYER_COMMAND_STOP:
-	case PLAYER_COMMAND_EXIT:
-	case PLAYER_COMMAND_CLOSE_AUDIO:
+	case PlayerCommand::NONE:
+	case PlayerCommand::STOP:
+	case PlayerCommand::EXIT:
+	case PlayerCommand::CLOSE_AUDIO:
 		break;
 
-	case PLAYER_COMMAND_UPDATE_AUDIO:
+	case PlayerCommand::UPDATE_AUDIO:
 		pc.Unlock();
 		audio_output_all_enable_disable();
 		pc.Lock();
 		pc.CommandFinished();
 		break;
 
-	case PLAYER_COMMAND_QUEUE:
+	case PlayerCommand::QUEUE:
 		assert(pc.next_song != nullptr);
 		assert(!queued);
 		assert(!IsDecoderAtNextSong());
@@ -611,7 +611,7 @@ player::ProcessCommand()
 		pc.CommandFinished();
 		break;
 
-	case PLAYER_COMMAND_PAUSE:
+	case PlayerCommand::PAUSE:
 		pc.Unlock();
 
 		paused = !paused;
@@ -619,13 +619,13 @@ player::ProcessCommand()
 			audio_output_all_pause();
 			pc.Lock();
 
-			pc.state = PLAYER_STATE_PAUSE;
+			pc.state = PlayerState::PAUSE;
 		} else if (!play_audio_format.IsDefined()) {
 			/* the decoder hasn't provided an audio format
 			   yet - don't open the audio device yet */
 			pc.Lock();
 
-			pc.state = PLAYER_STATE_PLAY;
+			pc.state = PlayerState::PLAY;
 		} else {
 			OpenOutput();
 
@@ -635,18 +635,18 @@ player::ProcessCommand()
 		pc.CommandFinished();
 		break;
 
-	case PLAYER_COMMAND_SEEK:
+	case PlayerCommand::SEEK:
 		pc.Unlock();
 		SeekDecoder();
 		pc.Lock();
 		break;
 
-	case PLAYER_COMMAND_CANCEL:
+	case PlayerCommand::CANCEL:
 		if (pc.next_song == nullptr) {
 			/* the cancel request arrived too late, we're
 			   already playing the queued song...  stop
 			   everything now */
-			pc.command = PLAYER_COMMAND_STOP;
+			pc.command = PlayerCommand::STOP;
 			return;
 		}
 
@@ -664,7 +664,7 @@ player::ProcessCommand()
 		pc.CommandFinished();
 		break;
 
-	case PLAYER_COMMAND_REFRESH:
+	case PlayerCommand::REFRESH:
 		if (output_open && !paused) {
 			pc.Unlock();
 			audio_output_all_check();
@@ -841,11 +841,11 @@ player::PlayNextChunk()
 
 		pc.Lock();
 
-		pc.SetError(PLAYER_ERROR_OUTPUT, std::move(error));
+		pc.SetError(PlayerError::OUTPUT, std::move(error));
 
 		/* pause: the user may resume playback as soon as an
 		   audio output becomes available */
-		pc.state = PLAYER_STATE_PAUSE;
+		pc.state = PlayerState::PAUSE;
 		paused = true;
 
 		pc.Unlock();
@@ -889,7 +889,7 @@ player::SongBorder()
 	const bool border_pause = pc.border_pause;
 	if (border_pause) {
 		paused = true;
-		pc.state = PLAYER_STATE_PAUSE;
+		pc.state = PlayerState::PAUSE;
 	}
 
 	pc.Unlock();
@@ -916,18 +916,18 @@ player::Run()
 	}
 
 	pc.Lock();
-	pc.state = PLAYER_STATE_PLAY;
+	pc.state = PlayerState::PLAY;
 
-	if (pc.command == PLAYER_COMMAND_SEEK)
+	if (pc.command == PlayerCommand::SEEK)
 		elapsed_time = pc.seek_where;
 
 	pc.CommandFinished();
 
 	while (true) {
 		ProcessCommand();
-		if (pc.command == PLAYER_COMMAND_STOP ||
-		    pc.command == PLAYER_COMMAND_EXIT ||
-		    pc.command == PLAYER_COMMAND_CLOSE_AUDIO) {
+		if (pc.command == PlayerCommand::STOP ||
+		    pc.command == PlayerCommand::EXIT ||
+		    pc.command == PlayerCommand::CLOSE_AUDIO) {
 			pc.Unlock();
 			audio_output_all_cancel();
 			break;
@@ -1021,7 +1021,7 @@ player::Run()
 		if (paused) {
 			pc.Lock();
 
-			if (pc.command == PLAYER_COMMAND_NONE)
+			if (pc.command == PlayerCommand::NONE)
 				pc.Wait();
 			continue;
 		} else if (!pipe->IsEmpty()) {
@@ -1079,7 +1079,7 @@ player::Run()
 		pc.next_song = nullptr;
 	}
 
-	pc.state = PLAYER_STATE_STOP;
+	pc.state = PlayerState::STOP;
 
 	pc.Unlock();
 }
@@ -1106,8 +1106,8 @@ player_task(gpointer arg)
 
 	while (1) {
 		switch (pc.command) {
-		case PLAYER_COMMAND_SEEK:
-		case PLAYER_COMMAND_QUEUE:
+		case PlayerCommand::SEEK:
+		case PlayerCommand::QUEUE:
 			assert(pc.next_song != nullptr);
 
 			pc.Unlock();
@@ -1116,14 +1116,14 @@ player_task(gpointer arg)
 			pc.Lock();
 			break;
 
-		case PLAYER_COMMAND_STOP:
+		case PlayerCommand::STOP:
 			pc.Unlock();
 			audio_output_all_cancel();
 			pc.Lock();
 
 			/* fall through */
 
-		case PLAYER_COMMAND_PAUSE:
+		case PlayerCommand::PAUSE:
 			if (pc.next_song != nullptr) {
 				pc.next_song->Free();
 				pc.next_song = nullptr;
@@ -1132,7 +1132,7 @@ player_task(gpointer arg)
 			pc.CommandFinished();
 			break;
 
-		case PLAYER_COMMAND_CLOSE_AUDIO:
+		case PlayerCommand::CLOSE_AUDIO:
 			pc.Unlock();
 
 			audio_output_all_release();
@@ -1144,14 +1144,14 @@ player_task(gpointer arg)
 
 			break;
 
-		case PLAYER_COMMAND_UPDATE_AUDIO:
+		case PlayerCommand::UPDATE_AUDIO:
 			pc.Unlock();
 			audio_output_all_enable_disable();
 			pc.Lock();
 			pc.CommandFinished();
 			break;
 
-		case PLAYER_COMMAND_EXIT:
+		case PlayerCommand::EXIT:
 			pc.Unlock();
 
 			dc.Quit();
@@ -1161,7 +1161,7 @@ player_task(gpointer arg)
 			player_command_finished(pc);
 			return nullptr;
 
-		case PLAYER_COMMAND_CANCEL:
+		case PlayerCommand::CANCEL:
 			if (pc.next_song != nullptr) {
 				pc.next_song->Free();
 				pc.next_song = nullptr;
@@ -1170,12 +1170,12 @@ player_task(gpointer arg)
 			pc.CommandFinished();
 			break;
 
-		case PLAYER_COMMAND_REFRESH:
+		case PlayerCommand::REFRESH:
 			/* no-op when not playing */
 			pc.CommandFinished();
 			break;
 
-		case PLAYER_COMMAND_NONE:
+		case PlayerCommand::NONE:
 			pc.Wait();
 			break;
 		}

src/Playlist.cxx

@@ -175,11 +175,11 @@ playlist::SyncWithPlayer(player_control &pc)
 		return;
 
 	pc.Lock();
-	const player_state pc_state = pc.GetState();
+	const PlayerState pc_state = pc.GetState();
 	const Song *pc_next_song = pc.next_song;
 	pc.Unlock();
 
-	if (pc_state == PLAYER_STATE_STOP)
+	if (pc_state == PlayerState::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
@@ -210,16 +210,16 @@ static void
 playlist_resume_playback(struct playlist *playlist, struct player_control *pc)
 {
 	assert(playlist->playing);
-	assert(pc->GetState() == PLAYER_STATE_STOP);
+	assert(pc->GetState() == PlayerState::STOP);
 
 	const auto error = pc->GetErrorType();
-	if (error == PLAYER_ERROR_NONE)
+	if (error == PlayerError::NONE)
 		playlist->error_count = 0;
 	else
 		++playlist->error_count;
 
-	if ((playlist->stop_on_error && error != PLAYER_ERROR_NONE) ||
-	    error == PLAYER_ERROR_OUTPUT ||
+	if ((playlist->stop_on_error && error != PlayerError::NONE) ||
+	    error == PlayerError::OUTPUT ||
 	    playlist->error_count >= playlist->queue.GetLength())
 		/* too many errors, or critical error: stop
 		   playback */

src/PlaylistControl.cxx

@@ -250,8 +250,8 @@ playlist::SeekCurrent(player_control &pc, float seek_time, bool relative)
 	if (relative) {
 		const auto status = pc.GetStatus();
 
-		if (status.state != PLAYER_STATE_PLAY &&
-		    status.state != PLAYER_STATE_PAUSE)
+		if (status.state != PlayerState::PLAY &&
+		    status.state != PlayerState::PAUSE)
 			return PLAYLIST_RESULT_NOT_PLAYING;
 
 		seek_time += (int)status.elapsed_time;

src/PlaylistEdit.cxx

@@ -226,7 +226,7 @@ playlist::DeleteInternal(player_control &pc,
 	unsigned songOrder = queue.PositionToOrder(song);
 
 	if (playing && current == (int)songOrder) {
-		const bool paused = pc.GetState() == PLAYER_STATE_PAUSE;
+		const bool paused = pc.GetState() == PlayerState::PAUSE;
 
 		/* the current song is going to be deleted: stop the player */
 

src/PlaylistState.cxx

@@ -63,7 +63,7 @@ playlist_state_save(FILE *fp, const struct playlist *playlist,
 
 	if (playlist->playing) {
 		switch (player_status.state) {
-		case PLAYER_STATE_PAUSE:
+		case PlayerState::PAUSE:
 			fputs(PLAYLIST_STATE_FILE_STATE_PAUSE "\n", fp);
 			break;
 		default:
@@ -126,7 +126,6 @@ playlist_state_restore(const char *line, TextFile &file,
 {
 	int current = -1;
 	int seek_time = 0;
-	enum player_state state = PLAYER_STATE_STOP;
 	bool random_mode = false;
 
 	if (!g_str_has_prefix(line, PLAYLIST_STATE_FILE_STATE))
@@ -134,10 +133,13 @@ playlist_state_restore(const char *line, TextFile &file,
 
 	line += sizeof(PLAYLIST_STATE_FILE_STATE) - 1;
 
+	PlayerState state;
 	if (strcmp(line, PLAYLIST_STATE_FILE_STATE_PLAY) == 0)
-		state = PLAYER_STATE_PLAY;
+		state = PlayerState::PLAY;
 	else if (strcmp(line, PLAYLIST_STATE_FILE_STATE_PAUSE) == 0)
-		state = PLAYER_STATE_PAUSE;
+		state = PlayerState::PAUSE;
+	else
+		state = PlayerState::STOP;
 
 	while ((line = file.ReadLine()) != NULL) {
 		if (g_str_has_prefix(line, PLAYLIST_STATE_FILE_TIME)) {
@@ -180,27 +182,27 @@ playlist_state_restore(const char *line, TextFile &file,
 		if (!playlist->queue.IsValidPosition(current))
 			current = 0;
 
-		if (state == PLAYER_STATE_PLAY &&
+		if (state == PlayerState::PLAY &&
 		    config_get_bool(CONF_RESTORE_PAUSED, false))
 			/* the user doesn't want MPD to auto-start
 			   playback after startup; fall back to
 			   "pause" */
-			state = PLAYER_STATE_PAUSE;
+			state = PlayerState::PAUSE;
 
 		/* enable all devices for the first time; this must be
 		   called here, after the audio output states were
 		   restored, before playback begins */
-		if (state != PLAYER_STATE_STOP)
+		if (state != PlayerState::STOP)
 			pc->UpdateAudio();
 
-		if (state == PLAYER_STATE_STOP /* && config_option */)
+		if (state == PlayerState::STOP /* && config_option */)
 			playlist->current = current;
 		else if (seek_time == 0)
 			playlist->PlayPosition(*pc, current);
 		else
 			playlist->SeekSongPosition(*pc, current, seek_time);
 
-		if (state == PLAYER_STATE_PAUSE)
+		if (state == PlayerState::PAUSE)
 			pc->Pause();
 	}
 
@@ -214,14 +216,14 @@ playlist_state_get_hash(const struct playlist *playlist,
 	const auto player_status = pc->GetStatus();
 
 	return playlist->queue.version ^
-		(player_status.state != PLAYER_STATE_STOP
+		(player_status.state != PlayerState::STOP
 		 ? ((int)player_status.elapsed_time << 8)
 		 : 0) ^
 		(playlist->current >= 0
 		 ? (playlist->queue.OrderToPosition(playlist->current) << 16)
 		 : 0) ^
 		((int)pc->GetCrossFade() << 20) ^
-		(player_status.state << 24) ^
+		(unsigned(player_status.state) << 24) ^
 		(playlist->queue.random << 27) ^
 		(playlist->queue.repeat << 28) ^
 		(playlist->queue.single << 29) ^