Skip to content

M
mpd
Commit 079ef931 authored by Max Kellermann's avatar Max Kellermann
Browse files
Options

PlayerThread: use player references

parent b2789c59
Hide whitespace changes
Inline Side-by-side
Showing with 115 additions and 116 deletions
src/PlayerThread.cxx
View file @ 079ef931
......@@ -167,12 +167,12 @@ player_command_finished(player_control &pc)
* Player lock is not held.
*/
static void
player_dc_start(struct player *player, MusicPipe &pipe)
player_dc_start(player &player, MusicPipe &pipe)
{
player_control &pc = player->pc;
decoder_control &dc = player->dc;
player_control &pc = player.pc;
decoder_control &dc = player.dc;
assert(player->queued || pc.command == PLAYER_COMMAND_SEEK);
assert(player.queued || pc.command == PLAYER_COMMAND_SEEK);
assert(pc.next_song != NULL);
unsigned start_ms = pc.next_song->start_ms;
......@@ -181,7 +181,7 @@ player_dc_start(struct player *player, MusicPipe &pipe)
dc.Start(pc.next_song->DupDetached(),
start_ms, pc.next_song->end_ms,
player->buffer, pipe);
player.buffer, pipe);
}
/**
......@@ -191,12 +191,11 @@ player_dc_start(struct player *player, MusicPipe &pipe)
* finished.
*/
static bool
player_dc_at_current_song(const struct player *player)
player_dc_at_current_song(const player &player)
{
assert(player != NULL);
assert(player->pipe != NULL);
assert(player.pipe != NULL);
return player->dc.pipe == player->pipe;
return player.dc.pipe == player.pipe;
}
/**
......@@ -205,9 +204,9 @@ player_dc_at_current_song(const struct player *player)
* switched to that song yet.
*/
static bool
player_dc_at_next_song(const struct player *player)
player_dc_at_next_song(const player &player)
{
return player->dc.pipe != NULL && !player_dc_at_current_song(player);
return player.dc.pipe != NULL && !player_dc_at_current_song(player);
}
/**
......@@ -216,18 +215,18 @@ player_dc_at_next_song(const struct player *player)
* Player lock is not held.
*/
static void
player_dc_stop(struct player *player)
player_dc_stop(player &player)
{
decoder_control &dc = player->dc;
decoder_control &dc = player.dc;
dc.Stop();
if (dc.pipe != NULL) {
/* clear and free the decoder pipe */
dc.pipe->Clear(player->buffer);
dc.pipe->Clear(player.buffer);
if (dc.pipe != player->pipe)
if (dc.pipe != player.pipe)
delete dc.pipe;
dc.pipe = NULL;
......@@ -242,15 +241,15 @@ player_dc_stop(struct player *player)
* The player lock is not held.
*/
static bool
player_wait_for_decoder(struct player *player)
player_wait_for_decoder(player &player)
{
player_control &pc = player->pc;
decoder_control &dc = player->dc;
player_control &pc = player.pc;
decoder_control &dc = player.dc;
assert(player->queued || pc.command == PLAYER_COMMAND_SEEK);
assert(player.queued || pc.command == PLAYER_COMMAND_SEEK);
assert(pc.next_song != NULL);
player->queued = false;
player.queued = false;
Error error = dc.LockGetError();
if (error.IsDefined()) {
......@@ -265,15 +264,15 @@ player_wait_for_decoder(struct player *player)
return false;
}
if (player->song != NULL)
player->song->Free();
if (player.song != NULL)
player.song->Free();
player->song = pc.next_song;
player->elapsed_time = 0.0;
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.decoder_starting = true;
pc.Lock();
......@@ -320,19 +319,19 @@ real_song_duration(const Song *song, double decoder_duration)
* @return true on success
*/
static bool
player_open_output(struct player *player)
player_open_output(player &player)
{
player_control &pc = player->pc;
player_control &pc = player.pc;
assert(player->play_audio_format.IsDefined());
assert(player.play_audio_format.IsDefined());
assert(pc.state == PLAYER_STATE_PLAY ||
pc.state == PLAYER_STATE_PAUSE);
Error error;
if (audio_output_all_open(player->play_audio_format, player->buffer,
if (audio_output_all_open(player.play_audio_format, player.buffer,
error)) {
player->output_open = true;
player->paused = false;
player.output_open = true;
player.paused = false;
pc.Lock();
pc.state = PLAYER_STATE_PLAY;
......@@ -344,11 +343,11 @@ player_open_output(struct player *player)
} else {
g_warning("%s", error.GetMessage());
player->output_open = false;
player.output_open = false;
/* pause: the user may resume playback as soon as an
audio output becomes available */
player->paused = true;
player.paused = true;
pc.Lock();
pc.SetError(PLAYER_ERROR_OUTPUT, std::move(error));
......@@ -369,12 +368,12 @@ player_open_output(struct player *player)
* The player lock is not held.
*/
static bool
player_check_decoder_startup(struct player *player)
player_check_decoder_startup(player &player)
{
player_control &pc = player->pc;
decoder_control &dc = player->dc;
player_control &pc = player.pc;
decoder_control &dc = player.dc;
assert(player->decoder_starting);
assert(player.decoder_starting);
dc.Lock();
......@@ -393,7 +392,7 @@ player_check_decoder_startup(struct player *player)
dc.Unlock();
if (player->output_open &&
if (player.output_open &&
!audio_output_all_wait(&pc, 1))
/* the output devices havn't finished playing
all chunks yet - wait for that */
......@@ -406,10 +405,10 @@ player_check_decoder_startup(struct player *player)
idle_add(IDLE_PLAYER);
player->play_audio_format = dc.out_audio_format;
player->decoder_starting = false;
player.play_audio_format = dc.out_audio_format;
player.decoder_starting = false;
if (!player->paused && !player_open_output(player)) {
if (!player.paused && !player_open_output(player)) {
char *uri = dc.song->GetURI();
g_warning("problems opening audio device "
"while playing \"%s\"", uri);
......@@ -437,22 +436,22 @@ player_check_decoder_startup(struct player *player)
* The player lock is not held.
*/
static bool
player_send_silence(struct player *player)
player_send_silence(player &player)
{
assert(player->output_open);
assert(player->play_audio_format.IsDefined());
assert(player.output_open);
assert(player.play_audio_format.IsDefined());
struct music_chunk *chunk = player->buffer.Allocate();
struct music_chunk *chunk = player.buffer.Allocate();
if (chunk == NULL) {
g_warning("Failed to allocate silence buffer");
return false;
}
#ifndef NDEBUG
chunk->audio_format = player->play_audio_format;
chunk->audio_format = player.play_audio_format;
#endif
const size_t frame_size = player->play_audio_format.GetFrameSize();
const size_t frame_size = player.play_audio_format.GetFrameSize();
/* this formula ensures that we don't send
partial frames */
unsigned num_frames = sizeof(chunk->data) / frame_size;
......@@ -464,7 +463,7 @@ player_send_silence(struct player *player)
Error error;
if (!audio_output_all_play(chunk, error)) {
g_warning("%s", error.GetMessage());
player->buffer.Return(chunk);
player.buffer.Return(chunk);
return false;
}
......@@ -476,11 +475,11 @@ player_send_silence(struct player *player)
*
* The player lock is not held.
*/
static bool player_seek_decoder(struct player *player)
static bool player_seek_decoder(player &player)
{
player_control &pc = player->pc;
player_control &pc = player.pc;
Song *song = pc.next_song;
decoder_control &dc = player->dc;
decoder_control &dc = player.dc;
assert(pc.next_song != NULL);
......@@ -494,10 +493,10 @@ static bool player_seek_decoder(struct player *player)
/* clear music chunks which might still reside in the
pipe */
player->pipe->Clear(player->buffer);
player.pipe->Clear(player.buffer);
/* re-start the decoder */
player_dc_start(player, *player->pipe);
player_dc_start(player, *player.pipe);
if (!player_wait_for_decoder(player)) {
/* decoder failure */
player_command_finished(pc);
......@@ -507,19 +506,19 @@ static bool player_seek_decoder(struct player *player)
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 */
player->pipe->Clear(player->buffer);
delete player->pipe;
player->pipe = dc.pipe;
player.pipe->Clear(player.buffer);
delete player.pipe;
player.pipe = dc.pipe;
}
pc.next_song->Free();
pc.next_song = NULL;
player->queued = false;
player.queued = false;
}
/* wait for the decoder to complete initialization */
while (player->decoder_starting) {
while (player.decoder_starting) {
if (!player_check_decoder_startup(player)) {
/* decoder failure */
player_command_finished(pc);
......@@ -541,14 +540,14 @@ static bool player_seek_decoder(struct player *player)
return false;
}
player->elapsed_time = where;
player.elapsed_time = where;
player_command_finished(pc);
player->xfade = XFADE_UNKNOWN;
player.xfade = XFADE_UNKNOWN;
/* re-fill the buffer after seeking */
player->buffering = true;
player.buffering = true;
audio_output_all_cancel();
......@@ -558,10 +557,10 @@ static bool player_seek_decoder(struct player *player)
/**
* Player lock must be held before calling.
*/
static void player_process_command(struct player *player)
static void player_process_command(player &player)
{
player_control &pc = player->pc;
gcc_unused decoder_control &dc = player->dc;
player_control &pc = player.pc;
gcc_unused decoder_control &dc = player.dc;
switch (pc.command) {
case PLAYER_COMMAND_NONE:
......@@ -579,23 +578,23 @@ static void player_process_command(struct player *player)
case PLAYER_COMMAND_QUEUE:
assert(pc.next_song != NULL);
assert(!player->queued);
assert(!player.queued);
assert(!player_dc_at_next_song(player));
player->queued = true;
player.queued = true;
player_command_finished_locked(pc);
break;
case PLAYER_COMMAND_PAUSE:
pc.Unlock();
player->paused = !player->paused;
if (player->paused) {
player.paused = !player.paused;
if (player.paused) {
audio_output_all_pause();
pc.Lock();
pc.state = PLAYER_STATE_PAUSE;
} else if (!player->play_audio_format.IsDefined()) {
} else if (!player.play_audio_format.IsDefined()) {
/* the decoder hasn't provided an audio format
yet - don't open the audio device yet */
pc.Lock();
......@@ -635,12 +634,12 @@ static void player_process_command(struct player *player)
pc.next_song->Free();
pc.next_song = NULL;
player->queued = false;
player.queued = false;
player_command_finished_locked(pc);
break;
case PLAYER_COMMAND_REFRESH:
if (player->output_open && !player->paused) {
if (player.output_open && !player.paused) {
pc.Unlock();
audio_output_all_check();
pc.Lock();
......@@ -648,7 +647,7 @@ static void player_process_command(struct player *player)
pc.elapsed_time = audio_output_all_get_elapsed_time();
if (pc.elapsed_time < 0.0)
pc.elapsed_time = player->elapsed_time;
pc.elapsed_time = player.elapsed_time;
player_command_finished_locked(pc);
break;
......@@ -722,10 +721,10 @@ play_chunk(player_control &pc,
* @return true on success, false on error (playback will be stopped)
*/
static bool
play_next_chunk(struct player *player)
play_next_chunk(player &player)
{
player_control &pc = player->pc;
decoder_control &dc = player->dc;
player_control &pc = player.pc;
decoder_control &dc = player.dc;
if (!audio_output_all_wait(&pc, 64))
/* the output pipe is still large enough, don't send
......@@ -734,38 +733,38 @@ play_next_chunk(struct player *player)
unsigned cross_fade_position;
struct music_chunk *chunk = NULL;
if (player->xfade == XFADE_ENABLED &&
if (player.xfade == XFADE_ENABLED &&
player_dc_at_next_song(player) &&
(cross_fade_position = player->pipe->GetSize())
<= player->cross_fade_chunks) {
(cross_fade_position = player.pipe->GetSize())
<= player.cross_fade_chunks) {
/* perform cross fade */
music_chunk *other_chunk = dc.pipe->Shift();
if (!player->cross_fading) {
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;
player.cross_fade_chunks = cross_fade_position;
player.cross_fading = true;
}
if (other_chunk != NULL) {
chunk = player->pipe->Shift();
chunk = player.pipe->Shift();
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::MergeReplace(player->cross_fade_tag,
player.cross_fade_tag =
Tag::MergeReplace(player.cross_fade_tag,
other_chunk->tag);
other_chunk->tag = NULL;
if (std::isnan(pc.mixramp_delay_seconds)) {
chunk->mix_ratio = ((float)cross_fade_position)
/ player->cross_fade_chunks;
/ player.cross_fade_chunks;
} else {
chunk->mix_ratio = nan("");
}
......@@ -778,7 +777,7 @@ play_next_chunk(struct player *player)
beginning of the new song, we can
easily recover by throwing it away
now */
player->buffer.Return(other_chunk);
player.buffer.Return(other_chunk);
other_chunk = NULL;
}
......@@ -793,7 +792,7 @@ play_next_chunk(struct player *player)
cross fading */
dc.Unlock();
player->xfade = XFADE_DISABLED;
player.xfade = XFADE_DISABLED;
} else {
/* wait for the decoder */
dc.Signal();
......@@ -806,26 +805,26 @@ play_next_chunk(struct player *player)
}
if (chunk == NULL)
chunk = player->pipe->Shift();
chunk = player.pipe->Shift();
assert(chunk != NULL);
/* insert the postponed tag if cross-fading is finished */
if (player->xfade != XFADE_ENABLED && player->cross_fade_tag != NULL) {
if (player.xfade != XFADE_ENABLED && player.cross_fade_tag != NULL) {
chunk->tag = Tag::MergeReplace(chunk->tag,
player->cross_fade_tag);
player->cross_fade_tag = NULL;
player.cross_fade_tag);
player.cross_fade_tag = NULL;
}
/* play the current chunk */
Error error;
if (!play_chunk(player->pc, player->song, chunk, player->buffer,
player->play_audio_format, error)) {
if (!play_chunk(player.pc, player.song, chunk, player.buffer,
player.play_audio_format, error)) {
g_warning("%s", error.GetMessage());
player->buffer.Return(chunk);
player.buffer.Return(chunk);
pc.Lock();
......@@ -834,7 +833,7 @@ play_next_chunk(struct player *player)
/* pause: the user may resume playback as soon as an
audio output becomes available */
pc.state = PLAYER_STATE_PAUSE;
player->paused = true;
player.paused = true;
pc.Unlock();
......@@ -849,7 +848,7 @@ play_next_chunk(struct player *player)
dc.Lock();
if (!dc.IsIdle() &&
dc.pipe->GetSize() <= (pc.buffered_before_play +
player->buffer.GetSize() * 3) / 4)
player.buffer.GetSize() * 3) / 4)
dc.Signal();
dc.Unlock();
......@@ -866,28 +865,28 @@ play_next_chunk(struct player *player)
* @return true on success, false on error (playback will be stopped)
*/
static bool
player_song_border(struct player *player)
player_song_border(player &player)
{
player->xfade = XFADE_UNKNOWN;
player.xfade = XFADE_UNKNOWN;
char *uri = player->song->GetURI();
char *uri = player.song->GetURI();
g_message("played \"%s\"", uri);
g_free(uri);
delete player->pipe;
player->pipe = player->dc.pipe;
delete player.pipe;
player.pipe = player.dc.pipe;
audio_output_all_song_border();
if (!player_wait_for_decoder(player))
return false;
player_control &pc = player->pc;
player_control &pc = player.pc;
pc.Lock();
const bool border_pause = pc.border_pause;
if (border_pause) {
player->paused = true;
player.paused = true;
pc.state = PLAYER_STATE_PAUSE;
}
......@@ -914,11 +913,11 @@ do_play(player_control &pc, decoder_control &dc,
player.pipe = new MusicPipe();
player_dc_start(&player, *player.pipe);
if (!player_wait_for_decoder(&player)) {
player_dc_start(player, *player.pipe);
if (!player_wait_for_decoder(player)) {
assert(player.song == NULL);
player_dc_stop(&player);
player_dc_stop(player);
player_command_finished(pc);
delete player.pipe;
GlobalEvents::Emit(GlobalEvents::PLAYLIST);
......@@ -935,7 +934,7 @@ do_play(player_control &pc, decoder_control &dc,
player_command_finished_locked(pc);
while (true) {
player_process_command(&player);
player_process_command(player);
if (pc.command == PLAYER_COMMAND_STOP ||
pc.command == PLAYER_COMMAND_EXIT ||
pc.command == PLAYER_COMMAND_CLOSE_AUDIO) {
......@@ -958,7 +957,7 @@ do_play(player_control &pc, decoder_control &dc,
if (!player.paused &&
player.output_open &&
audio_output_all_check() < 4 &&
!player_send_silence(&player))
!player_send_silence(player))
break;
dc.Lock();
......@@ -976,7 +975,7 @@ do_play(player_control &pc, decoder_control &dc,
if (player.decoder_starting) {
/* wait until the decoder is initialized completely */
if (!player_check_decoder_startup(&player))
if (!player_check_decoder_startup(player))
break;
pc.Lock();
......@@ -998,13 +997,13 @@ do_play(player_control &pc, decoder_control &dc,
assert(dc.pipe == NULL || dc.pipe == player.pipe);
player_dc_start(&player, *new MusicPipe());
player_dc_start(player, *new MusicPipe());
}
if (/* no cross-fading if MPD is going to pause at the
end of the current song */
!pc.border_pause &&
player_dc_at_next_song(&player) &&
player_dc_at_next_song(player) &&
player.xfade == XFADE_UNKNOWN &&
!dc.LockIsStarting()) {
/* enable cross fading in this song? if yes,
......@@ -1041,7 +1040,7 @@ do_play(player_control &pc, decoder_control &dc,
/* at least one music chunk is ready - send it
to the audio output */
play_next_chunk(&player);
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
......@@ -1049,10 +1048,10 @@ do_play(player_control &pc, decoder_control &dc,
/* XXX synchronize in a better way */
g_usleep(10000);
} else if (player_dc_at_next_song(&player)) {
} else if (player_dc_at_next_song(player)) {
/* at the beginning of a new song */
if (!player_song_border(&player))
if (!player_song_border(player))
break;
} else if (dc.LockIsIdle()) {
/* check the size of the pipe again, because
......@@ -1068,14 +1067,14 @@ do_play(player_control &pc, decoder_control &dc,
/* 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))
if (!player_send_silence(player))
break;
}
pc.Lock();
}
player_dc_stop(&player);
player_dc_stop(player);
player.pipe->Clear(player.buffer);
delete player.pipe;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment