From e1b03b4a716dbb35a737d34fba531e623f7980f3 Mon Sep 17 00:00:00 2001 From: Max Kellermann Date: Sun, 20 Jan 2013 17:48:23 +0100 Subject: PlayerControl: move functions into the class --- src/PlayerControl.hxx | 288 +++++++++++++++++++++----------------------------- 1 file changed, 121 insertions(+), 167 deletions(-) (limited to 'src/PlayerControl.hxx') 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 -- cgit v1.2.3