static void * update_task(void *_path)
{
const char *path = _path;
if (path != NULL && *path != 0)
g_debug("starting: %s", path);
else
g_debug("starting");
modified = update_walk(path, discard);
if (modified || !db_exists()) {
GError *error = NULL;
if (!db_save(&error)) {
g_warning("Failed to save database: %s",
error->message);
g_error_free(error);
}
}
if (path != NULL && *path != 0)
g_debug("finished: %s", path);
else
g_debug("finished");
g_free(_path);
progress = UPDATE_PROGRESS_DONE;
event_pipe_emit(PIPE_EVENT_UPDATE);
return NULL;
}
static DWORD WINAPI
service_dispatcher(G_GNUC_UNUSED DWORD control, G_GNUC_UNUSED DWORD event_type,
G_GNUC_UNUSED void *event_data, G_GNUC_UNUSED void *context)
{
switch (control) {
case SERVICE_CONTROL_SHUTDOWN:
case SERVICE_CONTROL_STOP:
event_pipe_emit(PIPE_EVENT_SHUTDOWN);
return NO_ERROR;
default:
return NO_ERROR;
}
}
static BOOL WINAPI
console_handler(DWORD event)
{
switch (event) {
case CTRL_C_EVENT:
case CTRL_CLOSE_EVENT:
if (!ignore_console_events)
event_pipe_emit(PIPE_EVENT_SHUTDOWN);
return TRUE;
default:
return FALSE;
}
}
/**
* After the decoder has been started asynchronously, wait for the
* "START" command to finish. The decoder may not be initialized yet,
* i.e. there is no audio_format information yet.
*
* The player lock is not held.
*/
static bool
player_wait_for_decoder(struct player *player)
{
struct player_control *pc = player->pc;
struct decoder_control *dc = player->dc;
assert(player->queued || pc->command == PLAYER_COMMAND_SEEK);
assert(pc->next_song != NULL);
player->queued = false;
GError *error = dc_lock_get_error(dc);
if (error != NULL) {
player_lock(pc);
pc_set_error(pc, PLAYER_ERROR_DECODER, error);
song_free(pc->next_song);
pc->next_song = NULL;
player_unlock(pc);
return false;
}
if (player->song != NULL)
song_free(player->song);
player->song = pc->next_song;
player->elapsed_time = 0.0;
/* set the "starting" flag, which will be cleared by
player_check_decoder_startup() */
player->decoder_starting = true;
player_lock(pc);
/* update player_control's song information */
pc->total_time = song_get_duration(pc->next_song);
pc->bit_rate = 0;
audio_format_clear(&pc->audio_format);
/* clear the queued song */
pc->next_song = NULL;
player_unlock(pc);
/* call syncPlaylistWithQueue() in the main thread */
event_pipe_emit(PIPE_EVENT_PLAYLIST);
return true;
}
/**
* After the decoder has been started asynchronously, wait for the
* "START" command to finish. The decoder may not be initialized yet,
* i.e. there is no audio_format information yet.
*
* The player lock is not held.
*/
static bool
player_wait_for_decoder(struct player *player)
{
struct decoder_control *dc = player->dc;
assert(player->queued || pc.command == PLAYER_COMMAND_SEEK);
assert(pc.next_song != NULL);
player->queued = false;
if (decoder_lock_has_failed(dc)) {
player_lock();
pc.errored_song = dc->song;
pc.error = PLAYER_ERROR_FILE;
pc.next_song = NULL;
player_unlock();
return false;
}
player->song = pc.next_song;
player->elapsed_time = 0.0;
/* set the "starting" flag, which will be cleared by
player_check_decoder_startup() */
player->decoder_starting = true;
player_lock();
/* update player_control's song information */
pc.total_time = song_get_duration(pc.next_song);
pc.bit_rate = 0;
audio_format_clear(&pc.audio_format);
/* clear the queued song */
pc.next_song = NULL;
player_unlock();
/* call syncPlaylistWithQueue() in the main thread */
event_pipe_emit(PIPE_EVENT_PLAYLIST);
return true;
}
static void
update_song_tag(struct song *song, const struct tag *new_tag)
{
if (song_is_file(song))
/* don't update tags of local files, only remote
streams may change tags dynamically */
return;
struct tag *old_tag = song->tag;
song->tag = tag_dup(new_tag);
if (old_tag != NULL)
tag_free(old_tag);
/* the main thread will update the playlist version when he
receives this event */
event_pipe_emit(PIPE_EVENT_TAG);
/* notify all clients that the tag of the current song has
changed */
idle_add(IDLE_PLAYER);
}
static void * update_task(void *_path)
{
const char *path = _path;
if (path != NULL && *path != 0)
g_debug("starting: %s", path);
else
g_debug("starting");
modified = update_walk(path, discard);
if (modified || !db_exists())
db_save();
if (path != NULL && *path != 0)
g_debug("finished: %s", path);
else
g_debug("finished");
g_free(_path);
progress = UPDATE_PROGRESS_DONE;
event_pipe_emit(PIPE_EVENT_UPDATE);
return NULL;
}
/*
* The main loop of the player thread, during playback. This is
* basically a state machine, which multiplexes data between the
* decoder thread and the output threads.
*/
static void do_play(struct player_control *pc, struct decoder_control *dc)
{
struct player player = {
.pc = pc,
.dc = dc,
.buffering = true,
.decoder_starting = false,
.paused = false,
.queued = true,
.song = NULL,
.xfade = XFADE_UNKNOWN,
.cross_fading = false,
.cross_fade_chunks = 0,
.cross_fade_tag = NULL,
.elapsed_time = 0.0,
};
player_unlock(pc);
player.pipe = music_pipe_new();
player_dc_start(&player, player.pipe);
if (!player_wait_for_decoder(&player)) {
player_dc_stop(&player);
player_command_finished(pc);
music_pipe_free(player.pipe);
event_pipe_emit(PIPE_EVENT_PLAYLIST);
player_lock(pc);
return;
}
player_lock(pc);
pc->state = PLAYER_STATE_PLAY;
player_command_finished_locked(pc);
while (true) {
player_process_command(&player);
if (pc->command == PLAYER_COMMAND_STOP ||
pc->command == PLAYER_COMMAND_EXIT ||
pc->command == PLAYER_COMMAND_CLOSE_AUDIO) {
player_unlock(pc);
audio_output_all_cancel();
break;
}
player_unlock(pc);
if (player.buffering) {
/* buffering at the start of the song - wait
until the buffer is large enough, to
prevent stuttering on slow machines */
if (music_pipe_size(player.pipe) < pc->buffered_before_play &&
!decoder_lock_is_idle(dc)) {
/* not enough decoded buffer space yet */
if (!player.paused &&
audio_format_defined(&player.play_audio_format) &&
audio_output_all_check() < 4 &&
!player_send_silence(&player))
break;
decoder_lock(dc);
/* XXX race condition: check decoder again */
player_wait_decoder(pc, dc);
decoder_unlock(dc);
player_lock(pc);
continue;
} else {
/* buffering is complete */
player.buffering = false;
}
}
if (player.decoder_starting) {
/* wait until the decoder is initialized completely */
if (!player_check_decoder_startup(&player))
break;
player_lock(pc);
continue;
}
#ifndef NDEBUG
/*
music_pipe_check_format(&play_audio_format,
player.next_song_chunk,
&dc->out_audio_format);
*/
#endif
if (decoder_lock_is_idle(dc) && player.queued &&
dc->pipe == player.pipe) {
/* the decoder has finished the current song;
make it decode the next song */
assert(dc->pipe == NULL || dc->pipe == player.pipe);
player_dc_start(&player, music_pipe_new());
}
if (player_dc_at_next_song(&player) &&
player.xfade == XFADE_UNKNOWN &&
!decoder_lock_is_starting(dc)) {
/* enable cross fading in this song? if yes,
calculate how many chunks will be required
for it */
player.cross_fade_chunks =
cross_fade_calc(pc->cross_fade_seconds, dc->total_time,
pc->mixramp_db,
pc->mixramp_delay_seconds,
dc->replay_gain_db,
dc->replay_gain_prev_db,
dc->mixramp_start,
dc->mixramp_prev_end,
&dc->out_audio_format,
&player.play_audio_format,
music_buffer_size(player_buffer) -
pc->buffered_before_play);
if (player.cross_fade_chunks > 0) {
player.xfade = XFADE_ENABLED;
player.cross_fading = false;
} else
/* cross fading is disabled or the
next song is too short */
player.xfade = XFADE_DISABLED;
}
if (player.paused) {
player_lock(pc);
if (pc->command == PLAYER_COMMAND_NONE)
player_wait(pc);
continue;
} else if (!music_pipe_empty(player.pipe)) {
/* at least one music chunk is ready - send it
to the audio output */
play_next_chunk(&player);
} else if (audio_output_all_check() > 0) {
/* not enough data from decoder, but the
output thread is still busy, so it's
okay */
/* XXX synchronize in a better way */
g_usleep(10000);
} else if (player_dc_at_next_song(&player)) {
/* at the beginning of a new song */
if (!player_song_border(&player))
break;
} else if (decoder_lock_is_idle(dc)) {
/* check the size of the pipe again, because
the decoder thread may have added something
since we last checked */
if (music_pipe_empty(player.pipe)) {
/* wait for the hardware to finish
playback */
audio_output_all_drain();
break;
}
} else {
/* the decoder is too busy and hasn't provided
new PCM data in time: send silence (if the
output pipe is empty) */
if (!player_send_silence(&player))
break;
}
player_lock(pc);
}
player_dc_stop(&player);
music_pipe_clear(player.pipe, player_buffer);
music_pipe_free(player.pipe);
if (player.cross_fade_tag != NULL)
tag_free(player.cross_fade_tag);
player_lock(pc);
if (player.queued) {
assert(pc->next_song != NULL);
pc->next_song = NULL;
}
pc->state = PLAYER_STATE_STOP;
player_unlock(pc);
event_pipe_emit(PIPE_EVENT_PLAYLIST);
player_lock(pc);
}
static gpointer
player_task(gpointer arg)
{
struct player_control *pc = arg;
struct decoder_control *dc = dc_new(pc->cond);
decoder_thread_start(dc);
player_buffer = music_buffer_new(pc->buffer_chunks);
player_lock(pc);
while (1) {
switch (pc->command) {
case PLAYER_COMMAND_QUEUE:
assert(pc->next_song != NULL);
do_play(pc, dc);
break;
case PLAYER_COMMAND_STOP:
player_unlock(pc);
audio_output_all_cancel();
player_lock(pc);
/* fall through */
case PLAYER_COMMAND_SEEK:
case PLAYER_COMMAND_PAUSE:
pc->next_song = NULL;
player_command_finished_locked(pc);
break;
case PLAYER_COMMAND_CLOSE_AUDIO:
player_unlock(pc);
audio_output_all_release();
player_lock(pc);
player_command_finished_locked(pc);
#ifndef NDEBUG
/* in the DEBUG build, check for leaked
music_chunk objects by freeing the
music_buffer */
music_buffer_free(player_buffer);
player_buffer = music_buffer_new(pc->buffer_chunks);
#endif
break;
case PLAYER_COMMAND_UPDATE_AUDIO:
player_unlock(pc);
audio_output_all_enable_disable();
player_lock(pc);
player_command_finished_locked(pc);
break;
case PLAYER_COMMAND_EXIT:
player_unlock(pc);
dc_quit(dc);
dc_free(dc);
audio_output_all_close();
music_buffer_free(player_buffer);
player_command_finished(pc);
return NULL;
case PLAYER_COMMAND_CANCEL:
pc->next_song = NULL;
player_command_finished_locked(pc);
break;
case PLAYER_COMMAND_REFRESH:
/* no-op when not playing */
player_command_finished_locked(pc);
break;
case PLAYER_COMMAND_NONE:
player_wait(pc);
break;
}
}
}
void
player_create(struct player_control *pc)
{
assert(pc->thread == NULL);
GError *e = NULL;
pc->thread = g_thread_create(player_task, pc, true, &e);
if (pc->thread == NULL)
MPD_ERROR("Failed to spawn player task: %s", e->message);
}