aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/DecoderControl.hxx9
-rw-r--r--src/Main.cxx4
-rw-r--r--src/OutputAll.cxx8
-rw-r--r--src/OutputCommand.cxx4
-rw-r--r--src/OutputThread.cxx2
-rw-r--r--src/PlayerCommands.cxx24
-rw-r--r--src/PlayerControl.cxx200
-rw-r--r--src/PlayerControl.hxx288
-rw-r--r--src/PlayerThread.cxx122
-rw-r--r--src/Playlist.cxx26
-rw-r--r--src/PlaylistControl.cxx13
-rw-r--r--src/PlaylistEdit.cxx4
-rw-r--r--src/PlaylistState.cxx29
-rw-r--r--src/Stats.cxx2
14 files changed, 335 insertions, 400 deletions
diff --git a/src/DecoderControl.hxx b/src/DecoderControl.hxx
index 42c28d78..02b98672 100644
--- a/src/DecoderControl.hxx
+++ b/src/DecoderControl.hxx
@@ -129,6 +129,15 @@ struct decoder_control {
char *mixramp_start;
char *mixramp_end;
char *mixramp_prev_end;
+
+ /**
+ * Waits for a signal from the decoder thread. This object
+ * must be locked prior to calling this function. This method
+ * is only valid in the player thread.
+ */
+ void WaitForDecoder() {
+ g_cond_wait(client_cond, mutex);
+ }
};
G_GNUC_MALLOC
diff --git a/src/Main.cxx b/src/Main.cxx
index ef78c92b..6d4fc82d 100644
--- a/src/Main.cxx
+++ b/src/Main.cxx
@@ -509,7 +509,7 @@ int mpd_main(int argc, char *argv[])
/* enable all audio outputs (if not already done by
playlist_state_restore() */
- pc_update_audio(&global_partition->pc);
+ global_partition->pc.UpdateAudio();
#ifdef WIN32
win32_app_started();
@@ -535,7 +535,7 @@ int mpd_main(int argc, char *argv[])
delete state_file;
}
- pc_kill(&global_partition->pc);
+ global_partition->pc.Kill();
finishZeroconf();
listen_global_finish();
delete client_list;
diff --git a/src/OutputAll.cxx b/src/OutputAll.cxx
index a18a6338..4cdcc84e 100644
--- a/src/OutputAll.cxx
+++ b/src/OutputAll.cxx
@@ -481,15 +481,15 @@ audio_output_all_check(void)
bool
audio_output_all_wait(struct player_control *pc, unsigned threshold)
{
- player_lock(pc);
+ pc->Lock();
if (audio_output_all_check() < threshold) {
- player_unlock(pc);
+ pc->Unlock();
return true;
}
- player_wait(pc);
- player_unlock(pc);
+ pc->Wait();
+ pc->Unlock();
return audio_output_all_check() < threshold;
}
diff --git a/src/OutputCommand.cxx b/src/OutputCommand.cxx
index f4edaa4a..be52b49a 100644
--- a/src/OutputCommand.cxx
+++ b/src/OutputCommand.cxx
@@ -53,7 +53,7 @@ audio_output_enable_index(unsigned idx)
ao->enabled = true;
idle_add(IDLE_OUTPUT);
- pc_update_audio(ao->player_control);
+ ao->player_control->UpdateAudio();
++audio_output_state_version;
@@ -82,7 +82,7 @@ audio_output_disable_index(unsigned idx)
idle_add(IDLE_MIXER);
}
- pc_update_audio(ao->player_control);
+ ao->player_control->UpdateAudio();
++audio_output_state_version;
diff --git a/src/OutputThread.cxx b/src/OutputThread.cxx
index 59394e07..20212cef 100644
--- a/src/OutputThread.cxx
+++ b/src/OutputThread.cxx
@@ -548,7 +548,7 @@ ao_play(struct audio_output *ao)
ao->chunk_finished = true;
g_mutex_unlock(ao->mutex);
- player_lock_signal(ao->player_control);
+ ao->player_control->LockSignal();
g_mutex_lock(ao->mutex);
return true;
diff --git a/src/PlayerCommands.cxx b/src/PlayerCommands.cxx
index 99ede9bd..32cd16d9 100644
--- a/src/PlayerCommands.cxx
+++ b/src/PlayerCommands.cxx
@@ -106,9 +106,9 @@ handle_pause(Client *client,
if (!check_bool(client, &pause_flag, argv[1]))
return COMMAND_RETURN_ERROR;
- pc_set_pause(client->player_control, pause_flag);
+ client->player_control->SetPause(pause_flag);
} else
- pc_pause(client->player_control);
+ client->player_control->Pause();
return COMMAND_RETURN_OK;
}
@@ -118,12 +118,10 @@ handle_status(Client *client,
G_GNUC_UNUSED int argc, G_GNUC_UNUSED char *argv[])
{
const char *state = NULL;
- struct player_status player_status;
int updateJobId;
- char *error;
int song;
- pc_get_status(client->player_control, &player_status);
+ const auto player_status = client->player_control->GetStatus();
switch (player_status.state) {
case PLAYER_STATE_STOP:
@@ -157,9 +155,9 @@ handle_status(Client *client,
playlist.GetConsume(),
(unsigned long)playlist.GetVersion(),
playlist.GetLength(),
- (int)(pc_get_cross_fade(client->player_control) + 0.5),
- pc_get_mixramp_db(client->player_control),
- pc_get_mixramp_delay(client->player_control),
+ (int)(client->player_control->GetCrossFade() + 0.5),
+ client->player_control->GetMixRampDb(),
+ client->player_control->GetMixRampDelay(),
state);
song = playlist.GetCurrentPosition();
@@ -192,7 +190,7 @@ handle_status(Client *client,
updateJobId);
}
- error = pc_get_error_message(client->player_control);
+ char *error = client->player_control->GetErrorMessage();
if (error != NULL) {
client_printf(client,
COMMAND_STATUS_ERROR ": %s\n",
@@ -285,7 +283,7 @@ enum command_return
handle_clearerror(G_GNUC_UNUSED Client *client,
G_GNUC_UNUSED int argc, G_GNUC_UNUSED char *argv[])
{
- pc_clear_error(client->player_control);
+ client->player_control->ClearError();
return COMMAND_RETURN_OK;
}
@@ -340,7 +338,7 @@ handle_crossfade(Client *client, G_GNUC_UNUSED int argc, char *argv[])
if (!check_unsigned(client, &xfade_time, argv[1]))
return COMMAND_RETURN_ERROR;
- pc_set_cross_fade(client->player_control, xfade_time);
+ client->player_control->SetCrossFade(xfade_time);
return COMMAND_RETURN_OK;
}
@@ -352,7 +350,7 @@ handle_mixrampdb(Client *client, G_GNUC_UNUSED int argc, char *argv[])
if (!check_float(client, &db, argv[1]))
return COMMAND_RETURN_ERROR;
- pc_set_mixramp_db(client->player_control, db);
+ client->player_control->SetMixRampDb(db);
return COMMAND_RETURN_OK;
}
@@ -364,7 +362,7 @@ handle_mixrampdelay(Client *client, G_GNUC_UNUSED int argc, char *argv[])
if (!check_float(client, &delay_secs, argv[1]))
return COMMAND_RETURN_ERROR;
- pc_set_mixramp_delay(client->player_control, delay_secs);
+ client->player_control->SetMixRampDelay(delay_secs);
return COMMAND_RETURN_OK;
}
diff --git a/src/PlayerControl.cxx b/src/PlayerControl.cxx
index 62a8a4f8..3805f776 100644
--- a/src/PlayerControl.cxx
+++ b/src/PlayerControl.cxx
@@ -56,18 +56,6 @@ player_control::~player_control()
song_free(next_song);
}
-void
-player_wait_decoder(gcc_unused struct player_control *pc,
- struct decoder_control *dc)
-{
- assert(pc != NULL);
- assert(dc != NULL);
-
- /* during this function, the decoder lock is held, because
- we're waiting for the decoder thread */
- g_cond_wait(dc->client_cond, dc->mutex);
-}
-
static void
player_command_wait_locked(struct player_control *pc)
{
@@ -81,84 +69,84 @@ player_command_locked(struct player_control *pc, enum player_command cmd)
assert(pc->command == PLAYER_COMMAND_NONE);
pc->command = cmd;
- player_signal(pc);
+ pc->Signal();
player_command_wait_locked(pc);
}
static void
player_command(struct player_control *pc, enum player_command cmd)
{
- player_lock(pc);
+ pc->Lock();
player_command_locked(pc, cmd);
- player_unlock(pc);
+ pc->Unlock();
}
void
-pc_play(struct player_control *pc, struct song *song)
+player_control::Play(struct song *song)
{
assert(song != NULL);
- player_lock(pc);
+ Lock();
- if (pc->state != PLAYER_STATE_STOP)
- player_command_locked(pc, PLAYER_COMMAND_STOP);
+ if (state != PLAYER_STATE_STOP)
+ player_command_locked(this, PLAYER_COMMAND_STOP);
- assert(pc->next_song == NULL);
+ assert(next_song == nullptr);
- pc_enqueue_song_locked(pc, song);
+ pc_enqueue_song_locked(this, song);
- assert(pc->next_song == NULL);
+ assert(next_song == nullptr);
- player_unlock(pc);
+ Unlock();
idle_add(IDLE_PLAYER);
}
void
-pc_cancel(struct player_control *pc)
+player_control::Cancel()
{
- player_command(pc, PLAYER_COMMAND_CANCEL);
- assert(pc->next_song == NULL);
+ player_command(this, PLAYER_COMMAND_CANCEL);
+ assert(next_song == NULL);
}
void
-pc_stop(struct player_control *pc)
+player_control::Stop()
{
- player_command(pc, PLAYER_COMMAND_CLOSE_AUDIO);
- assert(pc->next_song == NULL);
+ player_command(this, PLAYER_COMMAND_CLOSE_AUDIO);
+ assert(next_song == nullptr);
idle_add(IDLE_PLAYER);
}
void
-pc_update_audio(struct player_control *pc)
+player_control::UpdateAudio()
{
- player_command(pc, PLAYER_COMMAND_UPDATE_AUDIO);
+ player_command(this, PLAYER_COMMAND_UPDATE_AUDIO);
}
void
-pc_kill(struct player_control *pc)
+player_control::Kill()
{
- assert(pc->thread != NULL);
+ assert(thread != NULL);
- player_command(pc, PLAYER_COMMAND_EXIT);
- g_thread_join(pc->thread);
- pc->thread = NULL;
+ player_command(this, PLAYER_COMMAND_EXIT);
+ g_thread_join(thread);
+ thread = NULL;
idle_add(IDLE_PLAYER);
}
void
-pc_pause(struct player_control *pc)
+player_control::Pause()
{
- player_lock(pc);
+ Lock();
- if (pc->state != PLAYER_STATE_STOP) {
- player_command_locked(pc, PLAYER_COMMAND_PAUSE);
+ if (state != PLAYER_STATE_STOP) {
+ player_command_locked(this, PLAYER_COMMAND_PAUSE);
idle_add(IDLE_PLAYER);
}
- player_unlock(pc);
+ Unlock();
}
static void
@@ -171,90 +159,92 @@ pc_pause_locked(struct player_control *pc)
}
void
-pc_set_pause(struct player_control *pc, bool pause_flag)
+player_control::SetPause(bool pause_flag)
{
- player_lock(pc);
+ Lock();
- switch (pc->state) {
+ switch (state) {
case PLAYER_STATE_STOP:
break;
case PLAYER_STATE_PLAY:
if (pause_flag)
- pc_pause_locked(pc);
+ pc_pause_locked(this);
break;
case PLAYER_STATE_PAUSE:
if (!pause_flag)
- pc_pause_locked(pc);
+ pc_pause_locked(this);
break;
}
- player_unlock(pc);
+ Unlock();
}
void
-pc_set_border_pause(struct player_control *pc, bool border_pause)
+player_control::SetBorderPause(bool _border_pause)
{
- player_lock(pc);
- pc->border_pause = border_pause;
- player_unlock(pc);
+ Lock();
+ border_pause = _border_pause;
+ Unlock();
}
-void
-pc_get_status(struct player_control *pc, struct player_status *status)
+player_status
+player_control::GetStatus()
{
- player_lock(pc);
- player_command_locked(pc, PLAYER_COMMAND_REFRESH);
+ player_status status;
- status->state = pc->state;
+ Lock();
+ player_command_locked(this, PLAYER_COMMAND_REFRESH);
- if (pc->state != PLAYER_STATE_STOP) {
- status->bit_rate = pc->bit_rate;
- status->audio_format = pc->audio_format;
- status->total_time = pc->total_time;
- status->elapsed_time = pc->elapsed_time;
+ status.state = state;
+
+ if (state != PLAYER_STATE_STOP) {
+ status.bit_rate = bit_rate;
+ status.audio_format = audio_format;
+ status.total_time = total_time;
+ status.elapsed_time = elapsed_time;
}
- player_unlock(pc);
+ Unlock();
+
+ return status;
}
void
-pc_set_error(struct player_control *pc, enum player_error type,
- GError *error)
+player_control::SetError(player_error type, GError *_error)
{
- assert(pc != NULL);
assert(type != PLAYER_ERROR_NONE);
- assert(error != NULL);
+ assert(_error != NULL);
- if (pc->error_type != PLAYER_ERROR_NONE)
- g_error_free(pc->error);
+ if (error_type != PLAYER_ERROR_NONE)
+ g_error_free(error);
- pc->error_type = type;
- pc->error = error;
+ error_type = type;
+ error = _error;
}
void
-pc_clear_error(struct player_control *pc)
+player_control::ClearError()
{
- player_lock(pc);
+ Lock();
- if (pc->error_type != PLAYER_ERROR_NONE) {
- pc->error_type = PLAYER_ERROR_NONE;
- g_error_free(pc->error);
+ if (error_type != PLAYER_ERROR_NONE) {
+ error_type = PLAYER_ERROR_NONE;
+ g_error_free(error);
}
- player_unlock(pc);
+ Unlock();
}
char *
-pc_get_error_message(struct player_control *pc)
+player_control::GetErrorMessage() const
{
- player_lock(pc);
- char *message = pc->error_type != PLAYER_ERROR_NONE
- ? g_strdup(pc->error->message)
+ Lock();
+ char *message = error_type != PLAYER_ERROR_NONE
+ ? g_strdup(error->message)
: NULL;
- player_unlock(pc);
+ Unlock();
return message;
}
@@ -269,65 +259,59 @@ pc_enqueue_song_locked(struct player_control *pc, struct song *song)
}
void
-pc_enqueue_song(struct player_control *pc, struct song *song)
+player_control::EnqueueSong(struct song *song)
{
assert(song != NULL);
- player_lock(pc);
- pc_enqueue_song_locked(pc, song);
- player_unlock(pc);
+ Lock();
+ pc_enqueue_song_locked(this, song);
+ Unlock();
}
bool
-pc_seek(struct player_control *pc, struct song *song, float seek_time)
+player_control::Seek(struct song *song, float seek_time)
{
assert(song != NULL);
- player_lock(pc);
+ Lock();
- if (pc->next_song != NULL)
- song_free(pc->next_song);
+ if (next_song != nullptr)
+ song_free(next_song);
- pc->next_song = song;
- pc->seek_where = seek_time;
- player_command_locked(pc, PLAYER_COMMAND_SEEK);
- player_unlock(pc);
+ next_song = song;
+ seek_where = seek_time;
+ player_command_locked(this, PLAYER_COMMAND_SEEK);
+ Unlock();
- assert(pc->next_song == NULL);
+ assert(next_song == nullptr);
idle_add(IDLE_PLAYER);
return true;
}
-float
-pc_get_cross_fade(const struct player_control *pc)
-{
- return pc->cross_fade_seconds;
-}
-
void
-pc_set_cross_fade(struct player_control *pc, float cross_fade_seconds)
+player_control::SetCrossFade(float _cross_fade_seconds)
{
- if (cross_fade_seconds < 0)
- cross_fade_seconds = 0;
- pc->cross_fade_seconds = cross_fade_seconds;
+ if (_cross_fade_seconds < 0)
+ _cross_fade_seconds = 0;
+ cross_fade_seconds = _cross_fade_seconds;
idle_add(IDLE_OPTIONS);
}
void
-pc_set_mixramp_db(struct player_control *pc, float mixramp_db)
+player_control::SetMixRampDb(float _mixramp_db)
{
- pc->mixramp_db = mixramp_db;
+ mixramp_db = _mixramp_db;
idle_add(IDLE_OPTIONS);
}
void
-pc_set_mixramp_delay(struct player_control *pc, float mixramp_delay_seconds)
+player_control::SetMixRampDelay(float _mixramp_delay_seconds)
{
- pc->mixramp_delay_seconds = mixramp_delay_seconds;
+ mixramp_delay_seconds = _mixramp_delay_seconds;
idle_add(IDLE_OPTIONS);
}
diff --git a/src/PlayerControl.hxx b/src/PlayerControl.hxx
index 322b95c8..2b25177f 100644
--- a/src/PlayerControl.hxx
+++ b/src/PlayerControl.hxx
@@ -101,7 +101,7 @@ struct player_control {
/**
* This lock protects #command, #state, #error.
*/
- Mutex mutex;
+ mutable Mutex mutex;
/**
* Trigger this object after you have modified #command.
@@ -152,188 +152,142 @@ struct player_control {
player_control(unsigned buffer_chunks,
unsigned buffered_before_play);
~player_control();
-};
-/**
- * Locks the #player_control object.
- */
-static inline void
-player_lock(struct player_control *pc)
-{
- pc->mutex.lock();
-}
-
-/**
- * Unlocks the #player_control object.
- */
-static inline void
-player_unlock(struct player_control *pc)
-{
- pc->mutex.unlock();
-}
-
-/**
- * Waits for a signal on the #player_control object. This function is
- * only valid in the player thread. The object must be locked prior
- * to calling this function.
- */
-static inline void
-player_wait(struct player_control *pc)
-{
- pc->cond.wait(pc->mutex);
-}
-
-/**
- * Waits for a signal on the #player_control object. This function is
- * only valid in the player thread. The #decoder_control object must
- * be locked prior to calling this function.
- *
- * Note the small difference to the player_wait() function!
- */
-void
-player_wait_decoder(struct player_control *pc, struct decoder_control *dc);
+ /**
+ * Locks the object.
+ */
+ void Lock() const {
+ mutex.lock();
+ }
-/**
- * Signals the #player_control object. The object should be locked
- * prior to calling this function.
- */
-static inline void
-player_signal(struct player_control *pc)
-{
- pc->cond.signal();
-}
-
-/**
- * Signals the #player_control object. The object is temporarily
- * locked by this function.
- */
-static inline void
-player_lock_signal(struct player_control *pc)
-{
- player_lock(pc);
- player_signal(pc);
- player_unlock(pc);
-}
-
-/**
- * @param song the song to be queued; the given instance will be owned
- * and freed by the player
- */
-void
-pc_play(struct player_control *pc, struct song *song);
+ /**
+ * Unlocks the object.
+ */
+ void Unlock() const {
+ mutex.unlock();
+ }
-/**
- * see PLAYER_COMMAND_CANCEL
- */
-void
-pc_cancel(struct player_control *pc);
+ /**
+ * Signals the object. The object should be locked prior to
+ * calling this function.
+ */
+ void Signal() {
+ cond.signal();
+ }
-void
-pc_set_pause(struct player_control *pc, bool pause_flag);
+ /**
+ * Signals the object. The object is temporarily locked by
+ * this function.
+ */
+ void LockSignal() {
+ Lock();
+ Signal();
+ Unlock();
+ }
-void
-pc_pause(struct player_control *pc);
+ /**
+ * Waits for a signal on the object. This function is only
+ * valid in the player thread. The object must be locked
+ * prior to calling this function.
+ */
+ void Wait() {
+ cond.wait(mutex);
+ }
-/**
- * Set the player's #border_pause flag.
- */
-void
-pc_set_border_pause(struct player_control *pc, bool border_pause);
+ /**
+ * @param song the song to be queued; the given instance will
+ * be owned and freed by the player
+ */
+ void Play(struct song *song);
-void
-pc_kill(struct player_control *pc);
+ /**
+ * see PLAYER_COMMAND_CANCEL
+ */
+ void Cancel();
-void
-pc_get_status(struct player_control *pc, struct player_status *status);
+ void SetPause(bool pause_flag);
-static inline enum player_state
-pc_get_state(struct player_control *pc)
-{
- return pc->state;
-}
+ void Pause();
-/**
- * Set the error. Discards any previous error condition.
- *
- * Caller must lock the object.
- *
- * @param type the error type; must not be #PLAYER_ERROR_NONE
- * @param error detailed error information; must not be NULL; the
- * #player_control takes over ownership of this #GError instance
- */
-void
-pc_set_error(struct player_control *pc, enum player_error type,
- GError *error);
+ /**
+ * Set the player's #border_pause flag.
+ */
+ void SetBorderPause(bool border_pause);
-void
-pc_clear_error(struct player_control *pc);
+ void Kill();
-/**
- * Returns the human-readable message describing the last error during
- * playback, NULL if no error occurred. The caller has to free the
- * returned string.
- */
-char *
-pc_get_error_message(struct player_control *pc);
+ gcc_pure
+ player_status GetStatus();
-static inline enum player_error
-pc_get_error_type(struct player_control *pc)
-{
- return pc->error_type;
-}
+ player_state GetState() const {
+ return state;
+ }
-void
-pc_stop(struct player_control *pc);
+ /**
+ * Set the error. Discards any previous error condition.
+ *
+ * Caller must lock the object.
+ *
+ * @param type the error type; must not be #PLAYER_ERROR_NONE
+ * @param error detailed error information; must not be NULL; the
+ * #player_control takes over ownership of this #GError instance
+ */
+ void SetError(player_error type, GError *error);
-void
-pc_update_audio(struct player_control *pc);
+ void ClearError();
-/**
- * @param song the song to be queued; the given instance will be owned
- * and freed by the player
- */
-void
-pc_enqueue_song(struct player_control *pc, struct song *song);
+ /**
+ * Returns the human-readable message describing the last
+ * error during playback, NULL if no error occurred. The
+ * caller has to free the returned string.
+ */
+ char *GetErrorMessage() const;
-/**
- * Makes the player thread seek the specified song to a position.
- *
- * @param song the song to be queued; the given instance will be owned
- * and freed by the player
- * @return true on success, false on failure (e.g. if MPD isn't
- * playing currently)
- */
-bool
-pc_seek(struct player_control *pc, struct song *song, float seek_time);
-
-void
-pc_set_cross_fade(struct player_control *pc, float cross_fade_seconds);
-
-float
-pc_get_cross_fade(const struct player_control *pc);
-
-void
-pc_set_mixramp_db(struct player_control *pc, float mixramp_db);
-
-static inline float
-pc_get_mixramp_db(const struct player_control *pc)
-{
- return pc->mixramp_db;
-}
-
-void
-pc_set_mixramp_delay(struct player_control *pc, float mixramp_delay_seconds);
-
-static inline float
-pc_get_mixramp_delay(const struct player_control *pc)
-{
- return pc->mixramp_delay_seconds;
-}
-
-static inline double
-pc_get_total_play_time(const struct player_control *pc)
-{
- return pc->total_play_time;
-}
+ player_error GetErrorType() const {
+ return error_type;
+ }
+
+ void Stop();
+
+ void UpdateAudio();
+
+ /**
+ * @param song the song to be queued; the given instance will be owned
+ * and freed by the player
+ */
+ void EnqueueSong(struct song *song);
+
+ /**
+ * Makes the player thread seek the specified song to a position.
+ *
+ * @param song the song to be queued; the given instance will be owned
+ * and freed by the player
+ * @return true on success, false on failure (e.g. if MPD isn't
+ * playing currently)
+ */
+ bool Seek(struct song *song, float seek_time);
+
+ void SetCrossFade(float cross_fade_seconds);
+
+ float GetCrossFade() const {
+ return cross_fade_seconds;
+ }
+
+ void SetMixRampDb(float mixramp_db);
+
+ float GetMixRampDb() const {
+ return mixramp_db;
+ }
+
+ void SetMixRampDelay(float mixramp_delay_seconds);
+
+ float GetMixRampDelay() const {
+ return mixramp_delay_seconds;
+ }
+
+ double GetTotalPlayTime() const {
+ return total_play_time;
+ }
+};
#endif
diff --git a/src/PlayerThread.cxx b/src/PlayerThread.cxx
index fb743236..d061064b 100644
--- a/src/PlayerThread.cxx
+++ b/src/PlayerThread.cxx
@@ -153,9 +153,9 @@ player_command_finished_locked(struct player_control *pc)
static void
player_command_finished(struct player_control *pc)
{
- player_lock(pc);
+ pc->Lock();
player_command_finished_locked(pc);
- player_unlock(pc);
+ pc->Unlock();
}
/**
@@ -251,13 +251,13 @@ player_wait_for_decoder(struct player *player)
GError *error = dc_lock_get_error(dc);
if (error != NULL) {
- player_lock(pc);
- pc_set_error(pc, PLAYER_ERROR_DECODER, error);
+ pc->Lock();
+ pc->SetError(PLAYER_ERROR_DECODER, error);
song_free(pc->next_song);
pc->next_song = NULL;
- player_unlock(pc);
+ pc->Unlock();
return false;
}
@@ -272,7 +272,7 @@ player_wait_for_decoder(struct player *player)
player_check_decoder_startup() */
player->decoder_starting = true;
- player_lock(pc);
+ pc->Lock();
/* update player_control's song information */
pc->total_time = song_get_duration(pc->next_song);
@@ -282,7 +282,7 @@ player_wait_for_decoder(struct player *player)
/* clear the queued song */
pc->next_song = NULL;
- player_unlock(pc);
+ pc->Unlock();
/* call syncPlaylistWithQueue() in the main thread */
GlobalEvents::Emit(GlobalEvents::PLAYLIST);
@@ -331,9 +331,9 @@ player_open_output(struct player *player)
player->output_open = true;
player->paused = false;
- player_lock(pc);
+ pc->Lock();
pc->state = PLAYER_STATE_PLAY;
- player_unlock(pc);
+ pc->Unlock();
return true;
} else {
@@ -345,10 +345,10 @@ player_open_output(struct player *player)
audio output becomes available */
player->paused = true;
- player_lock(pc);
- pc_set_error(pc, PLAYER_ERROR_OUTPUT, error);
+ pc->Lock();
+ pc->SetError(PLAYER_ERROR_OUTPUT, error);
pc->state = PLAYER_STATE_PAUSE;
- player_unlock(pc);
+ pc->Unlock();
return false;
}
@@ -376,9 +376,9 @@ player_check_decoder_startup(struct player *player)
/* the decoder failed */
decoder_unlock(dc);
- player_lock(pc);
- pc_set_error(pc, PLAYER_ERROR_DECODER, error);
- player_unlock(pc);
+ pc->Lock();
+ pc->SetError(PLAYER_ERROR_DECODER, error);
+ pc->Unlock();
return false;
} else if (!decoder_is_starting(dc)) {
@@ -392,10 +392,10 @@ player_check_decoder_startup(struct player *player)
all chunks yet - wait for that */
return true;
- player_lock(pc);
+ pc->Lock();
pc->total_time = real_song_duration(dc->song, dc->total_time);
pc->audio_format = dc->in_audio_format;
- player_unlock(pc);
+ pc->Unlock();
player->play_audio_format = dc->out_audio_format;
player->decoder_starting = false;
@@ -413,7 +413,7 @@ player_check_decoder_startup(struct player *player)
} else {
/* the decoder is not yet ready; wait
some more */
- player_wait_decoder(pc, dc);
+ dc->WaitForDecoder();
decoder_unlock(dc);
return true;
@@ -565,9 +565,9 @@ static void player_process_command(struct player *player)
break;
case PLAYER_COMMAND_UPDATE_AUDIO:
- player_unlock(pc);
+ pc->Unlock();
audio_output_all_enable_disable();
- player_lock(pc);
+ pc->Lock();
player_command_finished_locked(pc);
break;
@@ -581,33 +581,33 @@ static void player_process_command(struct player *player)
break;
case PLAYER_COMMAND_PAUSE:
- player_unlock(pc);
+ pc->Unlock();
player->paused = !player->paused;
if (player->paused) {
audio_output_all_pause();
- player_lock(pc);
+ pc->Lock();
pc->state = PLAYER_STATE_PAUSE;
} else if (!audio_format_defined(&player->play_audio_format)) {
/* the decoder hasn't provided an audio format
yet - don't open the audio device yet */
- player_lock(pc);
+ pc->Lock();
pc->state = PLAYER_STATE_PLAY;
} else {
player_open_output(player);
- player_lock(pc);
+ pc->Lock();
}
player_command_finished_locked(pc);
break;
case PLAYER_COMMAND_SEEK:
- player_unlock(pc);
+ pc->Unlock();
player_seek_decoder(player);
- player_lock(pc);
+ pc->Lock();
break;
case PLAYER_COMMAND_CANCEL:
@@ -622,9 +622,9 @@ static void player_process_command(struct player *player)
if (player_dc_at_next_song(player)) {
/* the decoder is already decoding the song -
stop it and reset the position */
- player_unlock(pc);
+ pc->Unlock();
player_dc_stop(player);
- player_lock(pc);
+ pc->Lock();
}
song_free(pc->next_song);
@@ -635,9 +635,9 @@ static void player_process_command(struct player *player)
case PLAYER_COMMAND_REFRESH:
if (player->output_open && !player->paused) {
- player_unlock(pc);
+ pc->Unlock();
audio_output_all_check();
- player_lock(pc);
+ pc->Lock();
}
pc->elapsed_time = audio_output_all_get_elapsed_time();
@@ -695,9 +695,9 @@ play_chunk(struct player_control *pc,
return true;
}
- player_lock(pc);
+ pc->Lock();
pc->bit_rate = chunk->bit_rate;
- player_unlock(pc);
+ pc->Unlock();
/* send the chunk to the audio outputs */
@@ -793,7 +793,7 @@ play_next_chunk(struct player *player)
} else {
/* wait for the decoder */
decoder_signal(dc);
- player_wait_decoder(pc, dc);
+ dc->WaitForDecoder();
decoder_unlock(dc);
return true;
@@ -823,16 +823,16 @@ play_next_chunk(struct player *player)
music_buffer_return(player_buffer, chunk);
- player_lock(pc);
+ pc->Lock();
- pc_set_error(pc, PLAYER_ERROR_OUTPUT, error);
+ pc->SetError(PLAYER_ERROR_OUTPUT, error);
/* pause: the user may resume playback as soon as an
audio output becomes available */
pc->state = PLAYER_STATE_PAUSE;
player->paused = true;
- player_unlock(pc);
+ pc->Unlock();
return false;
}
@@ -877,14 +877,14 @@ player_song_border(struct player *player)
return false;
struct player_control *const pc = player->pc;
- player_lock(pc);
+ pc->Lock();
if (pc->border_pause) {
player->paused = true;
pc->state = PLAYER_STATE_PAUSE;
}
- player_unlock(pc);
+ pc->Unlock();
return true;
}
@@ -898,7 +898,7 @@ static void do_play(struct player_control *pc, struct decoder_control *dc)
{
player player(pc, dc);
- player_unlock(pc);
+ pc->Unlock();
player.pipe = music_pipe_new();
@@ -910,11 +910,11 @@ static void do_play(struct player_control *pc, struct decoder_control *dc)
player_command_finished(pc);
music_pipe_free(player.pipe);
GlobalEvents::Emit(GlobalEvents::PLAYLIST);
- player_lock(pc);
+ pc->Lock();
return;
}
- player_lock(pc);
+ pc->Lock();
pc->state = PLAYER_STATE_PLAY;
if (pc->command == PLAYER_COMMAND_SEEK)
@@ -927,12 +927,12 @@ static void do_play(struct player_control *pc, struct decoder_control *dc)
if (pc->command == PLAYER_COMMAND_STOP ||
pc->command == PLAYER_COMMAND_EXIT ||
pc->command == PLAYER_COMMAND_CLOSE_AUDIO) {
- player_unlock(pc);
+ pc->Unlock();
audio_output_all_cancel();
break;
}
- player_unlock(pc);
+ pc->Unlock();
if (player.buffering) {
/* buffering at the start of the song - wait
@@ -951,9 +951,9 @@ static void do_play(struct player_control *pc, struct decoder_control *dc)
decoder_lock(dc);
/* XXX race condition: check decoder again */
- player_wait_decoder(pc, dc);
+ dc->WaitForDecoder();
decoder_unlock(dc);
- player_lock(pc);
+ pc->Lock();
continue;
} else {
/* buffering is complete */
@@ -967,7 +967,7 @@ static void do_play(struct player_control *pc, struct decoder_control *dc)
if (!player_check_decoder_startup(&player))
break;
- player_lock(pc);
+ pc->Lock();
continue;
}
@@ -1020,10 +1020,10 @@ static void do_play(struct player_control *pc, struct decoder_control *dc)
}
if (player.paused) {
- player_lock(pc);
+ pc->Lock();
if (pc->command == PLAYER_COMMAND_NONE)
- player_wait(pc);
+ pc->Wait();
continue;
} else if (!music_pipe_empty(player.pipe)) {
/* at least one music chunk is ready - send it
@@ -1060,7 +1060,7 @@ static void do_play(struct player_control *pc, struct decoder_control *dc)
break;
}
- player_lock(pc);
+ pc->Lock();
}
player_dc_stop(&player);
@@ -1074,7 +1074,7 @@ static void do_play(struct player_control *pc, struct decoder_control *dc)
if (player.song != NULL)
song_free(player.song);
- player_lock(pc);
+ pc->Lock();
if (player.queued) {
assert(pc->next_song != NULL);
@@ -1084,11 +1084,11 @@ static void do_play(struct player_control *pc, struct decoder_control *dc)
pc->state = PLAYER_STATE_STOP;
- player_unlock(pc);
+ pc->Unlock();
GlobalEvents::Emit(GlobalEvents::PLAYLIST);
- player_lock(pc);
+ pc->Lock();
}
static gpointer
@@ -1101,7 +1101,7 @@ player_task(gpointer arg)
player_buffer = music_buffer_new(pc->buffer_chunks);
- player_lock(pc);
+ pc->Lock();
while (1) {
switch (pc->command) {
@@ -1113,9 +1113,9 @@ player_task(gpointer arg)
break;
case PLAYER_COMMAND_STOP:
- player_unlock(pc);
+ pc->Unlock();
audio_output_all_cancel();
- player_lock(pc);
+ pc->Lock();
/* fall through */
@@ -1129,11 +1129,11 @@ player_task(gpointer arg)
break;
case PLAYER_COMMAND_CLOSE_AUDIO:
- player_unlock(pc);
+ pc->Unlock();
audio_output_all_release();
- player_lock(pc);
+ pc->Lock();
player_command_finished_locked(pc);
#ifndef NDEBUG
@@ -1147,14 +1147,14 @@ player_task(gpointer arg)
break;
case PLAYER_COMMAND_UPDATE_AUDIO:
- player_unlock(pc);
+ pc->Unlock();
audio_output_all_enable_disable();
- player_lock(pc);
+ pc->Lock();
player_command_finished_locked(pc);
break;
case PLAYER_COMMAND_EXIT:
- player_unlock(pc);
+ pc->Unlock();
dc_quit(dc);
dc_free(dc);
@@ -1179,7 +1179,7 @@ player_task(gpointer arg)
break;
case PLAYER_COMMAND_NONE:
- player_wait(pc);
+ pc->Wait();
break;
}
}
diff --git a/src/Playlist.cxx b/src/Playlist.cxx
index 1977188d..89bdac63 100644
--- a/src/Playlist.cxx
+++ b/src/Playlist.cxx
@@ -69,7 +69,7 @@ playlist_queue_song_order(struct playlist *playlist, struct player_control *pc,
g_debug("queue song %i:\"%s\"", playlist->queued, uri);
g_free(uri);
- pc_enqueue_song(pc, song);
+ pc->EnqueueSong(song);
}
/**
@@ -136,7 +136,7 @@ playlist::UpdateQueuedSong(player_control &pc, const song *prev)
if (prev != NULL && next_song != prev) {
/* clear the currently queued song */
- pc_cancel(&pc);
+ pc.Cancel();
queued = -1;
}
@@ -160,7 +160,7 @@ playlist::PlayOrder(player_control &pc, int order)
g_debug("play %i:\"%s\"", order, uri);
g_free(uri);
- pc_play(&pc, song);
+ pc.Play(song);
current = order;
}
@@ -175,10 +175,10 @@ playlist::SyncWithPlayer(player_control &pc)
playing anymore; ignore the event */
return;
- player_lock(&pc);
- const enum player_state pc_state = pc_get_state(&pc);
+ pc.Lock();
+ const player_state pc_state = pc.GetState();
const song *pc_next_song = pc.next_song;
- player_unlock(&pc);
+ pc.Unlock();
if (pc_state == PLAYER_STATE_STOP)
/* the player thread has stopped: check if playback
@@ -192,9 +192,9 @@ playlist::SyncWithPlayer(player_control &pc)
if (pc_next_song == nullptr && queued != -1)
playlist_song_started(this, &pc);
- player_lock(&pc);
+ pc.Lock();
pc_next_song = pc.next_song;
- player_unlock(&pc);
+ pc.Unlock();
/* make sure the queued song is always set (if
possible) */
@@ -210,12 +210,10 @@ playlist::SyncWithPlayer(player_control &pc)
static void
playlist_resume_playback(struct playlist *playlist, struct player_control *pc)
{
- enum player_error error;
-
assert(playlist->playing);
- assert(pc_get_state(pc) == PLAYER_STATE_STOP);
+ assert(pc->GetState() == PLAYER_STATE_STOP);
- error = pc_get_error_type(pc);
+ const auto error = pc->GetErrorType();
if (error == PLAYER_ERROR_NONE)
playlist->error_count = 0;
else
@@ -240,7 +238,7 @@ playlist::SetRepeat(player_control &pc, bool status)
queue.repeat = status;
- pc_set_border_pause(&pc, queue.single && !queue.repeat);
+ pc.SetBorderPause(queue.single && !queue.repeat);
/* if the last song is currently being played, the "next song"
might change when repeat mode is toggled */
@@ -267,7 +265,7 @@ playlist::SetSingle(player_control &pc, bool status)
queue.single = status;
- pc_set_border_pause(&pc, queue.single && !queue.repeat);
+ pc.SetBorderPause(queue.single && !queue.repeat);
/* if the last song is currently being played, the "next song"
might change when single mode is toggled */
diff --git a/src/PlaylistControl.cxx b/src/PlaylistControl.cxx
index 32319224..3db61cc7 100644
--- a/src/PlaylistControl.cxx
+++ b/src/PlaylistControl.cxx
@@ -41,7 +41,7 @@ playlist::Stop(player_control &pc)
assert(current >= 0);
g_debug("stop");
- pc_stop(&pc);
+ pc.Stop();
queued = -1;
playing = false;
@@ -62,7 +62,7 @@ playlist::Stop(player_control &pc)
enum playlist_result
playlist::PlayPosition(player_control &pc, int song)
{
- pc_clear_error(&pc);
+ pc.ClearError();
unsigned i = song;
if (song == -1) {
@@ -74,7 +74,7 @@ playlist::PlayPosition(player_control &pc, int song)
if (playing) {
/* already playing: unpause playback, just in
case it was paused, and return */
- pc_set_pause(&pc, false);
+ pc.SetPause(false);
return PLAYLIST_RESULT_SUCCESS;
}
@@ -204,7 +204,7 @@ playlist::SeekSongPosition(player_control &pc, unsigned song, float seek_time)
? queue.PositionToOrder(song)
: song;
- pc_clear_error(&pc);
+ pc.ClearError();
stop_on_error = true;
error_count = 0;
@@ -219,7 +219,7 @@ playlist::SeekSongPosition(player_control &pc, unsigned song, float seek_time)
}
struct song *the_song = song_dup_detached(queue.GetOrder(i));
- if (!pc_seek(&pc, the_song, seek_time)) {
+ if (!pc.Seek(the_song, seek_time)) {
UpdateQueuedSong(pc, queued_song);
return PLAYLIST_RESULT_NOT_PLAYING;
@@ -248,8 +248,7 @@ playlist::SeekCurrent(player_control &pc, float seek_time, bool relative)
return PLAYLIST_RESULT_NOT_PLAYING;
if (relative) {
- struct player_status status;
- pc_get_status(&pc, &status);
+ const auto status = pc.GetStatus();
if (status.state != PLAYER_STATE_PLAY &&
status.state != PLAYER_STATE_PAUSE)
diff --git a/src/PlaylistEdit.cxx b/src/PlaylistEdit.cxx
index 138289dd..df38c3da 100644
--- a/src/PlaylistEdit.cxx
+++ b/src/PlaylistEdit.cxx
@@ -229,11 +229,11 @@ playlist::DeleteInternal(player_control &pc,
unsigned songOrder = queue.PositionToOrder(song);
if (playing && current == (int)songOrder) {
- bool paused = pc_get_state(&pc) == PLAYER_STATE_PAUSE;
+ const bool paused = pc.GetState() == PLAYER_STATE_PAUSE;
/* the current song is going to be deleted: stop the player */
- pc_stop(&pc);
+ pc.Stop();
playing = false;
/* see which song is going to be played instead */
diff --git a/src/PlaylistState.cxx b/src/PlaylistState.cxx
index 14c6d231..212b5286 100644
--- a/src/PlaylistState.cxx
+++ b/src/PlaylistState.cxx
@@ -56,9 +56,7 @@ void
playlist_state_save(FILE *fp, const struct playlist *playlist,
struct player_control *pc)
{
- struct player_status player_status;
-
- pc_get_status(pc, &player_status);
+ const auto player_status = pc->GetStatus();
fputs(PLAYLIST_STATE_FILE_STATE, fp);
@@ -88,11 +86,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(pc)));
+ (int)pc->GetCrossFade());
fprintf(fp, PLAYLIST_STATE_FILE_MIXRAMPDB "%f\n",
- pc_get_mixramp_db(pc));
+ pc->GetMixRampDb());
fprintf(fp, PLAYLIST_STATE_FILE_MIXRAMPDELAY "%f\n",
- pc_get_mixramp_delay(pc));
+ pc->GetMixRampDelay());
fputs(PLAYLIST_STATE_FILE_PLAYLIST_BEGIN "\n", fp);
queue_save(fp, &playlist->queue);
fputs(PLAYLIST_STATE_FILE_PLAYLIST_END "\n", fp);
@@ -156,14 +154,11 @@ playlist_state_restore(const char *line, TextFile &file,
playlist->SetConsume(strcmp(&(line[strlen(PLAYLIST_STATE_FILE_CONSUME)]),
"1") == 0);
} else if (g_str_has_prefix(line, PLAYLIST_STATE_FILE_CROSSFADE)) {
- pc_set_cross_fade(pc,
- atoi(line + strlen(PLAYLIST_STATE_FILE_CROSSFADE)));
+ pc->SetCrossFade(atoi(line + strlen(PLAYLIST_STATE_FILE_CROSSFADE)));
} else if (g_str_has_prefix(line, PLAYLIST_STATE_FILE_MIXRAMPDB)) {
- pc_set_mixramp_db(pc,
- atof(line + strlen(PLAYLIST_STATE_FILE_MIXRAMPDB)));
+ pc->SetMixRampDb(atof(line + strlen(PLAYLIST_STATE_FILE_MIXRAMPDB)));
} else if (g_str_has_prefix(line, PLAYLIST_STATE_FILE_MIXRAMPDELAY)) {
- pc_set_mixramp_delay(pc,
- atof(line + strlen(PLAYLIST_STATE_FILE_MIXRAMPDELAY)));
+ pc->SetMixRampDelay(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),
@@ -195,7 +190,7 @@ playlist_state_restore(const char *line, TextFile &file,
called here, after the audio output states were
restored, before playback begins */
if (state != PLAYER_STATE_STOP)
- pc_update_audio(pc);
+ pc->UpdateAudio();
if (state == PLAYER_STATE_STOP /* && config_option */)
playlist->current = current;
@@ -205,7 +200,7 @@ playlist_state_restore(const char *line, TextFile &file,
playlist->SeekSongPosition(*pc, current, seek_time);
if (state == PLAYER_STATE_PAUSE)
- pc_pause(pc);
+ pc->Pause();
}
return true;
@@ -215,9 +210,7 @@ unsigned
playlist_state_get_hash(const struct playlist *playlist,
struct player_control *pc)
{
- struct player_status player_status;
-
- pc_get_status(pc, &player_status);
+ const auto player_status = pc->GetStatus();
return playlist->queue.version ^
(player_status.state != PLAYER_STATE_STOP
@@ -226,7 +219,7 @@ playlist_state_get_hash(const struct playlist *playlist,
(playlist->current >= 0
? (playlist->queue.OrderToPosition(playlist->current) << 16)
: 0) ^
- ((int)pc_get_cross_fade(pc) << 20) ^
+ ((int)pc->GetCrossFade() << 20) ^
(player_status.state << 24) ^
(playlist->queue.random << 27) ^
(playlist->queue.repeat << 28) ^
diff --git a/src/Stats.cxx b/src/Stats.cxx
index f848a9b0..354d26c5 100644
--- a/src/Stats.cxx
+++ b/src/Stats.cxx
@@ -79,7 +79,7 @@ stats_print(Client *client)
stats.album_count,
stats.song_count,
(long)g_timer_elapsed(stats.timer, NULL),
- (long)(pc_get_total_play_time(client->player_control) + 0.5),
+ (long)(client->player_control->GetTotalPlayTime() + 0.5),
stats.song_duration);
if (db_is_simple())
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-28 19:48:24 +0000