/* * Copyright (C) 2003-2010 The Music Player Daemon Project * http://www.musicpd.org * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include "config.h" #include "player_thread.h" #include "player_control.h" #include "decoder_control.h" #include "decoder_thread.h" #include "output_all.h" #include "pcm_volume.h" #include "path.h" #include "event_pipe.h" #include "crossfade.h" #include "song.h" #include "tag.h" #include "pipe.h" #include "chunk.h" #include "idle.h" #include "main.h" #include "buffer.h" #include "mpd_error.h" #include <glib.h> #undef G_LOG_DOMAIN #define G_LOG_DOMAIN "player_thread" enum xfade_state { XFADE_DISABLED = -1, XFADE_UNKNOWN = 0, XFADE_ENABLED = 1 }; struct player { struct decoder_control *dc; struct music_pipe *pipe; /** * are we waiting for buffered_before_play? */ bool buffering; /** * true if the decoder is starting and did not provide data * yet */ bool decoder_starting; /** * is the player paused? */ bool paused; /** * is there a new song in pc.next_song? */ bool queued; /** * the song currently being played */ struct song *song; /** * is cross fading enabled? */ enum xfade_state xfade; /** * has cross-fading begun? */ bool cross_fading; /** * The number of chunks used for crossfading. */ unsigned cross_fade_chunks; /** * The tag of the "next" song during cross-fade. It is * postponed, and sent to the output thread when the new song * really begins. */ struct tag *cross_fade_tag; /** * The current audio format for the audio outputs. */ struct audio_format play_audio_format; /** * The time stamp of the chunk most recently sent to the * output thread. This attribute is only used if * audio_output_all_get_elapsed_time() didn't return a usable * value; the output thread can estimate the elapsed time more * precisly. */ float elapsed_time; }; static struct music_buffer *player_buffer; static void player_command_finished_locked(void) { assert(pc.command != PLAYER_COMMAND_NONE); pc.command = PLAYER_COMMAND_NONE; g_cond_signal(main_cond); } static void player_command_finished(void) { player_lock(); player_command_finished_locked(); player_unlock(); } /** * Start the decoder. * * Player lock is not held. */ static void player_dc_start(struct player *player, struct music_pipe *pipe) { struct decoder_control *dc = player->dc; assert(player->queued || pc.command == PLAYER_COMMAND_SEEK); assert(pc.next_song != NULL); dc_start(dc, pc.next_song, player_buffer, pipe); } /** * Is the decoder still busy on the same song as the player? * * Note: this function does not check if the decoder is already * finished. */ static bool player_dc_at_current_song(const struct player *player) { assert(player != NULL); assert(player->pipe != NULL); return player->dc->pipe == player->pipe; } /** * Returns true if the decoder is decoding the next song (or has begun * decoding it, or has finished doing it), and the player hasn't * switched to that song yet. */ static bool player_dc_at_next_song(const struct player *player) { return player->dc->pipe != NULL && !player_dc_at_current_song(player); } /** * Stop the decoder and clears (and frees) its music pipe. * * Player lock is not held. */ static void player_dc_stop(struct player *player) { struct decoder_control *dc = player->dc; dc_stop(dc); if (dc->pipe != NULL) { /* clear and free the decoder pipe */ music_pipe_clear(dc->pipe, player_buffer); if (dc->pipe != player->pipe) music_pipe_free(dc->pipe); dc->pipe = NULL; } } /** * 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; } /** * Returns the real duration of the song, comprising the duration * indicated by the decoder plugin. */ static double real_song_duration(const struct song *song, double decoder_duration) { assert(song != NULL); if (decoder_duration <= 0.0) /* the decoder plugin didn't provide information; fall back to song_get_duration() */ return song_get_duration(song); if (song->end_ms > 0 && song->end_ms / 1000.0 < decoder_duration) return (song->end_ms - song->start_ms) / 1000.0; return decoder_duration - song->start_ms / 1000.0; } /** * The decoder has acknowledged the "START" command (see * player_wait_for_decoder()). This function checks if the decoder * initialization has completed yet. * * The player lock is not held. */ static bool player_check_decoder_startup(struct player *player) { struct decoder_control *dc = player->dc; assert(player->decoder_starting); decoder_lock(dc); if (decoder_has_failed(dc)) { /* the decoder failed */ decoder_unlock(dc); player_lock(); pc.errored_song = dc->song; pc.error = PLAYER_ERROR_FILE; player_unlock(); return false; } else if (!decoder_is_starting(dc)) { /* the decoder is ready and ok */ decoder_unlock(dc); if (audio_format_defined(&player->play_audio_format) && !audio_output_all_wait(1)) /* the output devices havn't finished playing all chunks yet - wait for that */ return true; player_lock(); pc.total_time = real_song_duration(dc->song, dc->total_time); pc.audio_format = dc->in_audio_format; player_unlock(); player->play_audio_format = dc->out_audio_format; player->decoder_starting = false; if (!player->paused && !audio_output_all_open(&dc->out_audio_format, player_buffer)) { char *uri = song_get_uri(dc->song); g_warning("problems opening audio device " "while playing \"%s\"", uri); g_free(uri); player_lock(); pc.error = PLAYER_ERROR_AUDIO; /* pause: the user may resume playback as soon as an audio output becomes available */ pc.state = PLAYER_STATE_PAUSE; player_unlock(); player->paused = true; return true; } return true; } else { /* the decoder is not yet ready; wait some more */ player_wait_decoder(dc); decoder_unlock(dc); return true; } } /** * Sends a chunk of silence to the audio outputs. This is called when * there is not enough decoded data in the pipe yet, to prevent * underruns in the hardware buffers. * * The player lock is not held. */ static bool player_send_silence(struct player *player) { struct music_chunk *chunk; size_t frame_size = audio_format_frame_size(&player->play_audio_format); /* this formula ensures that we don't send partial frames */ unsigned num_frames = sizeof(chunk->data) / frame_size; assert(audio_format_defined(&player->play_audio_format)); chunk = music_buffer_allocate(player_buffer); if (chunk == NULL) { g_warning("Failed to allocate silence buffer"); return false; } #ifndef NDEBUG chunk->audio_format = player->play_audio_format; #endif chunk->times = -1.0; /* undefined time stamp */ chunk->length = num_frames * frame_size; memset(chunk->data, 0, chunk->length); if (!audio_output_all_play(chunk)) { music_buffer_return(player_buffer, chunk); return false; } return true; } /** * This is the handler for the #PLAYER_COMMAND_SEEK command. * * The player lock is not held. */ static bool player_seek_decoder(struct player *player) { struct song *song = pc.next_song; struct decoder_control *dc = player->dc; double where; bool ret; assert(pc.next_song != NULL); if (decoder_current_song(dc) != song) { /* the decoder is already decoding the "next" song - stop it and start the previous song again */ player_dc_stop(player); /* clear music chunks which might still reside in the pipe */ music_pipe_clear(player->pipe, player_buffer); /* re-start the decoder */ player_dc_start(player, player->pipe); ret = player_wait_for_decoder(player); if (!ret) { /* decoder failure */ player_command_finished(); return false; } } else { if (!player_dc_at_current_song(player)) { /* the decoder is already decoding the "next" song, but it is the same song file; exchange the pipe */ music_pipe_clear(player->pipe, player_buffer); music_pipe_free(player->pipe); player->pipe = dc->pipe; } pc.next_song = NULL; player->queued = false; } /* wait for the decoder to complete initialization */ while (player->decoder_starting) { ret = player_check_decoder_startup(player); if (!ret) { /* decoder failure */ player_command_finished(); return false; } } /* send the SEEK command */ where = pc.seek_where; if (where > pc.total_time) where = pc.total_time - 0.1; if (where < 0.0) where = 0.0; ret = dc_seek(dc, where + song->start_ms / 1000.0); if (!ret) { /* decoder failure */ player_command_finished(); return false; } player->elapsed_time = where; player_command_finished(); player->xfade = XFADE_UNKNOWN; /* re-fill the buffer after seeking */ player->buffering = true; audio_output_all_cancel(); return true; } /** * Player lock must be held before calling. */ static void player_process_command(struct player *player) { G_GNUC_UNUSED struct decoder_control *dc = player->dc; switch (pc.command) { case PLAYER_COMMAND_NONE: case PLAYER_COMMAND_STOP: case PLAYER_COMMAND_EXIT: case PLAYER_COMMAND_CLOSE_AUDIO: break; case PLAYER_COMMAND_UPDATE_AUDIO: player_unlock(); audio_output_all_enable_disable(); player_lock(); player_command_finished_locked(); break; case PLAYER_COMMAND_QUEUE: assert(pc.next_song != NULL); assert(!player->queued); assert(!player_dc_at_next_song(player)); player->queued = true; player_command_finished_locked(); break; case PLAYER_COMMAND_PAUSE: player_unlock(); player->paused = !player->paused; if (player->paused) { audio_output_all_pause(); player_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.state = PLAYER_STATE_PLAY; } else if (audio_output_all_open(&player->play_audio_format, player_buffer)) { /* unpaused, continue playing */ player_lock(); pc.state = PLAYER_STATE_PLAY; } else { /* the audio device has failed - rollback to pause mode */ pc.error = PLAYER_ERROR_AUDIO; player->paused = true; player_lock(); } player_command_finished_locked(); break; case PLAYER_COMMAND_SEEK: player_unlock(); player_seek_decoder(player); player_lock(); break; case PLAYER_COMMAND_CANCEL: if (pc.next_song == NULL) { /* the cancel request arrived too late, we're already playing the queued song... stop everything now */ pc.command = PLAYER_COMMAND_STOP; return; } if (player_dc_at_next_song(player)) { /* the decoder is already decoding the song - stop it and reset the position */ player_unlock(); player_dc_stop(player); player_lock(); } pc.next_song = NULL; player->queued = false; player_command_finished_locked(); break; case PLAYER_COMMAND_REFRESH: if (audio_format_defined(&player->play_audio_format) && !player->paused) { player_unlock(); audio_output_all_check(); player_lock(); } pc.elapsed_time = audio_output_all_get_elapsed_time(); if (pc.elapsed_time < 0.0) pc.elapsed_time = player->elapsed_time; player_command_finished_locked(); break; } } static void update_song_tag(struct song *song, const struct tag *new_tag) { struct tag *old_tag; if (song_is_file(song)) /* don't update tags of local files, only remote streams may change tags dynamically */ return; 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); } /** * Plays a #music_chunk object (after applying software volume). If * it contains a (stream) tag, copy it to the current song, so MPD's * playlist reflects the new stream tag. * * Player lock is not held. */ static bool play_chunk(struct song *song, struct music_chunk *chunk, const struct audio_format *format) { assert(music_chunk_check_format(chunk, format)); if (chunk->tag != NULL) update_song_tag(song, chunk->tag); if (chunk->length == 0) { music_buffer_return(player_buffer, chunk); return true; } pc.bit_rate = chunk->bit_rate; /* send the chunk to the audio outputs */ if (!audio_output_all_play(chunk)) return false; pc.total_play_time += (double)chunk->length / audio_format_time_to_size(format); return true; } /** * Obtains the next chunk from the music pipe, optionally applies * cross-fading, and sends it to all audio outputs. * * @return true on success, false on error (playback will be stopped) */ static bool play_next_chunk(struct player *player) { struct decoder_control *dc = player->dc; struct music_chunk *chunk = NULL; unsigned cross_fade_position; bool success; if (!audio_output_all_wait(64)) /* the output pipe is still large enough, don't send another chunk */ return true; if (player->xfade == XFADE_ENABLED && player_dc_at_next_song(player) && (cross_fade_position = music_pipe_size(player->pipe)) <= player->cross_fade_chunks) { /* perform cross fade */ struct music_chunk *other_chunk = music_pipe_shift(dc->pipe); if (!player->cross_fading) { /* beginning of the cross fade - adjust crossFadeChunks which might be bigger than the remaining number of chunks in the old song */ player->cross_fade_chunks = cross_fade_position; player->cross_fading = true; } if (other_chunk != NULL) { chunk = music_pipe_shift(player->pipe); assert(chunk != NULL); assert(chunk->other == NULL); /* don't send the tags of the new song (which is being faded in) yet; postpone it until the current song is faded out */ player->cross_fade_tag = tag_merge_replace(player->cross_fade_tag, other_chunk->tag); other_chunk->tag = NULL; if (isnan(pc.mixramp_delay_seconds)) { chunk->mix_ratio = ((float)cross_fade_position) / player->cross_fade_chunks; } else { chunk->mix_ratio = nan(""); } chunk->other = other_chunk; } else { /* there are not enough decoded chunks yet */ decoder_lock(dc); if (decoder_is_idle(dc)) { /* the decoder isn't running, abort cross fading */ decoder_unlock(dc); player->xfade = XFADE_DISABLED; } else { /* wait for the decoder */ decoder_signal(dc); player_wait_decoder(dc); decoder_unlock(dc); return true; } } } if (chunk == NULL) chunk = music_pipe_shift(player->pipe); assert(chunk != NULL); /* insert the postponed tag if cross-fading is finished */ if (player->xfade != XFADE_ENABLED && player->cross_fade_tag != NULL) { chunk->tag = tag_merge_replace(chunk->tag, player->cross_fade_tag); player->cross_fade_tag = NULL; } /* play the current chunk */ success = play_chunk(player->song, chunk, &player->play_audio_format); if (!success) { music_buffer_return(player_buffer, chunk); player_lock(); pc.error = PLAYER_ERROR_AUDIO; /* pause: the user may resume playback as soon as an audio output becomes available */ pc.state = PLAYER_STATE_PAUSE; player->paused = true; player_unlock(); return false; } /* this formula should prevent that the decoder gets woken up with each chunk; it is more efficient to make it decode a larger block at a time */ decoder_lock(dc); if (!decoder_is_idle(dc) && music_pipe_size(dc->pipe) <= (pc.buffered_before_play + music_buffer_size(player_buffer) * 3) / 4) decoder_signal(dc); decoder_unlock(dc); return true; } /** * This is called at the border between two songs: the audio output * has consumed all chunks of the current song, and we should start * sending chunks from the next one. * * The player lock is not held. * * @return true on success, false on error (playback will be stopped) */ static bool player_song_border(struct player *player) { char *uri; player->xfade = XFADE_UNKNOWN; uri = song_get_uri(player->song); g_message("played \"%s\"", uri); g_free(uri); music_pipe_free(player->pipe); player->pipe = player->dc->pipe; audio_output_all_song_border(); if (!player_wait_for_decoder(player)) return false; return true; } /* * 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 decoder_control *dc) { struct player player = { .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(); player.pipe = music_pipe_new(); player_dc_start(&player, player.pipe); if (!player_wait_for_decoder(&player)) { player_dc_stop(&player); player_command_finished(); music_pipe_free(player.pipe); event_pipe_emit(PIPE_EVENT_PLAYLIST); player_lock(); return; } player_lock(); pc.state = PLAYER_STATE_PLAY; player_command_finished_locked(); 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(); audio_output_all_cancel(); break; } player_unlock(); 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(dc); decoder_unlock(dc); player_lock(); continue; } else { /* buffering is complete */ player.buffering = false; } } if (player.decoder_starting) { /* wait until the decoder is initialized completely */ bool success; const struct song *song; success = player_check_decoder_startup(&player); if (!success) break; /* seek to the beginning of the range */ song = decoder_current_song(dc); if (song != NULL && song->start_ms > 0 && !dc_seek(dc, song->start_ms / 1000.0)) player_dc_stop(&player); player_lock(); 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(); if (pc.command == PLAYER_COMMAND_NONE) player_wait(); 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(); } 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(); if (player.queued) { assert(pc.next_song != NULL); pc.next_song = NULL; } pc.state = PLAYER_STATE_STOP; player_unlock(); event_pipe_emit(PIPE_EVENT_PLAYLIST); player_lock(); } static gpointer player_task(G_GNUC_UNUSED gpointer arg) { struct decoder_control dc; dc_init(&dc); decoder_thread_start(&dc); player_buffer = music_buffer_new(pc.buffer_chunks); player_lock(); while (1) { switch (pc.command) { case PLAYER_COMMAND_QUEUE: assert(pc.next_song != NULL); do_play(&dc); break; case PLAYER_COMMAND_STOP: player_unlock(); audio_output_all_cancel(); player_lock(); /* fall through */ case PLAYER_COMMAND_SEEK: case PLAYER_COMMAND_PAUSE: pc.next_song = NULL; player_command_finished_locked(); break; case PLAYER_COMMAND_CLOSE_AUDIO: player_unlock(); audio_output_all_release(); player_lock(); player_command_finished_locked(); #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(); audio_output_all_enable_disable(); player_lock(); player_command_finished_locked(); break; case PLAYER_COMMAND_EXIT: player_unlock(); dc_quit(&dc); dc_deinit(&dc); audio_output_all_close(); music_buffer_free(player_buffer); player_command_finished(); return NULL; case PLAYER_COMMAND_CANCEL: pc.next_song = NULL; player_command_finished_locked(); break; case PLAYER_COMMAND_REFRESH: /* no-op when not playing */ player_command_finished_locked(); break; case PLAYER_COMMAND_NONE: player_wait(); break; } } } void player_create(void) { GError *e = NULL; assert(pc.thread == NULL); pc.thread = g_thread_create(player_task, NULL, true, &e); if (pc.thread == NULL) MPD_ERROR("Failed to spawn player task: %s", e->message); }