PlayerThread: use player references
This commit is contained in:
Max Kellermann
parent
b2789c598e
commit
079ef93121
@ -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;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user