77c63511d8
After the number of decoded chunks has fallen below the threshold, the PlayerThread woke up the DecoderThread over and over. This commit adds a boolean flag that avoids these duplicate wakeups, and thus reduces the number of system calls.
1205 lines
24 KiB
C++
1205 lines
24 KiB
C++
/*
|
|
* Copyright (C) 2003-2013 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 "PlayerThread.hxx"
|
|
#include "DecoderThread.hxx"
|
|
#include "DecoderControl.hxx"
|
|
#include "MusicPipe.hxx"
|
|
#include "MusicBuffer.hxx"
|
|
#include "MusicChunk.hxx"
|
|
#include "Song.hxx"
|
|
#include "Main.hxx"
|
|
#include "system/FatalError.hxx"
|
|
#include "CrossFade.hxx"
|
|
#include "PlayerControl.hxx"
|
|
#include "OutputAll.hxx"
|
|
#include "tag/Tag.hxx"
|
|
#include "Idle.hxx"
|
|
#include "GlobalEvents.hxx"
|
|
#include "util/Domain.hxx"
|
|
#include "Log.hxx"
|
|
|
|
#include <glib.h>
|
|
|
|
#include <string.h>
|
|
|
|
static constexpr Domain player_domain("player");
|
|
|
|
enum class CrossFadeState : int8_t {
|
|
DISABLED = -1,
|
|
UNKNOWN = 0,
|
|
ENABLED = 1
|
|
};
|
|
|
|
class Player {
|
|
PlayerControl &pc;
|
|
|
|
DecoderControl &dc;
|
|
|
|
MusicBuffer &buffer;
|
|
|
|
MusicPipe *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;
|
|
|
|
/**
|
|
* Did we wake up the DecoderThread recently? This avoids
|
|
* duplicate wakeup calls.
|
|
*/
|
|
bool decoder_woken;
|
|
|
|
/**
|
|
* is the player paused?
|
|
*/
|
|
bool paused;
|
|
|
|
/**
|
|
* is there a new song in pc.next_song?
|
|
*/
|
|
bool queued;
|
|
|
|
/**
|
|
* Was any audio output opened successfully? It might have
|
|
* failed meanwhile, but was not explicitly closed by the
|
|
* player thread. When this flag is unset, some output
|
|
* methods must not be called.
|
|
*/
|
|
bool output_open;
|
|
|
|
/**
|
|
* the song currently being played
|
|
*/
|
|
Song *song;
|
|
|
|
/**
|
|
* is cross fading enabled?
|
|
*/
|
|
CrossFadeState xfade_state;
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
Tag *cross_fade_tag;
|
|
|
|
/**
|
|
* The current audio format for the audio outputs.
|
|
*/
|
|
AudioFormat 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
|
|
* precisely.
|
|
*/
|
|
float elapsed_time;
|
|
|
|
public:
|
|
Player(PlayerControl &_pc, DecoderControl &_dc,
|
|
MusicBuffer &_buffer)
|
|
:pc(_pc), dc(_dc), buffer(_buffer),
|
|
buffering(true),
|
|
decoder_starting(false),
|
|
decoder_woken(false),
|
|
paused(false),
|
|
queued(true),
|
|
output_open(false),
|
|
song(nullptr),
|
|
xfade_state(CrossFadeState::UNKNOWN),
|
|
cross_fading(false),
|
|
cross_fade_chunks(0),
|
|
cross_fade_tag(nullptr),
|
|
elapsed_time(0.0) {}
|
|
|
|
private:
|
|
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 #PlayerCommand::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();
|
|
|
|
public:
|
|
/*
|
|
* 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
|
|
player_command_finished(PlayerControl &pc)
|
|
{
|
|
pc.Lock();
|
|
pc.CommandFinished();
|
|
pc.Unlock();
|
|
}
|
|
|
|
void
|
|
Player::StartDecoder(MusicPipe &_pipe)
|
|
{
|
|
assert(queued || pc.command == PlayerCommand::SEEK);
|
|
assert(pc.next_song != nullptr);
|
|
|
|
unsigned start_ms = pc.next_song->start_ms;
|
|
if (pc.command == PlayerCommand::SEEK)
|
|
start_ms += (unsigned)(pc.seek_where * 1000);
|
|
|
|
dc.Start(pc.next_song->DupDetached(),
|
|
start_ms, pc.next_song->end_ms,
|
|
buffer, _pipe);
|
|
}
|
|
|
|
void
|
|
Player::StopDecoder()
|
|
{
|
|
dc.Stop();
|
|
|
|
if (dc.pipe != nullptr) {
|
|
/* clear and free the decoder pipe */
|
|
|
|
dc.pipe->Clear(buffer);
|
|
|
|
if (dc.pipe != pipe)
|
|
delete dc.pipe;
|
|
|
|
dc.pipe = nullptr;
|
|
}
|
|
}
|
|
|
|
bool
|
|
Player::WaitForDecoder()
|
|
{
|
|
assert(queued || pc.command == PlayerCommand::SEEK);
|
|
assert(pc.next_song != nullptr);
|
|
|
|
queued = false;
|
|
|
|
pc.Lock();
|
|
Error error = dc.GetError();
|
|
if (error.IsDefined()) {
|
|
pc.SetError(PlayerError::DECODER, std::move(error));
|
|
|
|
pc.next_song->Free();
|
|
pc.next_song = nullptr;
|
|
|
|
pc.Unlock();
|
|
|
|
return false;
|
|
}
|
|
|
|
pc.ClearTaggedSong();
|
|
|
|
if (song != nullptr)
|
|
song->Free();
|
|
|
|
song = pc.next_song;
|
|
elapsed_time = 0.0;
|
|
|
|
/* set the "starting" flag, which will be cleared by
|
|
player_check_decoder_startup() */
|
|
decoder_starting = true;
|
|
|
|
/* update PlayerControl's song information */
|
|
pc.total_time = pc.next_song->GetDuration();
|
|
pc.bit_rate = 0;
|
|
pc.audio_format.Clear();
|
|
|
|
/* clear the queued song */
|
|
pc.next_song = nullptr;
|
|
|
|
pc.Unlock();
|
|
|
|
/* call syncPlaylistWithQueue() in the main thread */
|
|
GlobalEvents::Emit(GlobalEvents::PLAYLIST);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Returns the real duration of the song, comprising the duration
|
|
* indicated by the decoder plugin.
|
|
*/
|
|
static double
|
|
real_song_duration(const Song *song, double decoder_duration)
|
|
{
|
|
assert(song != nullptr);
|
|
|
|
if (decoder_duration <= 0.0)
|
|
/* the decoder plugin didn't provide information; fall
|
|
back to Song::GetDuration() */
|
|
return song->GetDuration();
|
|
|
|
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;
|
|
}
|
|
|
|
bool
|
|
Player::OpenOutput()
|
|
{
|
|
assert(play_audio_format.IsDefined());
|
|
assert(pc.state == PlayerState::PLAY ||
|
|
pc.state == PlayerState::PAUSE);
|
|
|
|
Error error;
|
|
if (audio_output_all_open(play_audio_format, buffer, error)) {
|
|
output_open = true;
|
|
paused = false;
|
|
|
|
pc.Lock();
|
|
pc.state = PlayerState::PLAY;
|
|
pc.Unlock();
|
|
|
|
idle_add(IDLE_PLAYER);
|
|
|
|
return true;
|
|
} else {
|
|
LogError(error);
|
|
|
|
output_open = false;
|
|
|
|
/* pause: the user may resume playback as soon as an
|
|
audio output becomes available */
|
|
paused = true;
|
|
|
|
pc.Lock();
|
|
pc.SetError(PlayerError::OUTPUT, std::move(error));
|
|
pc.state = PlayerState::PAUSE;
|
|
pc.Unlock();
|
|
|
|
idle_add(IDLE_PLAYER);
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool
|
|
Player::CheckDecoderStartup()
|
|
{
|
|
assert(decoder_starting);
|
|
|
|
pc.Lock();
|
|
|
|
Error error = dc.GetError();
|
|
if (error.IsDefined()) {
|
|
/* the decoder failed */
|
|
pc.SetError(PlayerError::DECODER, std::move(error));
|
|
pc.Unlock();
|
|
|
|
return false;
|
|
} else if (!dc.IsStarting()) {
|
|
/* the decoder is ready and ok */
|
|
|
|
pc.Unlock();
|
|
|
|
if (output_open &&
|
|
!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();
|
|
|
|
idle_add(IDLE_PLAYER);
|
|
|
|
play_audio_format = dc.out_audio_format;
|
|
decoder_starting = false;
|
|
|
|
if (!paused && !OpenOutput()) {
|
|
const auto uri = dc.song->GetURI();
|
|
FormatError(player_domain,
|
|
"problems opening audio device "
|
|
"while playing \"%s\"", uri.c_str());
|
|
return true;
|
|
}
|
|
|
|
return true;
|
|
} else {
|
|
/* the decoder is not yet ready; wait
|
|
some more */
|
|
dc.WaitForDecoder();
|
|
pc.Unlock();
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
bool
|
|
Player::SendSilence()
|
|
{
|
|
assert(output_open);
|
|
assert(play_audio_format.IsDefined());
|
|
|
|
struct music_chunk *chunk = buffer.Allocate();
|
|
if (chunk == nullptr) {
|
|
LogError(player_domain, "Failed to allocate silence buffer");
|
|
return false;
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
chunk->audio_format = play_audio_format;
|
|
#endif
|
|
|
|
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;
|
|
|
|
chunk->times = -1.0; /* undefined time stamp */
|
|
chunk->length = num_frames * frame_size;
|
|
memset(chunk->data, 0, chunk->length);
|
|
|
|
Error error;
|
|
if (!audio_output_all_play(chunk, error)) {
|
|
LogError(error);
|
|
buffer.Return(chunk);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
inline bool
|
|
Player::SeekDecoder()
|
|
{
|
|
assert(pc.next_song != nullptr);
|
|
|
|
const unsigned start_ms = pc.next_song->start_ms;
|
|
|
|
if (!dc.LockIsCurrentSong(*pc.next_song)) {
|
|
/* the decoder is already decoding the "next" song -
|
|
stop it and start the previous song again */
|
|
|
|
StopDecoder();
|
|
|
|
/* clear music chunks which might still reside in the
|
|
pipe */
|
|
pipe->Clear(buffer);
|
|
|
|
/* re-start the decoder */
|
|
StartDecoder(*pipe);
|
|
if (!WaitForDecoder()) {
|
|
/* decoder failure */
|
|
player_command_finished(pc);
|
|
return false;
|
|
}
|
|
} else {
|
|
if (!IsDecoderAtCurrentSong()) {
|
|
/* the decoder is already decoding the "next" song,
|
|
but it is the same song file; exchange the pipe */
|
|
ClearAndReplacePipe(dc.pipe);
|
|
}
|
|
|
|
pc.next_song->Free();
|
|
pc.next_song = nullptr;
|
|
queued = false;
|
|
}
|
|
|
|
/* wait for the decoder to complete initialization */
|
|
|
|
while (decoder_starting) {
|
|
if (!CheckDecoderStartup()) {
|
|
/* decoder failure */
|
|
player_command_finished(pc);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/* send the SEEK command */
|
|
|
|
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)) {
|
|
/* decoder failure */
|
|
player_command_finished(pc);
|
|
return false;
|
|
}
|
|
|
|
elapsed_time = where;
|
|
|
|
player_command_finished(pc);
|
|
|
|
xfade_state = CrossFadeState::UNKNOWN;
|
|
|
|
/* re-fill the buffer after seeking */
|
|
buffering = true;
|
|
|
|
audio_output_all_cancel();
|
|
|
|
return true;
|
|
}
|
|
|
|
inline void
|
|
Player::ProcessCommand()
|
|
{
|
|
switch (pc.command) {
|
|
case PlayerCommand::NONE:
|
|
case PlayerCommand::STOP:
|
|
case PlayerCommand::EXIT:
|
|
case PlayerCommand::CLOSE_AUDIO:
|
|
break;
|
|
|
|
case PlayerCommand::UPDATE_AUDIO:
|
|
pc.Unlock();
|
|
audio_output_all_enable_disable();
|
|
pc.Lock();
|
|
pc.CommandFinished();
|
|
break;
|
|
|
|
case PlayerCommand::QUEUE:
|
|
assert(pc.next_song != nullptr);
|
|
assert(!queued);
|
|
assert(!IsDecoderAtNextSong());
|
|
|
|
queued = true;
|
|
pc.CommandFinished();
|
|
break;
|
|
|
|
case PlayerCommand::PAUSE:
|
|
pc.Unlock();
|
|
|
|
paused = !paused;
|
|
if (paused) {
|
|
audio_output_all_pause();
|
|
pc.Lock();
|
|
|
|
pc.state = PlayerState::PAUSE;
|
|
} 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 = PlayerState::PLAY;
|
|
} else {
|
|
OpenOutput();
|
|
|
|
pc.Lock();
|
|
}
|
|
|
|
pc.CommandFinished();
|
|
break;
|
|
|
|
case PlayerCommand::SEEK:
|
|
pc.Unlock();
|
|
SeekDecoder();
|
|
pc.Lock();
|
|
break;
|
|
|
|
case PlayerCommand::CANCEL:
|
|
if (pc.next_song == nullptr) {
|
|
/* the cancel request arrived too late, we're
|
|
already playing the queued song... stop
|
|
everything now */
|
|
pc.command = PlayerCommand::STOP;
|
|
return;
|
|
}
|
|
|
|
if (IsDecoderAtNextSong()) {
|
|
/* the decoder is already decoding the song -
|
|
stop it and reset the position */
|
|
pc.Unlock();
|
|
StopDecoder();
|
|
pc.Lock();
|
|
}
|
|
|
|
pc.next_song->Free();
|
|
pc.next_song = nullptr;
|
|
queued = false;
|
|
pc.CommandFinished();
|
|
break;
|
|
|
|
case PlayerCommand::REFRESH:
|
|
if (output_open && !paused) {
|
|
pc.Unlock();
|
|
audio_output_all_check();
|
|
pc.Lock();
|
|
}
|
|
|
|
pc.elapsed_time = audio_output_all_get_elapsed_time();
|
|
if (pc.elapsed_time < 0.0)
|
|
pc.elapsed_time = elapsed_time;
|
|
|
|
pc.CommandFinished();
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
update_song_tag(PlayerControl &pc, Song *song, const Tag &new_tag)
|
|
{
|
|
if (song->IsFile())
|
|
/* don't update tags of local files, only remote
|
|
streams may change tags dynamically */
|
|
return;
|
|
|
|
Tag *old_tag = song->tag;
|
|
song->tag = new Tag(new_tag);
|
|
|
|
delete old_tag;
|
|
|
|
pc.LockSetTaggedSong(*song);
|
|
|
|
/* the main thread will update the playlist version when he
|
|
receives this event */
|
|
GlobalEvents::Emit(GlobalEvents::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(PlayerControl &pc,
|
|
Song *song, struct music_chunk *chunk,
|
|
MusicBuffer &buffer,
|
|
const AudioFormat format,
|
|
Error &error)
|
|
{
|
|
assert(chunk->CheckFormat(format));
|
|
|
|
if (chunk->tag != nullptr)
|
|
update_song_tag(pc, song, *chunk->tag);
|
|
|
|
if (chunk->IsEmpty()) {
|
|
buffer.Return(chunk);
|
|
return true;
|
|
}
|
|
|
|
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 /
|
|
format.GetTimeToSize();
|
|
return true;
|
|
}
|
|
|
|
inline bool
|
|
Player::PlayNextChunk()
|
|
{
|
|
if (!audio_output_all_wait(pc, 64))
|
|
/* the output pipe is still large enough, don't send
|
|
another chunk */
|
|
return true;
|
|
|
|
unsigned cross_fade_position;
|
|
struct music_chunk *chunk = nullptr;
|
|
if (xfade_state == CrossFadeState::ENABLED && IsDecoderAtNextSong() &&
|
|
(cross_fade_position = pipe->GetSize()) <= cross_fade_chunks) {
|
|
/* perform cross fade */
|
|
music_chunk *other_chunk = dc.pipe->Shift();
|
|
|
|
if (!cross_fading) {
|
|
/* beginning of the cross fade - adjust
|
|
crossFadeChunks which might be bigger than
|
|
the remaining number of chunks in the old
|
|
song */
|
|
cross_fade_chunks = cross_fade_position;
|
|
cross_fading = true;
|
|
}
|
|
|
|
if (other_chunk != nullptr) {
|
|
chunk = pipe->Shift();
|
|
assert(chunk != nullptr);
|
|
assert(chunk->other == nullptr);
|
|
|
|
/* don't send the tags of the new song (which
|
|
is being faded in) yet; postpone it until
|
|
the current song is faded out */
|
|
cross_fade_tag =
|
|
Tag::MergeReplace(cross_fade_tag,
|
|
other_chunk->tag);
|
|
other_chunk->tag = nullptr;
|
|
|
|
if (pc.cross_fade.mixramp_delay <= 0) {
|
|
chunk->mix_ratio = ((float)cross_fade_position)
|
|
/ cross_fade_chunks;
|
|
} else {
|
|
chunk->mix_ratio = -1;
|
|
}
|
|
|
|
if (other_chunk->IsEmpty()) {
|
|
/* the "other" chunk was a music_chunk
|
|
which had only a tag, but no music
|
|
data - we cannot cross-fade that;
|
|
but since this happens only at the
|
|
beginning of the new song, we can
|
|
easily recover by throwing it away
|
|
now */
|
|
buffer.Return(other_chunk);
|
|
other_chunk = nullptr;
|
|
}
|
|
|
|
chunk->other = other_chunk;
|
|
} else {
|
|
/* there are not enough decoded chunks yet */
|
|
|
|
pc.Lock();
|
|
|
|
if (dc.IsIdle()) {
|
|
/* the decoder isn't running, abort
|
|
cross fading */
|
|
pc.Unlock();
|
|
|
|
xfade_state = CrossFadeState::DISABLED;
|
|
} else {
|
|
/* wait for the decoder */
|
|
dc.Signal();
|
|
dc.WaitForDecoder();
|
|
pc.Unlock();
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (chunk == nullptr)
|
|
chunk = pipe->Shift();
|
|
|
|
assert(chunk != nullptr);
|
|
|
|
/* insert the postponed tag if cross-fading is finished */
|
|
|
|
if (xfade_state != CrossFadeState::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(pc, song, chunk, buffer, play_audio_format, error)) {
|
|
LogError(error);
|
|
|
|
buffer.Return(chunk);
|
|
|
|
pc.Lock();
|
|
|
|
pc.SetError(PlayerError::OUTPUT, std::move(error));
|
|
|
|
/* pause: the user may resume playback as soon as an
|
|
audio output becomes available */
|
|
pc.state = PlayerState::PAUSE;
|
|
paused = true;
|
|
|
|
pc.Unlock();
|
|
|
|
idle_add(IDLE_PLAYER);
|
|
|
|
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 */
|
|
pc.Lock();
|
|
if (!dc.IsIdle() &&
|
|
dc.pipe->GetSize() <= (pc.buffered_before_play +
|
|
buffer.GetSize() * 3) / 4) {
|
|
if (!decoder_woken) {
|
|
decoder_woken = true;
|
|
dc.Signal();
|
|
}
|
|
} else
|
|
decoder_woken = false;
|
|
pc.Unlock();
|
|
|
|
return true;
|
|
}
|
|
|
|
inline bool
|
|
Player::SongBorder()
|
|
{
|
|
xfade_state = CrossFadeState::UNKNOWN;
|
|
|
|
{
|
|
const auto uri = song->GetURI();
|
|
FormatDefault(player_domain, "played \"%s\"", uri.c_str());
|
|
}
|
|
|
|
ReplacePipe(dc.pipe);
|
|
|
|
audio_output_all_song_border();
|
|
|
|
if (!WaitForDecoder())
|
|
return false;
|
|
|
|
pc.Lock();
|
|
|
|
const bool border_pause = pc.border_pause;
|
|
if (border_pause) {
|
|
paused = true;
|
|
pc.state = PlayerState::PAUSE;
|
|
}
|
|
|
|
pc.Unlock();
|
|
|
|
if (border_pause)
|
|
idle_add(IDLE_PLAYER);
|
|
|
|
return true;
|
|
}
|
|
|
|
inline void
|
|
Player::Run()
|
|
{
|
|
pipe = new MusicPipe();
|
|
|
|
StartDecoder(*pipe);
|
|
if (!WaitForDecoder()) {
|
|
assert(song == nullptr);
|
|
|
|
StopDecoder();
|
|
player_command_finished(pc);
|
|
delete pipe;
|
|
return;
|
|
}
|
|
|
|
pc.Lock();
|
|
pc.state = PlayerState::PLAY;
|
|
|
|
if (pc.command == PlayerCommand::SEEK)
|
|
elapsed_time = pc.seek_where;
|
|
|
|
pc.CommandFinished();
|
|
|
|
while (true) {
|
|
ProcessCommand();
|
|
if (pc.command == PlayerCommand::STOP ||
|
|
pc.command == PlayerCommand::EXIT ||
|
|
pc.command == PlayerCommand::CLOSE_AUDIO) {
|
|
pc.Unlock();
|
|
audio_output_all_cancel();
|
|
break;
|
|
}
|
|
|
|
pc.Unlock();
|
|
|
|
if (buffering) {
|
|
/* buffering at the start of the song - wait
|
|
until the buffer is large enough, to
|
|
prevent stuttering on slow machines */
|
|
|
|
if (pipe->GetSize() < pc.buffered_before_play &&
|
|
!dc.LockIsIdle()) {
|
|
/* not enough decoded buffer space yet */
|
|
|
|
if (!paused && output_open &&
|
|
audio_output_all_check() < 4 &&
|
|
!SendSilence())
|
|
break;
|
|
|
|
pc.Lock();
|
|
/* XXX race condition: check decoder again */
|
|
dc.WaitForDecoder();
|
|
continue;
|
|
} else {
|
|
/* buffering is complete */
|
|
buffering = false;
|
|
}
|
|
}
|
|
|
|
if (decoder_starting) {
|
|
/* wait until the decoder is initialized completely */
|
|
|
|
if (!CheckDecoderStartup())
|
|
break;
|
|
|
|
pc.Lock();
|
|
continue;
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
/*
|
|
music_pipe_check_format(&play_audio_format,
|
|
next_song_chunk,
|
|
&dc.out_audio_format);
|
|
*/
|
|
#endif
|
|
|
|
if (dc.LockIsIdle() && queued && dc.pipe == pipe) {
|
|
/* the decoder has finished the current song;
|
|
make it decode the next song */
|
|
|
|
assert(dc.pipe == nullptr || dc.pipe == pipe);
|
|
|
|
StartDecoder(*new MusicPipe());
|
|
}
|
|
|
|
if (/* no cross-fading if MPD is going to pause at the
|
|
end of the current song */
|
|
!pc.border_pause &&
|
|
IsDecoderAtNextSong() &&
|
|
xfade_state == CrossFadeState::UNKNOWN &&
|
|
!dc.LockIsStarting()) {
|
|
/* enable cross fading in this song? if yes,
|
|
calculate how many chunks will be required
|
|
for it */
|
|
cross_fade_chunks =
|
|
pc.cross_fade.Calculate(dc.total_time,
|
|
dc.replay_gain_db,
|
|
dc.replay_gain_prev_db,
|
|
dc.GetMixRampStart(),
|
|
dc.GetMixRampPreviousEnd(),
|
|
dc.out_audio_format,
|
|
play_audio_format,
|
|
buffer.GetSize() -
|
|
pc.buffered_before_play);
|
|
if (cross_fade_chunks > 0) {
|
|
xfade_state = CrossFadeState::ENABLED;
|
|
cross_fading = false;
|
|
} else
|
|
/* cross fading is disabled or the
|
|
next song is too short */
|
|
xfade_state = CrossFadeState::DISABLED;
|
|
}
|
|
|
|
if (paused) {
|
|
pc.Lock();
|
|
|
|
if (pc.command == PlayerCommand::NONE)
|
|
pc.Wait();
|
|
continue;
|
|
} else if (!pipe->IsEmpty()) {
|
|
/* at least one music chunk is ready - send it
|
|
to the audio output */
|
|
|
|
PlayNextChunk();
|
|
} 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 (IsDecoderAtNextSong()) {
|
|
/* at the beginning of a new song */
|
|
|
|
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 (pipe->IsEmpty()) {
|
|
/* wait for the hardware to finish
|
|
playback */
|
|
audio_output_all_drain();
|
|
break;
|
|
}
|
|
} 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 (!SendSilence())
|
|
break;
|
|
}
|
|
|
|
pc.Lock();
|
|
}
|
|
|
|
StopDecoder();
|
|
|
|
ClearAndDeletePipe();
|
|
|
|
delete cross_fade_tag;
|
|
|
|
if (song != nullptr)
|
|
song->Free();
|
|
|
|
pc.Lock();
|
|
|
|
pc.ClearTaggedSong();
|
|
|
|
if (queued) {
|
|
assert(pc.next_song != nullptr);
|
|
pc.next_song->Free();
|
|
pc.next_song = nullptr;
|
|
}
|
|
|
|
pc.state = PlayerState::STOP;
|
|
|
|
pc.Unlock();
|
|
}
|
|
|
|
static void
|
|
do_play(PlayerControl &pc, DecoderControl &dc,
|
|
MusicBuffer &buffer)
|
|
{
|
|
Player player(pc, dc, buffer);
|
|
player.Run();
|
|
}
|
|
|
|
static void
|
|
player_task(void *arg)
|
|
{
|
|
PlayerControl &pc = *(PlayerControl *)arg;
|
|
|
|
DecoderControl dc(pc.mutex, pc.cond);
|
|
decoder_thread_start(dc);
|
|
|
|
MusicBuffer buffer(pc.buffer_chunks);
|
|
|
|
pc.Lock();
|
|
|
|
while (1) {
|
|
switch (pc.command) {
|
|
case PlayerCommand::SEEK:
|
|
case PlayerCommand::QUEUE:
|
|
assert(pc.next_song != nullptr);
|
|
|
|
pc.Unlock();
|
|
do_play(pc, dc, buffer);
|
|
GlobalEvents::Emit(GlobalEvents::PLAYLIST);
|
|
pc.Lock();
|
|
break;
|
|
|
|
case PlayerCommand::STOP:
|
|
pc.Unlock();
|
|
audio_output_all_cancel();
|
|
pc.Lock();
|
|
|
|
/* fall through */
|
|
|
|
case PlayerCommand::PAUSE:
|
|
if (pc.next_song != nullptr) {
|
|
pc.next_song->Free();
|
|
pc.next_song = nullptr;
|
|
}
|
|
|
|
pc.CommandFinished();
|
|
break;
|
|
|
|
case PlayerCommand::CLOSE_AUDIO:
|
|
pc.Unlock();
|
|
|
|
audio_output_all_release();
|
|
|
|
pc.Lock();
|
|
pc.CommandFinished();
|
|
|
|
assert(buffer.IsEmptyUnsafe());
|
|
|
|
break;
|
|
|
|
case PlayerCommand::UPDATE_AUDIO:
|
|
pc.Unlock();
|
|
audio_output_all_enable_disable();
|
|
pc.Lock();
|
|
pc.CommandFinished();
|
|
break;
|
|
|
|
case PlayerCommand::EXIT:
|
|
pc.Unlock();
|
|
|
|
dc.Quit();
|
|
|
|
audio_output_all_close();
|
|
|
|
player_command_finished(pc);
|
|
return;
|
|
|
|
case PlayerCommand::CANCEL:
|
|
if (pc.next_song != nullptr) {
|
|
pc.next_song->Free();
|
|
pc.next_song = nullptr;
|
|
}
|
|
|
|
pc.CommandFinished();
|
|
break;
|
|
|
|
case PlayerCommand::REFRESH:
|
|
/* no-op when not playing */
|
|
pc.CommandFinished();
|
|
break;
|
|
|
|
case PlayerCommand::NONE:
|
|
pc.Wait();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
player_create(PlayerControl &pc)
|
|
{
|
|
assert(!pc.thread.IsDefined());
|
|
|
|
Error error;
|
|
if (!pc.thread.Start(player_task, &pc, error))
|
|
FatalError(error);
|
|
}
|