oysteikt/mpd
0
0
Fork 0
Code Issues Pull Requests Releases Activity

PlayerThread: move code into the player class

Browse Source
This commit is contained in:
Max Kellermann
2013-09-26 23:57:31 +02:00
parent 079ef93121
commit bcb2db62c9
1 changed files with 277 additions and 269 deletions
Download Patch File Download Diff File Expand all files Collapse all files

546
src/PlayerThread.cxx
View File

@@ -142,6 +142,132 @@ struct player {
cross_fade_chunks(0),
cross_fade_tag(NULL),
elapsed_time(0.0) {}
void ClearAndDeletePipe() {
pipe->Clear(buffer);
delete pipe;
}
void ClearAndReplacePipe(MusicPipe *_pipe) {
ClearAndDeletePipe();
pipe = _pipe;
}
void ReplacePipe(MusicPipe *_pipe) {
delete pipe;
pipe = _pipe;
}
/**
* Start the decoder.
*
* Player lock is not held.
*/
void StartDecoder(MusicPipe &pipe);
/**
* The decoder has acknowledged the "START" command (see
* player::WaitForDecoder()). This function checks if the decoder
* initialization has completed yet.
*
* The player lock is not held.
*/
bool CheckDecoderStartup();
/**
* Stop the decoder and clears (and frees) its music pipe.
*
* Player lock is not held.
*/
void StopDecoder();
/**
* Is the decoder still busy on the same song as the player?
*
* Note: this function does not check if the decoder is already
* finished.
*/
gcc_pure
bool IsDecoderAtCurrentSong() const {
assert(pipe != nullptr);
return dc.pipe == 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.
*/
gcc_pure
bool IsDecoderAtNextSong() const {
return dc.pipe != nullptr && !IsDecoderAtCurrentSong();
}
/**
* This is the handler for the #PLAYER_COMMAND_SEEK command.
*
* The player lock is not held.
*/
bool SeekDecoder();
/**
* 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.
*/
bool WaitForDecoder();
/**
* Wrapper for audio_output_all_open(). Upon failure, it pauses the
* player.
*
* @return true on success
*/
bool OpenOutput();
/**
* 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)
*/
bool PlayNextChunk();
/**
* 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.
*/
bool SendSilence();
/**
* Player lock must be held before calling.
*/
void ProcessCommand();
/**
* 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)
*/
bool SongBorder();
/*
* 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.
*/
void Run();
};
static void
@@ -161,18 +287,10 @@ player_command_finished(player_control &pc)
pc.Unlock();
}
/**
* Start the decoder.
*
* Player lock is not held.
*/
static void
player_dc_start(player &player, MusicPipe &pipe)
void
player::StartDecoder(MusicPipe &_pipe)
{
player_control &pc = player.pc;
decoder_control &dc = player.dc;
assert(player.queued || pc.command == PLAYER_COMMAND_SEEK);
assert(queued || pc.command == PLAYER_COMMAND_SEEK);
assert(pc.next_song != NULL);
unsigned start_ms = pc.next_song->start_ms;
@@ -181,75 +299,33 @@ player_dc_start(player &player, MusicPipe &pipe)
dc.Start(pc.next_song->DupDetached(),
start_ms, pc.next_song->end_ms,
player.buffer, pipe);
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 player &player)
void
player::StopDecoder()
{
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 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(player &player)
{
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(buffer);
if (dc.pipe != player.pipe)
if (dc.pipe != pipe)
delete 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(player &player)
bool
player::WaitForDecoder()
{
player_control &pc = player.pc;
decoder_control &dc = player.dc;
assert(player.queued || pc.command == PLAYER_COMMAND_SEEK);
assert(queued || pc.command == PLAYER_COMMAND_SEEK);
assert(pc.next_song != NULL);
player.queued = false;
queued = false;
Error error = dc.LockGetError();
if (error.IsDefined()) {
@@ -264,15 +340,15 @@ player_wait_for_decoder(player &player)
return false;
}
if (player.song != NULL)
player.song->Free();
if (song != nullptr)
song->Free();
player.song = pc.next_song;
player.elapsed_time = 0.0;
song = pc.next_song;
elapsed_time = 0.0;
/* set the "starting" flag, which will be cleared by
player_check_decoder_startup() */
player.decoder_starting = true;
decoder_starting = true;
pc.Lock();
@@ -312,26 +388,17 @@ real_song_duration(const Song *song, double decoder_duration)
return decoder_duration - song->start_ms / 1000.0;
}
/**
* Wrapper for audio_output_all_open(). Upon failure, it pauses the
* player.
*
* @return true on success
*/
static bool
player_open_output(player &player)
bool
player::OpenOutput()
{
player_control &pc = player.pc;
assert(player.play_audio_format.IsDefined());
assert(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,
error)) {
player.output_open = true;
player.paused = false;
if (audio_output_all_open(play_audio_format, buffer, error)) {
output_open = true;
paused = false;
pc.Lock();
pc.state = PLAYER_STATE_PLAY;
@@ -343,11 +410,11 @@ player_open_output(player &player)
} else {
g_warning("%s", error.GetMessage());
player.output_open = false;
output_open = false;
/* pause: the user may resume playback as soon as an
audio output becomes available */
player.paused = true;
paused = true;
pc.Lock();
pc.SetError(PLAYER_ERROR_OUTPUT, std::move(error));
@@ -360,20 +427,10 @@ player_open_output(player &player)
}
}
/**
* 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(player &player)
bool
player::CheckDecoderStartup()
{
player_control &pc = player.pc;
decoder_control &dc = player.dc;
assert(player.decoder_starting);
assert(decoder_starting);
dc.Lock();
@@ -392,7 +449,7 @@ player_check_decoder_startup(player &player)
dc.Unlock();
if (player.output_open &&
if (output_open &&
!audio_output_all_wait(&pc, 1))
/* the output devices havn't finished playing
all chunks yet - wait for that */
@@ -405,10 +462,10 @@ player_check_decoder_startup(player &player)
idle_add(IDLE_PLAYER);
player.play_audio_format = dc.out_audio_format;
player.decoder_starting = false;
play_audio_format = dc.out_audio_format;
decoder_starting = false;
if (!player.paused && !player_open_output(player)) {
if (!paused && !OpenOutput()) {
char *uri = dc.song->GetURI();
g_warning("problems opening audio device "
"while playing \"%s\"", uri);
@@ -428,30 +485,23 @@ player_check_decoder_startup(player &player)
}
}
/**
* 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(player &player)
bool
player::SendSilence()
{
assert(player.output_open);
assert(player.play_audio_format.IsDefined());
assert(output_open);
assert(play_audio_format.IsDefined());
struct music_chunk *chunk = player.buffer.Allocate();
struct music_chunk *chunk = 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 = play_audio_format;
#endif
const size_t frame_size = player.play_audio_format.GetFrameSize();
const size_t frame_size = play_audio_format.GetFrameSize();
/* this formula ensures that we don't send
partial frames */
unsigned num_frames = sizeof(chunk->data) / frame_size;
@@ -463,63 +513,53 @@ player_send_silence(player &player)
Error error;
if (!audio_output_all_play(chunk, error)) {
g_warning("%s", error.GetMessage());
player.buffer.Return(chunk);
buffer.Return(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(player &player)
inline bool
player::SeekDecoder()
{
player_control &pc = player.pc;
Song *song = pc.next_song;
decoder_control &dc = player.dc;
assert(pc.next_song != NULL);
const unsigned start_ms = song->start_ms;
const unsigned start_ms = pc.next_song->start_ms;
if (!dc.LockIsCurrentSong(song)) {
if (!dc.LockIsCurrentSong(pc.next_song)) {
/* the decoder is already decoding the "next" song -
stop it and start the previous song again */
player_dc_stop(player);
StopDecoder();
/* clear music chunks which might still reside in the
pipe */
player.pipe->Clear(player.buffer);
pipe->Clear(buffer);
/* re-start the decoder */
player_dc_start(player, *player.pipe);
if (!player_wait_for_decoder(player)) {
StartDecoder(*pipe);
if (!WaitForDecoder()) {
/* decoder failure */
player_command_finished(pc);
return false;
}
} else {
if (!player_dc_at_current_song(player)) {
if (!IsDecoderAtCurrentSong()) {
/* 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;
ClearAndReplacePipe(dc.pipe);
}
pc.next_song->Free();
pc.next_song = NULL;
player.queued = false;
queued = false;
}
/* wait for the decoder to complete initialization */
while (player.decoder_starting) {
if (!player_check_decoder_startup(player)) {
while (decoder_starting) {
if (!CheckDecoderStartup()) {
/* decoder failure */
player_command_finished(pc);
return false;
@@ -540,28 +580,23 @@ static bool player_seek_decoder(player &player)
return false;
}
player.elapsed_time = where;
elapsed_time = where;
player_command_finished(pc);
player.xfade = XFADE_UNKNOWN;
xfade = XFADE_UNKNOWN;
/* re-fill the buffer after seeking */
player.buffering = true;
buffering = true;
audio_output_all_cancel();
return true;
}
/**
* Player lock must be held before calling.
*/
static void player_process_command(player &player)
inline void
player::ProcessCommand()
{
player_control &pc = player.pc;
gcc_unused decoder_control &dc = player.dc;
switch (pc.command) {
case PLAYER_COMMAND_NONE:
case PLAYER_COMMAND_STOP:
@@ -578,30 +613,30 @@ static void player_process_command(player &player)
case PLAYER_COMMAND_QUEUE:
assert(pc.next_song != NULL);
assert(!player.queued);
assert(!player_dc_at_next_song(player));
assert(!queued);
assert(!IsDecoderAtNextSong());
player.queued = true;
queued = true;
player_command_finished_locked(pc);
break;
case PLAYER_COMMAND_PAUSE:
pc.Unlock();
player.paused = !player.paused;
if (player.paused) {
paused = !paused;
if (paused) {
audio_output_all_pause();
pc.Lock();
pc.state = PLAYER_STATE_PAUSE;
} else if (!player.play_audio_format.IsDefined()) {
} else if (!play_audio_format.IsDefined()) {
/* the decoder hasn't provided an audio format
yet - don't open the audio device yet */
pc.Lock();
pc.state = PLAYER_STATE_PLAY;
} else {
player_open_output(player);
OpenOutput();
pc.Lock();
}
@@ -611,7 +646,7 @@ static void player_process_command(player &player)
case PLAYER_COMMAND_SEEK:
pc.Unlock();
player_seek_decoder(player);
SeekDecoder();
pc.Lock();
break;
@@ -624,22 +659,22 @@ static void player_process_command(player &player)
return;
}
if (player_dc_at_next_song(player)) {
if (IsDecoderAtNextSong()) {
/* the decoder is already decoding the song -
stop it and reset the position */
pc.Unlock();
player_dc_stop(player);
StopDecoder();
pc.Lock();
}
pc.next_song->Free();
pc.next_song = NULL;
player.queued = false;
queued = false;
player_command_finished_locked(pc);
break;
case PLAYER_COMMAND_REFRESH:
if (player.output_open && !player.paused) {
if (output_open && !paused) {
pc.Unlock();
audio_output_all_check();
pc.Lock();
@@ -647,7 +682,7 @@ static void player_process_command(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 = elapsed_time;
player_command_finished_locked(pc);
break;
@@ -714,18 +749,9 @@ play_chunk(player_control &pc,
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(player &player)
inline bool
player::PlayNextChunk()
{
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
another chunk */
@@ -733,38 +759,36 @@ play_next_chunk(player &player)
unsigned cross_fade_position;
struct music_chunk *chunk = NULL;
if (player.xfade == XFADE_ENABLED &&
player_dc_at_next_song(player) &&
(cross_fade_position = player.pipe->GetSize())
<= player.cross_fade_chunks) {
if (xfade == XFADE_ENABLED && IsDecoderAtNextSong() &&
(cross_fade_position = pipe->GetSize()) <= cross_fade_chunks) {
/* perform cross fade */
music_chunk *other_chunk = dc.pipe->Shift();
if (!player.cross_fading) {
if (!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;
cross_fade_chunks = cross_fade_position;
cross_fading = true;
}
if (other_chunk != NULL) {
chunk = player.pipe->Shift();
chunk = 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,
cross_fade_tag =
Tag::MergeReplace(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;
/ cross_fade_chunks;
} else {
chunk->mix_ratio = nan("");
}
@@ -777,7 +801,7 @@ play_next_chunk(player &player)
beginning of the new song, we can
easily recover by throwing it away
now */
player.buffer.Return(other_chunk);
buffer.Return(other_chunk);
other_chunk = NULL;
}
@@ -792,7 +816,7 @@ play_next_chunk(player &player)
cross fading */
dc.Unlock();
player.xfade = XFADE_DISABLED;
xfade = XFADE_DISABLED;
} else {
/* wait for the decoder */
dc.Signal();
@@ -805,26 +829,24 @@ play_next_chunk(player &player)
}
if (chunk == NULL)
chunk = player.pipe->Shift();
chunk = pipe->Shift();
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::MergeReplace(chunk->tag,
player.cross_fade_tag);
player.cross_fade_tag = NULL;
if (xfade != XFADE_ENABLED && cross_fade_tag != nullptr) {
chunk->tag = Tag::MergeReplace(chunk->tag, cross_fade_tag);
cross_fade_tag = nullptr;
}
/* play the current chunk */
Error error;
if (!play_chunk(player.pc, player.song, chunk, player.buffer,
player.play_audio_format, error)) {
if (!play_chunk(pc, song, chunk, buffer, play_audio_format, error)) {
g_warning("%s", error.GetMessage());
player.buffer.Return(chunk);
buffer.Return(chunk);
pc.Lock();
@@ -833,7 +855,7 @@ play_next_chunk(player &player)
/* pause: the user may resume playback as soon as an
audio output becomes available */
pc.state = PLAYER_STATE_PAUSE;
player.paused = true;
paused = true;
pc.Unlock();
@@ -848,45 +870,34 @@ play_next_chunk(player &player)
dc.Lock();
if (!dc.IsIdle() &&
dc.pipe->GetSize() <= (pc.buffered_before_play +
player.buffer.GetSize() * 3) / 4)
buffer.GetSize() * 3) / 4)
dc.Signal();
dc.Unlock();
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(player &player)
inline bool
player::SongBorder()
{
player.xfade = XFADE_UNKNOWN;
xfade = XFADE_UNKNOWN;
char *uri = player.song->GetURI();
char *uri = song->GetURI();
g_message("played \"%s\"", uri);
g_free(uri);
delete player.pipe;
player.pipe = player.dc.pipe;
ReplacePipe(dc.pipe);
audio_output_all_song_border();
if (!player_wait_for_decoder(player))
if (!WaitForDecoder())
return false;
player_control &pc = player.pc;
pc.Lock();
const bool border_pause = pc.border_pause;
if (border_pause) {
player.paused = true;
paused = true;
pc.state = PLAYER_STATE_PAUSE;
}
@@ -898,28 +909,20 @@ player_song_border(player &player)
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(player_control &pc, decoder_control &dc,
MusicBuffer &buffer)
inline void
player::Run()
{
player player(pc, dc, buffer);
pc.Unlock();
player.pipe = new MusicPipe();
pipe = new MusicPipe();
player_dc_start(player, *player.pipe);
if (!player_wait_for_decoder(player)) {
assert(player.song == NULL);
StartDecoder(*pipe);
if (!WaitForDecoder()) {
assert(song == NULL);
player_dc_stop(player);
StopDecoder();
player_command_finished(pc);
delete player.pipe;
delete pipe;
GlobalEvents::Emit(GlobalEvents::PLAYLIST);
pc.Lock();
return;
@@ -929,12 +932,12 @@ do_play(player_control &pc, decoder_control &dc,
pc.state = PLAYER_STATE_PLAY;
if (pc.command == PLAYER_COMMAND_SEEK)
player.elapsed_time = pc.seek_where;
elapsed_time = pc.seek_where;
player_command_finished_locked(pc);
while (true) {
player_process_command(player);
ProcessCommand();
if (pc.command == PLAYER_COMMAND_STOP ||
pc.command == PLAYER_COMMAND_EXIT ||
pc.command == PLAYER_COMMAND_CLOSE_AUDIO) {
@@ -945,19 +948,18 @@ do_play(player_control &pc, decoder_control &dc,
pc.Unlock();
if (player.buffering) {
if (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 &&
if (pipe->GetSize() < pc.buffered_before_play &&
!dc.LockIsIdle()) {
/* not enough decoded buffer space yet */
if (!player.paused &&
player.output_open &&
if (!paused && output_open &&
audio_output_all_check() < 4 &&
!player_send_silence(player))
!SendSilence())
break;
dc.Lock();
@@ -968,14 +970,14 @@ do_play(player_control &pc, decoder_control &dc,
continue;
} else {
/* buffering is complete */
player.buffering = false;
buffering = false;
}
}
if (player.decoder_starting) {
if (decoder_starting) {
/* wait until the decoder is initialized completely */
if (!player_check_decoder_startup(player))
if (!CheckDecoderStartup())
break;
pc.Lock();
@@ -985,31 +987,30 @@ do_play(player_control &pc, decoder_control &dc,
#ifndef NDEBUG
/*
music_pipe_check_format(&play_audio_format,
player.next_song_chunk,
next_song_chunk,
&dc.out_audio_format);
*/
#endif
if (dc.LockIsIdle() && player.queued &&
dc.pipe == player.pipe) {
if (dc.LockIsIdle() && queued && dc.pipe == 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 == pipe);
player_dc_start(player, *new MusicPipe());
StartDecoder(*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.xfade == XFADE_UNKNOWN &&
IsDecoderAtNextSong() &&
xfade == XFADE_UNKNOWN &&
!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_chunks =
cross_fade_calc(pc.cross_fade_seconds, dc.total_time,
pc.mixramp_db,
pc.mixramp_delay_seconds,
@@ -1018,29 +1019,29 @@ do_play(player_control &pc, decoder_control &dc,
dc.mixramp_start,
dc.mixramp_prev_end,
dc.out_audio_format,
player.play_audio_format,
player.buffer.GetSize() -
play_audio_format,
buffer.GetSize() -
pc.buffered_before_play);
if (player.cross_fade_chunks > 0) {
player.xfade = XFADE_ENABLED;
player.cross_fading = false;
if (cross_fade_chunks > 0) {
xfade = XFADE_ENABLED;
cross_fading = false;
} else
/* cross fading is disabled or the
next song is too short */
player.xfade = XFADE_DISABLED;
xfade = XFADE_DISABLED;
}
if (player.paused) {
if (paused) {
pc.Lock();
if (pc.command == PLAYER_COMMAND_NONE)
pc.Wait();
continue;
} else if (!player.pipe->IsEmpty()) {
} else if (!pipe->IsEmpty()) {
/* at least one music chunk is ready - send it
to the audio output */
play_next_chunk(player);
PlayNextChunk();
} else if (audio_output_all_check() > 0) {
/* not enough data from decoder, but the
output thread is still busy, so it's
@@ -1048,45 +1049,44 @@ 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 (IsDecoderAtNextSong()) {
/* at the beginning of a new song */
if (!player_song_border(player))
if (!SongBorder())
break;
} else if (dc.LockIsIdle()) {
/* check the size of the pipe again, because
the decoder thread may have added something
since we last checked */
if (player.pipe->IsEmpty()) {
if (pipe->IsEmpty()) {
/* wait for the hardware to finish
playback */
audio_output_all_drain();
break;
}
} else if (player.output_open) {
} else if (output_open) {
/* 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 (!SendSilence())
break;
}
pc.Lock();
}
player_dc_stop(player);
StopDecoder();
player.pipe->Clear(player.buffer);
delete player.pipe;
ClearAndDeletePipe();
delete player.cross_fade_tag;
delete cross_fade_tag;
if (player.song != NULL)
player.song->Free();
if (song != nullptr)
song->Free();
pc.Lock();
if (player.queued) {
if (queued) {
assert(pc.next_song != NULL);
pc.next_song->Free();
pc.next_song = NULL;
@@ -1101,6 +1101,14 @@ do_play(player_control &pc, decoder_control &dc,
pc.Lock();
}
static void
do_play(player_control &pc, decoder_control &dc,
MusicBuffer &buffer)
{
player player(pc, dc, buffer);
player.Run();
}
static gpointer
player_task(gpointer arg)
{