From b2789c598e43bbc6df4cb8598b417e87139ec7ba Mon Sep 17 00:00:00 2001 From: Max Kellermann Date: Thu, 26 Sep 2013 22:53:40 +0200 Subject: PlayerThread: use {decoder,player}_control references --- src/PlayerThread.cxx | 428 +++++++++++++++++++++++++-------------------------- 1 file changed, 214 insertions(+), 214 deletions(-) (limited to 'src/PlayerThread.cxx') diff --git a/src/PlayerThread.cxx b/src/PlayerThread.cxx index 0086c797a..20563a091 100644 --- a/src/PlayerThread.cxx +++ b/src/PlayerThread.cxx @@ -50,9 +50,9 @@ enum xfade_state { }; struct player { - struct player_control *pc; + player_control &pc; - struct decoder_control *dc; + decoder_control &dc; MusicBuffer &buffer; @@ -128,7 +128,7 @@ struct player { */ float elapsed_time; - player(player_control *_pc, decoder_control *_dc, + player(player_control &_pc, decoder_control &_dc, MusicBuffer &_buffer) :pc(_pc), dc(_dc), buffer(_buffer), buffering(false), @@ -145,20 +145,20 @@ struct player { }; static void -player_command_finished_locked(struct player_control *pc) +player_command_finished_locked(player_control &pc) { - assert(pc->command != PLAYER_COMMAND_NONE); + assert(pc.command != PLAYER_COMMAND_NONE); - pc->command = PLAYER_COMMAND_NONE; - pc->ClientSignal(); + pc.command = PLAYER_COMMAND_NONE; + pc.ClientSignal(); } static void -player_command_finished(struct player_control *pc) +player_command_finished(player_control &pc) { - pc->Lock(); + pc.Lock(); player_command_finished_locked(pc); - pc->Unlock(); + pc.Unlock(); } /** @@ -169,19 +169,19 @@ player_command_finished(struct player_control *pc) static void player_dc_start(struct player *player, MusicPipe &pipe) { - struct player_control *pc = player->pc; - struct decoder_control *dc = player->dc; + player_control &pc = player->pc; + decoder_control &dc = player->dc; - assert(player->queued || pc->command == PLAYER_COMMAND_SEEK); - assert(pc->next_song != NULL); + assert(player->queued || pc.command == PLAYER_COMMAND_SEEK); + assert(pc.next_song != NULL); - unsigned start_ms = pc->next_song->start_ms; - if (pc->command == PLAYER_COMMAND_SEEK) - start_ms += (unsigned)(pc->seek_where * 1000); + unsigned start_ms = pc.next_song->start_ms; + if (pc.command == PLAYER_COMMAND_SEEK) + start_ms += (unsigned)(pc.seek_where * 1000); - dc->Start(pc->next_song->DupDetached(), - start_ms, pc->next_song->end_ms, - player->buffer, pipe); + dc.Start(pc.next_song->DupDetached(), + start_ms, pc.next_song->end_ms, + player->buffer, pipe); } /** @@ -196,7 +196,7 @@ player_dc_at_current_song(const struct player *player) assert(player != NULL); assert(player->pipe != NULL); - return player->dc->pipe == player->pipe; + return player->dc.pipe == player->pipe; } /** @@ -207,7 +207,7 @@ player_dc_at_current_song(const struct player *player) static bool player_dc_at_next_song(const struct player *player) { - return player->dc->pipe != NULL && !player_dc_at_current_song(player); + return player->dc.pipe != NULL && !player_dc_at_current_song(player); } /** @@ -218,19 +218,19 @@ player_dc_at_next_song(const struct player *player) static void player_dc_stop(struct player *player) { - struct decoder_control *dc = player->dc; + decoder_control &dc = player->dc; - dc->Stop(); + dc.Stop(); - if (dc->pipe != NULL) { + 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) - delete dc->pipe; + if (dc.pipe != player->pipe) + delete dc.pipe; - dc->pipe = NULL; + dc.pipe = NULL; } } @@ -244,23 +244,23 @@ player_dc_stop(struct player *player) static bool player_wait_for_decoder(struct player *player) { - struct player_control *pc = player->pc; - struct decoder_control *dc = player->dc; + player_control &pc = player->pc; + decoder_control &dc = player->dc; - assert(player->queued || pc->command == PLAYER_COMMAND_SEEK); - assert(pc->next_song != NULL); + assert(player->queued || pc.command == PLAYER_COMMAND_SEEK); + assert(pc.next_song != NULL); player->queued = false; - Error error = dc->LockGetError(); + Error error = dc.LockGetError(); if (error.IsDefined()) { - pc->Lock(); - pc->SetError(PLAYER_ERROR_DECODER, std::move(error)); + pc.Lock(); + pc.SetError(PLAYER_ERROR_DECODER, std::move(error)); - pc->next_song->Free(); - pc->next_song = NULL; + pc.next_song->Free(); + pc.next_song = NULL; - pc->Unlock(); + pc.Unlock(); return false; } @@ -268,24 +268,24 @@ player_wait_for_decoder(struct player *player) if (player->song != NULL) player->song->Free(); - player->song = pc->next_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; - pc->Lock(); + pc.Lock(); /* update player_control's song information */ - pc->total_time = pc->next_song->GetDuration(); - pc->bit_rate = 0; - pc->audio_format.Clear(); + pc.total_time = pc.next_song->GetDuration(); + pc.bit_rate = 0; + pc.audio_format.Clear(); /* clear the queued song */ - pc->next_song = NULL; + pc.next_song = NULL; - pc->Unlock(); + pc.Unlock(); /* call syncPlaylistWithQueue() in the main thread */ GlobalEvents::Emit(GlobalEvents::PLAYLIST); @@ -322,11 +322,11 @@ real_song_duration(const Song *song, double decoder_duration) static bool player_open_output(struct player *player) { - struct player_control *pc = player->pc; + player_control &pc = player->pc; assert(player->play_audio_format.IsDefined()); - assert(pc->state == PLAYER_STATE_PLAY || - pc->state == PLAYER_STATE_PAUSE); + assert(pc.state == PLAYER_STATE_PLAY || + pc.state == PLAYER_STATE_PAUSE); Error error; if (audio_output_all_open(player->play_audio_format, player->buffer, @@ -334,9 +334,9 @@ player_open_output(struct player *player) player->output_open = true; player->paused = false; - pc->Lock(); - pc->state = PLAYER_STATE_PLAY; - pc->Unlock(); + pc.Lock(); + pc.state = PLAYER_STATE_PLAY; + pc.Unlock(); idle_add(IDLE_PLAYER); @@ -350,10 +350,10 @@ player_open_output(struct player *player) audio output becomes available */ player->paused = true; - pc->Lock(); - pc->SetError(PLAYER_ERROR_OUTPUT, std::move(error)); - pc->state = PLAYER_STATE_PAUSE; - pc->Unlock(); + pc.Lock(); + pc.SetError(PLAYER_ERROR_OUTPUT, std::move(error)); + pc.state = PLAYER_STATE_PAUSE; + pc.Unlock(); idle_add(IDLE_PLAYER); @@ -371,46 +371,46 @@ player_open_output(struct player *player) static bool player_check_decoder_startup(struct player *player) { - struct player_control *pc = player->pc; - struct decoder_control *dc = player->dc; + player_control &pc = player->pc; + decoder_control &dc = player->dc; assert(player->decoder_starting); - dc->Lock(); + dc.Lock(); - Error error = dc->GetError(); + Error error = dc.GetError(); if (error.IsDefined()) { /* the decoder failed */ - dc->Unlock(); + dc.Unlock(); - pc->Lock(); - pc->SetError(PLAYER_ERROR_DECODER, std::move(error)); - pc->Unlock(); + pc.Lock(); + pc.SetError(PLAYER_ERROR_DECODER, std::move(error)); + pc.Unlock(); return false; - } else if (!dc->IsStarting()) { + } else if (!dc.IsStarting()) { /* the decoder is ready and ok */ - dc->Unlock(); + dc.Unlock(); if (player->output_open && - !audio_output_all_wait(pc, 1)) + !audio_output_all_wait(&pc, 1)) /* the output devices havn't finished playing all chunks yet - wait for that */ return true; - pc->Lock(); - pc->total_time = real_song_duration(dc->song, dc->total_time); - pc->audio_format = dc->in_audio_format; - pc->Unlock(); + pc.Lock(); + pc.total_time = real_song_duration(dc.song, dc.total_time); + pc.audio_format = dc.in_audio_format; + pc.Unlock(); idle_add(IDLE_PLAYER); - player->play_audio_format = dc->out_audio_format; + player->play_audio_format = dc.out_audio_format; player->decoder_starting = false; if (!player->paused && !player_open_output(player)) { - char *uri = dc->song->GetURI(); + char *uri = dc.song->GetURI(); g_warning("problems opening audio device " "while playing \"%s\"", uri); g_free(uri); @@ -422,8 +422,8 @@ player_check_decoder_startup(struct player *player) } else { /* the decoder is not yet ready; wait some more */ - dc->WaitForDecoder(); - dc->Unlock(); + dc.WaitForDecoder(); + dc.Unlock(); return true; } @@ -478,15 +478,15 @@ player_send_silence(struct player *player) */ static bool player_seek_decoder(struct player *player) { - struct player_control *pc = player->pc; - Song *song = pc->next_song; - struct decoder_control *dc = player->dc; + player_control &pc = player->pc; + Song *song = pc.next_song; + decoder_control &dc = player->dc; - assert(pc->next_song != NULL); + assert(pc.next_song != NULL); const unsigned start_ms = song->start_ms; - if (!dc->LockIsCurrentSong(song)) { + if (!dc.LockIsCurrentSong(song)) { /* the decoder is already decoding the "next" song - stop it and start the previous song again */ @@ -509,11 +509,11 @@ static bool player_seek_decoder(struct player *player) but it is the same song file; exchange the pipe */ player->pipe->Clear(player->buffer); delete player->pipe; - player->pipe = dc->pipe; + player->pipe = dc.pipe; } - pc->next_song->Free(); - pc->next_song = NULL; + pc.next_song->Free(); + pc.next_song = NULL; player->queued = false; } @@ -529,13 +529,13 @@ static bool player_seek_decoder(struct player *player) /* send the SEEK command */ - double where = pc->seek_where; - if (where > pc->total_time) - where = pc->total_time - 0.1; + double where = pc.seek_where; + if (where > pc.total_time) + where = pc.total_time - 0.1; if (where < 0.0) where = 0.0; - if (!dc->Seek(where + start_ms / 1000.0)) { + if (!dc.Seek(where + start_ms / 1000.0)) { /* decoder failure */ player_command_finished(pc); return false; @@ -560,10 +560,10 @@ static bool player_seek_decoder(struct player *player) */ static void player_process_command(struct player *player) { - struct player_control *pc = player->pc; - gcc_unused struct decoder_control *dc = player->dc; + player_control &pc = player->pc; + gcc_unused decoder_control &dc = player->dc; - switch (pc->command) { + switch (pc.command) { case PLAYER_COMMAND_NONE: case PLAYER_COMMAND_STOP: case PLAYER_COMMAND_EXIT: @@ -571,14 +571,14 @@ static void player_process_command(struct player *player) break; case PLAYER_COMMAND_UPDATE_AUDIO: - pc->Unlock(); + pc.Unlock(); audio_output_all_enable_disable(); - pc->Lock(); + pc.Lock(); player_command_finished_locked(pc); break; case PLAYER_COMMAND_QUEUE: - assert(pc->next_song != NULL); + assert(pc.next_song != NULL); assert(!player->queued); assert(!player_dc_at_next_song(player)); @@ -587,68 +587,68 @@ static void player_process_command(struct player *player) break; case PLAYER_COMMAND_PAUSE: - pc->Unlock(); + pc.Unlock(); player->paused = !player->paused; if (player->paused) { audio_output_all_pause(); - pc->Lock(); + pc.Lock(); - pc->state = PLAYER_STATE_PAUSE; + pc.state = PLAYER_STATE_PAUSE; } 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(); + pc.Lock(); - pc->state = PLAYER_STATE_PLAY; + pc.state = PLAYER_STATE_PLAY; } else { player_open_output(player); - pc->Lock(); + pc.Lock(); } player_command_finished_locked(pc); break; case PLAYER_COMMAND_SEEK: - pc->Unlock(); + pc.Unlock(); player_seek_decoder(player); - pc->Lock(); + pc.Lock(); break; case PLAYER_COMMAND_CANCEL: - if (pc->next_song == NULL) { + 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; + 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 */ - pc->Unlock(); + pc.Unlock(); player_dc_stop(player); - pc->Lock(); + pc.Lock(); } - pc->next_song->Free(); - pc->next_song = NULL; + pc.next_song->Free(); + pc.next_song = NULL; player->queued = false; player_command_finished_locked(pc); break; case PLAYER_COMMAND_REFRESH: if (player->output_open && !player->paused) { - pc->Unlock(); + pc.Unlock(); audio_output_all_check(); - pc->Lock(); + pc.Lock(); } - pc->elapsed_time = audio_output_all_get_elapsed_time(); - if (pc->elapsed_time < 0.0) - pc->elapsed_time = player->elapsed_time; + 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(pc); break; @@ -685,7 +685,7 @@ update_song_tag(Song *song, const Tag &new_tag) * Player lock is not held. */ static bool -play_chunk(struct player_control *pc, +play_chunk(player_control &pc, Song *song, struct music_chunk *chunk, MusicBuffer &buffer, const AudioFormat format, @@ -701,16 +701,16 @@ play_chunk(struct player_control *pc, return true; } - pc->Lock(); - pc->bit_rate = chunk->bit_rate; - pc->Unlock(); + pc.Lock(); + pc.bit_rate = chunk->bit_rate; + pc.Unlock(); /* send the chunk to the audio outputs */ if (!audio_output_all_play(chunk, error)) return false; - pc->total_play_time += (double)chunk->length / + pc.total_play_time += (double)chunk->length / format.GetTimeToSize(); return true; } @@ -724,10 +724,10 @@ play_chunk(struct player_control *pc, static bool play_next_chunk(struct player *player) { - struct player_control *pc = player->pc; - struct decoder_control *dc = player->dc; + player_control &pc = player->pc; + decoder_control &dc = player->dc; - if (!audio_output_all_wait(pc, 64)) + if (!audio_output_all_wait(&pc, 64)) /* the output pipe is still large enough, don't send another chunk */ return true; @@ -739,7 +739,7 @@ play_next_chunk(struct player *player) (cross_fade_position = player->pipe->GetSize()) <= player->cross_fade_chunks) { /* perform cross fade */ - music_chunk *other_chunk = dc->pipe->Shift(); + music_chunk *other_chunk = dc.pipe->Shift(); if (!player->cross_fading) { /* beginning of the cross fade - adjust @@ -763,7 +763,7 @@ play_next_chunk(struct player *player) other_chunk->tag); other_chunk->tag = NULL; - if (std::isnan(pc->mixramp_delay_seconds)) { + if (std::isnan(pc.mixramp_delay_seconds)) { chunk->mix_ratio = ((float)cross_fade_position) / player->cross_fade_chunks; } else { @@ -786,19 +786,19 @@ play_next_chunk(struct player *player) } else { /* there are not enough decoded chunks yet */ - dc->Lock(); + dc.Lock(); - if (dc->IsIdle()) { + if (dc.IsIdle()) { /* the decoder isn't running, abort cross fading */ - dc->Unlock(); + dc.Unlock(); player->xfade = XFADE_DISABLED; } else { /* wait for the decoder */ - dc->Signal(); - dc->WaitForDecoder(); - dc->Unlock(); + dc.Signal(); + dc.WaitForDecoder(); + dc.Unlock(); return true; } @@ -827,16 +827,16 @@ play_next_chunk(struct player *player) player->buffer.Return(chunk); - pc->Lock(); + pc.Lock(); - pc->SetError(PLAYER_ERROR_OUTPUT, std::move(error)); + pc.SetError(PLAYER_ERROR_OUTPUT, std::move(error)); /* pause: the user may resume playback as soon as an audio output becomes available */ - pc->state = PLAYER_STATE_PAUSE; + pc.state = PLAYER_STATE_PAUSE; player->paused = true; - pc->Unlock(); + pc.Unlock(); idle_add(IDLE_PLAYER); @@ -846,12 +846,12 @@ play_next_chunk(struct player *player) /* 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 */ - dc->Lock(); - if (!dc->IsIdle() && - dc->pipe->GetSize() <= (pc->buffered_before_play + + dc.Lock(); + if (!dc.IsIdle() && + dc.pipe->GetSize() <= (pc.buffered_before_play + player->buffer.GetSize() * 3) / 4) - dc->Signal(); - dc->Unlock(); + dc.Signal(); + dc.Unlock(); return true; } @@ -875,23 +875,23 @@ player_song_border(struct player *player) g_free(uri); delete player->pipe; - player->pipe = player->dc->pipe; + player->pipe = player->dc.pipe; audio_output_all_song_border(); if (!player_wait_for_decoder(player)) return false; - struct player_control *const pc = player->pc; - pc->Lock(); + player_control &pc = player->pc; + pc.Lock(); - const bool border_pause = pc->border_pause; + const bool border_pause = pc.border_pause; if (border_pause) { player->paused = true; - pc->state = PLAYER_STATE_PAUSE; + pc.state = PLAYER_STATE_PAUSE; } - pc->Unlock(); + pc.Unlock(); if (border_pause) idle_add(IDLE_PLAYER); @@ -905,12 +905,12 @@ player_song_border(struct player *player) * decoder thread and the output threads. */ static void -do_play(struct player_control *pc, struct decoder_control *dc, +do_play(player_control &pc, decoder_control &dc, MusicBuffer &buffer) { player player(pc, dc, buffer); - pc->Unlock(); + pc.Unlock(); player.pipe = new MusicPipe(); @@ -922,37 +922,37 @@ do_play(struct player_control *pc, struct decoder_control *dc, player_command_finished(pc); delete player.pipe; GlobalEvents::Emit(GlobalEvents::PLAYLIST); - pc->Lock(); + pc.Lock(); return; } - pc->Lock(); - pc->state = PLAYER_STATE_PLAY; + pc.Lock(); + pc.state = PLAYER_STATE_PLAY; - if (pc->command == PLAYER_COMMAND_SEEK) - player.elapsed_time = pc->seek_where; + if (pc.command == PLAYER_COMMAND_SEEK) + player.elapsed_time = pc.seek_where; 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) { - pc->Unlock(); + if (pc.command == PLAYER_COMMAND_STOP || + pc.command == PLAYER_COMMAND_EXIT || + pc.command == PLAYER_COMMAND_CLOSE_AUDIO) { + pc.Unlock(); audio_output_all_cancel(); break; } - pc->Unlock(); + pc.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 (player.pipe->GetSize() < pc->buffered_before_play && - !dc->LockIsIdle()) { + if (player.pipe->GetSize() < pc.buffered_before_play && + !dc.LockIsIdle()) { /* not enough decoded buffer space yet */ if (!player.paused && @@ -961,11 +961,11 @@ do_play(struct player_control *pc, struct decoder_control *dc, !player_send_silence(&player)) break; - dc->Lock(); + dc.Lock(); /* XXX race condition: check decoder again */ - dc->WaitForDecoder(); - dc->Unlock(); - pc->Lock(); + dc.WaitForDecoder(); + dc.Unlock(); + pc.Lock(); continue; } else { /* buffering is complete */ @@ -979,7 +979,7 @@ do_play(struct player_control *pc, struct decoder_control *dc, if (!player_check_decoder_startup(&player)) break; - pc->Lock(); + pc.Lock(); continue; } @@ -987,41 +987,41 @@ do_play(struct player_control *pc, struct decoder_control *dc, /* music_pipe_check_format(&play_audio_format, player.next_song_chunk, - &dc->out_audio_format); + &dc.out_audio_format); */ #endif - if (dc->LockIsIdle() && player.queued && - dc->pipe == player.pipe) { + if (dc.LockIsIdle() && 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); + assert(dc.pipe == NULL || dc.pipe == player.pipe); 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 && + !pc.border_pause && player_dc_at_next_song(&player) && player.xfade == XFADE_UNKNOWN && - !dc->LockIsStarting()) { + !dc.LockIsStarting()) { /* 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, + 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, player.buffer.GetSize() - - pc->buffered_before_play); + pc.buffered_before_play); if (player.cross_fade_chunks > 0) { player.xfade = XFADE_ENABLED; player.cross_fading = false; @@ -1032,10 +1032,10 @@ do_play(struct player_control *pc, struct decoder_control *dc, } if (player.paused) { - pc->Lock(); + pc.Lock(); - if (pc->command == PLAYER_COMMAND_NONE) - pc->Wait(); + if (pc.command == PLAYER_COMMAND_NONE) + pc.Wait(); continue; } else if (!player.pipe->IsEmpty()) { /* at least one music chunk is ready - send it @@ -1054,7 +1054,7 @@ do_play(struct player_control *pc, struct decoder_control *dc, if (!player_song_border(&player)) break; - } else if (dc->LockIsIdle()) { + } else if (dc.LockIsIdle()) { /* check the size of the pipe again, because the decoder thread may have added something since we last checked */ @@ -1072,7 +1072,7 @@ do_play(struct player_control *pc, struct decoder_control *dc, break; } - pc->Lock(); + pc.Lock(); } player_dc_stop(&player); @@ -1085,66 +1085,66 @@ do_play(struct player_control *pc, struct decoder_control *dc, if (player.song != NULL) player.song->Free(); - pc->Lock(); + pc.Lock(); if (player.queued) { - assert(pc->next_song != NULL); - pc->next_song->Free(); - pc->next_song = NULL; + assert(pc.next_song != NULL); + pc.next_song->Free(); + pc.next_song = NULL; } - pc->state = PLAYER_STATE_STOP; + pc.state = PLAYER_STATE_STOP; - pc->Unlock(); + pc.Unlock(); GlobalEvents::Emit(GlobalEvents::PLAYLIST); - pc->Lock(); + pc.Lock(); } static gpointer player_task(gpointer arg) { - struct player_control *pc = (struct player_control *)arg; + player_control &pc = *(player_control *)arg; decoder_control dc; decoder_thread_start(&dc); - MusicBuffer buffer(pc->buffer_chunks); + MusicBuffer buffer(pc.buffer_chunks); - pc->Lock(); + pc.Lock(); while (1) { - switch (pc->command) { + switch (pc.command) { case PLAYER_COMMAND_SEEK: case PLAYER_COMMAND_QUEUE: - assert(pc->next_song != NULL); + assert(pc.next_song != NULL); - do_play(pc, &dc, buffer); + do_play(pc, dc, buffer); break; case PLAYER_COMMAND_STOP: - pc->Unlock(); + pc.Unlock(); audio_output_all_cancel(); - pc->Lock(); + pc.Lock(); /* fall through */ case PLAYER_COMMAND_PAUSE: - if (pc->next_song != NULL) { - pc->next_song->Free(); - pc->next_song = NULL; + if (pc.next_song != NULL) { + pc.next_song->Free(); + pc.next_song = NULL; } player_command_finished_locked(pc); break; case PLAYER_COMMAND_CLOSE_AUDIO: - pc->Unlock(); + pc.Unlock(); audio_output_all_release(); - pc->Lock(); + pc.Lock(); player_command_finished_locked(pc); assert(buffer.IsEmptyUnsafe()); @@ -1152,14 +1152,14 @@ player_task(gpointer arg) break; case PLAYER_COMMAND_UPDATE_AUDIO: - pc->Unlock(); + pc.Unlock(); audio_output_all_enable_disable(); - pc->Lock(); + pc.Lock(); player_command_finished_locked(pc); break; case PLAYER_COMMAND_EXIT: - pc->Unlock(); + pc.Unlock(); dc.Quit(); @@ -1169,9 +1169,9 @@ player_task(gpointer arg) return NULL; case PLAYER_COMMAND_CANCEL: - if (pc->next_song != NULL) { - pc->next_song->Free(); - pc->next_song = NULL; + if (pc.next_song != NULL) { + pc.next_song->Free(); + pc.next_song = NULL; } player_command_finished_locked(pc); @@ -1183,23 +1183,23 @@ player_task(gpointer arg) break; case PLAYER_COMMAND_NONE: - pc->Wait(); + pc.Wait(); break; } } } void -player_create(struct player_control *pc) +player_create(player_control &pc) { - assert(pc->thread == NULL); + assert(pc.thread == NULL); #if GLIB_CHECK_VERSION(2,32,0) - pc->thread = g_thread_new("player", player_task, pc); + pc.thread = g_thread_new("player", player_task, &pc); #else GError *e = NULL; - pc->thread = g_thread_create(player_task, pc, true, &e); - if (pc->thread == NULL) + pc.thread = g_thread_create(player_task, &pc, true, &e); + if (pc.thread == NULL) FatalError("Failed to spawn player task", e); #endif } -- cgit v1.2.3