2009-03-11 09:35:16 +01:00
|
|
|
/*
|
2017-01-03 20:48:59 +01:00
|
|
|
* Copyright 2003-2017 The Music Player Daemon Project
|
2009-03-11 09:35:16 +01:00
|
|
|
* http://www.musicpd.org
|
2008-08-26 08:27:09 +02:00
|
|
|
*
|
|
|
|
* 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.
|
2009-03-13 18:43:16 +01:00
|
|
|
*
|
|
|
|
* 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.
|
2008-08-26 08:27:09 +02:00
|
|
|
*/
|
|
|
|
|
2018-09-21 17:14:19 +02:00
|
|
|
/* \file
|
|
|
|
*
|
|
|
|
* The player thread controls the playback. It acts as a bridge
|
|
|
|
* between the decoder thread and the output thread(s): it receives
|
|
|
|
* #MusicChunk objects from the decoder, optionally mixes them
|
|
|
|
* (cross-fading), applies software volume, and sends them to the
|
|
|
|
* audio outputs via audio_output_all_play().
|
|
|
|
*
|
|
|
|
* It is controlled by the main thread (the playlist code), see
|
|
|
|
* Control.hxx. The playlist enqueues new songs into the player
|
|
|
|
* thread and sends it commands.
|
|
|
|
*
|
|
|
|
* The player thread itself does not do any I/O. It synchronizes with
|
|
|
|
* other threads via #GMutex and #GCond objects, and passes
|
|
|
|
* #MusicChunk instances around in #MusicPipe objects.
|
|
|
|
*/
|
|
|
|
|
2009-11-12 09:12:38 +01:00
|
|
|
#include "config.h"
|
2018-09-21 17:14:19 +02:00
|
|
|
#include "Control.hxx"
|
2017-12-29 16:23:19 +01:00
|
|
|
#include "Outputs.hxx"
|
2015-08-15 15:55:46 +02:00
|
|
|
#include "Listener.hxx"
|
2018-09-21 16:56:53 +02:00
|
|
|
#include "decoder/Control.hxx"
|
2013-01-04 10:16:16 +01:00
|
|
|
#include "MusicPipe.hxx"
|
|
|
|
#include "MusicBuffer.hxx"
|
|
|
|
#include "MusicChunk.hxx"
|
2018-08-02 13:45:43 +02:00
|
|
|
#include "song/DetachedSong.hxx"
|
2013-01-04 10:31:59 +01:00
|
|
|
#include "CrossFade.hxx"
|
2013-09-05 18:22:02 +02:00
|
|
|
#include "tag/Tag.hxx"
|
2013-01-09 08:36:52 +01:00
|
|
|
#include "Idle.hxx"
|
2013-09-27 22:31:24 +02:00
|
|
|
#include "util/Domain.hxx"
|
2014-01-23 10:07:14 +01:00
|
|
|
#include "thread/Name.hxx"
|
2013-09-27 22:31:24 +02:00
|
|
|
#include "Log.hxx"
|
2008-08-26 08:27:09 +02:00
|
|
|
|
2017-12-19 10:56:23 +01:00
|
|
|
#include <exception>
|
2018-06-23 18:45:57 +02:00
|
|
|
#include <memory>
|
2016-11-09 12:31:23 +01:00
|
|
|
|
2013-07-30 20:11:57 +02:00
|
|
|
#include <string.h>
|
|
|
|
|
2013-09-27 22:31:24 +02:00
|
|
|
static constexpr Domain player_domain("player");
|
2008-12-29 17:29:14 +01:00
|
|
|
|
player/Thread: calculate `buffered_before_play` based on a fixed duration
Previously, there was the setting `buffered_before_play` which
specified a percentage of the audio buffer, defaulting to `10%`. That
was working well enough for quite some time, until high-quality audio
formats became common.
At 44.1 kHz, 16 bit stereo, MPD collected 2.3 seconds worth of data in
the buffer before starting playback. With the same default settings
and 192 kHz, 24 bit stereo, that was only 0.27 seconds.
Making this depend on the byte size only leads to high latency at low
quality, and too little data at high quality. The natural choice
would be to use a duration instead of a byte size, which should give
the same good experience with all audio formats.
Since the `buffered_before_play` configuration setting was not
understood well by users and caused more harm than good, this commit
deprecates it. It has now no effect.
2018-09-23 15:26:42 +02:00
|
|
|
/**
|
|
|
|
* Start playback as soon as enough data for this duration has been
|
|
|
|
* pushed to the decoder pipe.
|
|
|
|
*/
|
|
|
|
static constexpr auto buffer_before_play_duration = std::chrono::seconds(1);
|
|
|
|
|
2013-09-27 22:22:11 +02:00
|
|
|
class Player {
|
2013-10-28 10:12:21 +01:00
|
|
|
PlayerControl &pc;
|
2009-11-03 21:08:48 +01:00
|
|
|
|
2013-10-28 10:09:21 +01:00
|
|
|
DecoderControl &dc;
|
2009-10-31 19:22:56 +01:00
|
|
|
|
2013-09-26 22:45:49 +02:00
|
|
|
MusicBuffer &buffer;
|
|
|
|
|
2018-06-23 18:45:57 +02:00
|
|
|
std::shared_ptr<MusicPipe> pipe;
|
2009-03-06 00:42:03 +01:00
|
|
|
|
2017-12-20 18:43:56 +01:00
|
|
|
/**
|
|
|
|
* the song currently being played
|
|
|
|
*/
|
|
|
|
std::unique_ptr<DetachedSong> song;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The tag of the "next" song during cross-fade. It is
|
|
|
|
* postponed, and sent to the output thread when the new song
|
|
|
|
* really begins.
|
|
|
|
*/
|
|
|
|
std::unique_ptr<Tag> cross_fade_tag;
|
|
|
|
|
2018-09-23 15:23:42 +02:00
|
|
|
/**
|
|
|
|
* Start playback as soon as this number of chunks has been
|
player/Thread: calculate `buffered_before_play` based on a fixed duration
Previously, there was the setting `buffered_before_play` which
specified a percentage of the audio buffer, defaulting to `10%`. That
was working well enough for quite some time, until high-quality audio
formats became common.
At 44.1 kHz, 16 bit stereo, MPD collected 2.3 seconds worth of data in
the buffer before starting playback. With the same default settings
and 192 kHz, 24 bit stereo, that was only 0.27 seconds.
Making this depend on the byte size only leads to high latency at low
quality, and too little data at high quality. The natural choice
would be to use a duration instead of a byte size, which should give
the same good experience with all audio formats.
Since the `buffered_before_play` configuration setting was not
understood well by users and caused more harm than good, this commit
deprecates it. It has now no effect.
2018-09-23 15:26:42 +02:00
|
|
|
* pushed to the decoder pipe. This is calculated based on
|
|
|
|
* #buffer_before_play_duration.
|
2018-09-23 15:23:42 +02:00
|
|
|
*/
|
player/Thread: calculate `buffered_before_play` based on a fixed duration
Previously, there was the setting `buffered_before_play` which
specified a percentage of the audio buffer, defaulting to `10%`. That
was working well enough for quite some time, until high-quality audio
formats became common.
At 44.1 kHz, 16 bit stereo, MPD collected 2.3 seconds worth of data in
the buffer before starting playback. With the same default settings
and 192 kHz, 24 bit stereo, that was only 0.27 seconds.
Making this depend on the byte size only leads to high latency at low
quality, and too little data at high quality. The natural choice
would be to use a duration instead of a byte size, which should give
the same good experience with all audio formats.
Since the `buffered_before_play` configuration setting was not
understood well by users and caused more harm than good, this commit
deprecates it. It has now no effect.
2018-09-23 15:26:42 +02:00
|
|
|
unsigned buffer_before_play;
|
2018-09-23 15:23:42 +02:00
|
|
|
|
2018-09-22 19:56:00 +02:00
|
|
|
/**
|
|
|
|
* If the decoder pipe gets consumed below this threshold,
|
|
|
|
* it's time to wake up the decoder.
|
|
|
|
*
|
|
|
|
* It is calculated in a way which should prevent a wakeup
|
|
|
|
* after each single consumed chunk; it is more efficient to
|
|
|
|
* make the decoder decode a larger block at a time.
|
|
|
|
*/
|
|
|
|
const unsigned decoder_wakeup_threshold;
|
|
|
|
|
2008-10-12 00:02:23 +02:00
|
|
|
/**
|
2018-09-23 15:23:42 +02:00
|
|
|
* Are we waiting for #buffer_before_play?
|
2008-10-12 00:02:23 +02:00
|
|
|
*/
|
2017-12-20 13:35:07 +01:00
|
|
|
bool buffering = true;
|
2008-10-12 00:02:23 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* true if the decoder is starting and did not provide data
|
|
|
|
* yet
|
|
|
|
*/
|
2017-12-20 13:35:07 +01:00
|
|
|
bool decoder_starting = false;
|
2008-10-12 00:02:23 +02:00
|
|
|
|
2013-11-06 23:30:29 +01:00
|
|
|
/**
|
|
|
|
* Did we wake up the DecoderThread recently? This avoids
|
|
|
|
* duplicate wakeup calls.
|
|
|
|
*/
|
2017-12-20 13:35:07 +01:00
|
|
|
bool decoder_woken = false;
|
2013-11-06 23:30:29 +01:00
|
|
|
|
2008-10-12 00:02:23 +02:00
|
|
|
/**
|
|
|
|
* is the player paused?
|
|
|
|
*/
|
2017-12-20 13:35:07 +01:00
|
|
|
bool paused = false;
|
2008-10-12 00:02:23 +02:00
|
|
|
|
2008-10-12 00:07:54 +02:00
|
|
|
/**
|
|
|
|
* is there a new song in pc.next_song?
|
|
|
|
*/
|
2017-12-20 13:35:07 +01:00
|
|
|
bool queued = true;
|
2008-10-12 00:07:54 +02:00
|
|
|
|
2011-10-06 20:30:46 +02:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2017-12-20 13:35:07 +01:00
|
|
|
bool output_open = false;
|
2011-10-06 20:30:46 +02:00
|
|
|
|
2008-10-12 00:02:23 +02:00
|
|
|
/**
|
2015-10-27 21:12:20 +01:00
|
|
|
* Is cross-fading to the next song enabled?
|
2008-10-12 00:02:23 +02:00
|
|
|
*/
|
2015-10-27 21:05:10 +01:00
|
|
|
enum class CrossFadeState : uint8_t {
|
2015-10-27 21:12:20 +01:00
|
|
|
/**
|
|
|
|
* The initial state: we don't know yet if we will
|
|
|
|
* cross-fade; it will be determined soon.
|
|
|
|
*/
|
2015-10-27 21:05:10 +01:00
|
|
|
UNKNOWN,
|
2015-10-27 21:12:20 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Cross-fading is disabled for the transition to the
|
|
|
|
* next song.
|
|
|
|
*/
|
2015-10-27 21:05:10 +01:00
|
|
|
DISABLED,
|
2015-10-27 21:12:20 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Cross-fading is enabled (but may not yet be in
|
|
|
|
* progress), will start near the end of the current
|
|
|
|
* song.
|
|
|
|
*/
|
2015-10-27 21:05:10 +01:00
|
|
|
ENABLED,
|
2009-03-07 23:11:43 +01:00
|
|
|
|
2015-10-27 21:02:53 +01:00
|
|
|
/**
|
|
|
|
* Currently cross-fading to the next song.
|
|
|
|
*/
|
|
|
|
ACTIVE,
|
2017-12-20 13:35:07 +01:00
|
|
|
} xfade_state = CrossFadeState::UNKNOWN;
|
2009-03-09 19:14:06 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The number of chunks used for crossfading.
|
|
|
|
*/
|
2017-12-20 13:35:07 +01:00
|
|
|
unsigned cross_fade_chunks = 0;
|
2009-03-09 19:14:06 +01:00
|
|
|
|
2009-03-07 23:11:43 +01:00
|
|
|
/**
|
|
|
|
* The current audio format for the audio outputs.
|
|
|
|
*/
|
2017-08-23 17:43:49 +02:00
|
|
|
AudioFormat play_audio_format = AudioFormat::Undefined();
|
2009-10-30 16:28:15 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The time stamp of the chunk most recently sent to the
|
|
|
|
* output thread. This attribute is only used if
|
2014-01-27 08:20:25 +01:00
|
|
|
* MultipleOutputs::GetElapsedTime() didn't return a usable
|
2009-10-30 16:28:15 +01:00
|
|
|
* value; the output thread can estimate the elapsed time more
|
2011-03-31 21:43:53 +02:00
|
|
|
* precisely.
|
2009-10-30 16:28:15 +01:00
|
|
|
*/
|
2017-12-20 13:35:07 +01:00
|
|
|
SongTime elapsed_time = SongTime::zero();
|
2013-01-02 20:36:28 +01:00
|
|
|
|
2017-11-26 11:27:06 +01:00
|
|
|
/**
|
|
|
|
* If this is positive, then we need to ask the decoder to
|
|
|
|
* seek after it has completed startup. This is needed if the
|
|
|
|
* decoder is in the middle of startup while the player
|
|
|
|
* receives another seek command.
|
|
|
|
*
|
|
|
|
* This is only valid while #decoder_starting is true.
|
|
|
|
*/
|
|
|
|
SongTime pending_seek;
|
|
|
|
|
2013-09-27 22:22:11 +02:00
|
|
|
public:
|
2013-10-28 10:12:21 +01:00
|
|
|
Player(PlayerControl &_pc, DecoderControl &_dc,
|
2017-12-20 13:32:38 +01:00
|
|
|
MusicBuffer &_buffer) noexcept
|
2018-09-22 19:56:00 +02:00
|
|
|
:pc(_pc), dc(_dc), buffer(_buffer),
|
2018-09-23 15:00:47 +02:00
|
|
|
decoder_wakeup_threshold(buffer.GetSize() * 3 / 4)
|
2018-09-22 19:56:00 +02:00
|
|
|
{
|
|
|
|
}
|
2013-09-26 23:57:31 +02:00
|
|
|
|
2013-09-27 22:22:11 +02:00
|
|
|
private:
|
2015-10-27 22:05:41 +01:00
|
|
|
/**
|
|
|
|
* Reset cross-fading to the initial state. A check to
|
|
|
|
* re-enable it at an appropriate time will be scheduled.
|
|
|
|
*/
|
2017-12-20 13:32:38 +01:00
|
|
|
void ResetCrossFade() noexcept {
|
2015-10-27 22:05:41 +01:00
|
|
|
xfade_state = CrossFadeState::UNKNOWN;
|
|
|
|
}
|
|
|
|
|
2018-06-23 18:45:57 +02:00
|
|
|
template<typename P>
|
|
|
|
void ReplacePipe(P &&_pipe) noexcept {
|
2015-10-27 22:11:56 +01:00
|
|
|
ResetCrossFade();
|
2018-06-23 18:45:57 +02:00
|
|
|
pipe = std::forward<P>(_pipe);
|
2013-09-26 23:57:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Start the decoder.
|
|
|
|
*
|
2017-12-22 01:01:04 +01:00
|
|
|
* Caller must lock the mutex.
|
2013-09-26 23:57:31 +02:00
|
|
|
*/
|
2018-06-23 18:45:57 +02:00
|
|
|
void StartDecoder(std::shared_ptr<MusicPipe> pipe) noexcept;
|
2013-09-26 23:57:31 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The decoder has acknowledged the "START" command (see
|
2015-10-28 18:20:48 +01:00
|
|
|
* ActivateDecoder()). This function checks if the decoder
|
2017-12-20 13:27:13 +01:00
|
|
|
* initialization has completed yet. If not, it will wait
|
|
|
|
* some more.
|
2013-09-26 23:57:31 +02:00
|
|
|
*
|
2016-12-14 20:13:18 +01:00
|
|
|
* Caller must lock the mutex.
|
2017-12-20 13:27:13 +01:00
|
|
|
*
|
|
|
|
* @return false if the decoder has failed, true on success
|
|
|
|
* (though the decoder startup may or may not yet be finished)
|
2013-09-26 23:57:31 +02:00
|
|
|
*/
|
2017-12-20 13:32:38 +01:00
|
|
|
bool CheckDecoderStartup() noexcept;
|
2013-09-26 23:57:31 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Stop the decoder and clears (and frees) its music pipe.
|
|
|
|
*
|
2017-12-22 00:46:03 +01:00
|
|
|
* Caller must lock the mutex.
|
2013-09-26 23:57:31 +02:00
|
|
|
*/
|
2017-12-20 13:32:38 +01:00
|
|
|
void StopDecoder() noexcept;
|
2013-09-26 23:57:31 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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
|
2017-06-03 21:33:44 +02:00
|
|
|
bool IsDecoderAtCurrentSong() const noexcept {
|
2013-09-26 23:57:31 +02:00
|
|
|
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
|
2017-06-03 21:33:44 +02:00
|
|
|
bool IsDecoderAtNextSong() const noexcept {
|
2013-09-26 23:57:31 +02:00
|
|
|
return dc.pipe != nullptr && !IsDecoderAtCurrentSong();
|
|
|
|
}
|
|
|
|
|
2017-12-21 23:59:42 +01:00
|
|
|
/**
|
|
|
|
* Invoke DecoderControl::Seek() and update our state or
|
|
|
|
* handle errors.
|
|
|
|
*
|
|
|
|
* Caller must lock the mutex.
|
|
|
|
*
|
|
|
|
* @return false if the decoder has failed
|
|
|
|
*/
|
|
|
|
bool SeekDecoder(SongTime seek_time) noexcept;
|
|
|
|
|
2013-09-26 23:57:31 +02:00
|
|
|
/**
|
2013-09-27 22:07:20 +02:00
|
|
|
* This is the handler for the #PlayerCommand::SEEK command.
|
2013-09-26 23:57:31 +02:00
|
|
|
*
|
2017-12-22 01:05:48 +01:00
|
|
|
* Caller must lock the mutex.
|
2017-12-20 13:27:13 +01:00
|
|
|
*
|
|
|
|
* @return false if the decoder has failed
|
2013-09-26 23:57:31 +02:00
|
|
|
*/
|
2017-12-20 13:32:38 +01:00
|
|
|
bool SeekDecoder() noexcept;
|
2013-09-26 23:57:31 +02:00
|
|
|
|
2017-11-26 11:27:06 +01:00
|
|
|
void CancelPendingSeek() noexcept {
|
|
|
|
pending_seek = SongTime::zero();
|
2018-09-21 18:00:23 +02:00
|
|
|
pc.CancelPendingSeek();
|
2017-11-26 11:27:06 +01:00
|
|
|
}
|
|
|
|
|
2015-10-27 23:28:13 +01:00
|
|
|
/**
|
|
|
|
* Check if the decoder has reported an error, and forward it
|
|
|
|
* to PlayerControl::SetError().
|
|
|
|
*
|
|
|
|
* @return false if an error has occurred
|
|
|
|
*/
|
2017-12-20 13:32:38 +01:00
|
|
|
bool ForwardDecoderError() noexcept;
|
2015-10-27 23:28:13 +01:00
|
|
|
|
2013-09-26 23:57:31 +02:00
|
|
|
/**
|
2015-10-28 18:20:48 +01:00
|
|
|
* After the decoder has been started asynchronously, activate
|
|
|
|
* it for playback. That is, make the currently decoded song
|
|
|
|
* active (assign it to #song), clear PlayerControl::next_song
|
|
|
|
* and #queued, initialize #elapsed_time, and set
|
|
|
|
* #decoder_starting.
|
|
|
|
*
|
|
|
|
* When returning, the decoder may not have completed startup
|
|
|
|
* yet, therefore we don't know the audio format yet. To
|
|
|
|
* finish decoder startup, call CheckDecoderStartup().
|
2013-09-26 23:57:31 +02:00
|
|
|
*
|
2017-12-22 00:57:40 +01:00
|
|
|
* Caller must lock the mutex.
|
2013-09-26 23:57:31 +02:00
|
|
|
*/
|
2017-12-20 13:32:38 +01:00
|
|
|
void ActivateDecoder() noexcept;
|
2013-09-26 23:57:31 +02:00
|
|
|
|
|
|
|
/**
|
2014-01-27 08:20:25 +01:00
|
|
|
* Wrapper for MultipleOutputs::Open(). Upon failure, it
|
|
|
|
* pauses the player.
|
2013-09-26 23:57:31 +02:00
|
|
|
*
|
2016-12-14 20:23:23 +01:00
|
|
|
* Caller must lock the mutex.
|
|
|
|
*
|
2013-09-26 23:57:31 +02:00
|
|
|
* @return true on success
|
|
|
|
*/
|
2017-12-20 13:32:38 +01:00
|
|
|
bool OpenOutput() noexcept;
|
2013-09-26 23:57:31 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
*/
|
2017-12-20 13:32:38 +01:00
|
|
|
bool PlayNextChunk() noexcept;
|
2013-09-26 23:57:31 +02:00
|
|
|
|
2017-12-22 01:16:38 +01:00
|
|
|
unsigned UnlockCheckOutputs() noexcept {
|
|
|
|
const ScopeUnlock unlock(pc.mutex);
|
2017-12-29 16:23:19 +01:00
|
|
|
return pc.outputs.CheckPipe();
|
2017-12-22 01:16:38 +01:00
|
|
|
}
|
|
|
|
|
2013-09-26 23:57:31 +02:00
|
|
|
/**
|
|
|
|
* Player lock must be held before calling.
|
2017-12-28 08:30:01 +01:00
|
|
|
*
|
|
|
|
* @return false to stop playback
|
2013-09-26 23:57:31 +02:00
|
|
|
*/
|
2017-12-28 08:30:01 +01:00
|
|
|
bool ProcessCommand() noexcept;
|
2013-09-26 23:57:31 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*
|
2018-01-03 17:12:21 +01:00
|
|
|
* Caller must lock the mutex.
|
2013-09-26 23:57:31 +02:00
|
|
|
*/
|
2017-12-20 13:32:38 +01:00
|
|
|
void SongBorder() noexcept;
|
2013-09-26 23:57:31 +02:00
|
|
|
|
2013-09-27 22:22:11 +02:00
|
|
|
public:
|
2013-09-26 23:57:31 +02:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2017-12-20 13:32:38 +01:00
|
|
|
void Run() noexcept;
|
2008-10-12 00:02:23 +02:00
|
|
|
};
|
|
|
|
|
2013-09-26 23:57:31 +02:00
|
|
|
void
|
2018-06-23 18:45:57 +02:00
|
|
|
Player::StartDecoder(std::shared_ptr<MusicPipe> _pipe) noexcept
|
2009-11-03 21:01:56 +01:00
|
|
|
{
|
2013-09-27 22:07:20 +02:00
|
|
|
assert(queued || pc.command == PlayerCommand::SEEK);
|
2013-09-27 00:03:22 +02:00
|
|
|
assert(pc.next_song != nullptr);
|
2009-11-03 21:01:56 +01:00
|
|
|
|
2017-12-22 00:59:50 +01:00
|
|
|
/* copy ReplayGain parameters to the decoder */
|
|
|
|
dc.replay_gain_mode = pc.replay_gain_mode;
|
2016-11-25 12:51:55 +01:00
|
|
|
|
2015-11-05 00:29:03 +01:00
|
|
|
SongTime start_time = pc.next_song->GetStartTime() + pc.seek_time;
|
2011-10-05 22:13:13 +02:00
|
|
|
|
2017-11-26 12:11:07 +01:00
|
|
|
dc.Start(std::make_unique<DetachedSong>(*pc.next_song),
|
2014-08-28 13:04:45 +02:00
|
|
|
start_time, pc.next_song->GetEndTime(),
|
2018-06-23 18:45:57 +02:00
|
|
|
buffer, std::move(_pipe));
|
2009-11-03 21:01:56 +01:00
|
|
|
}
|
|
|
|
|
2013-09-26 23:57:31 +02:00
|
|
|
void
|
2017-12-20 13:32:38 +01:00
|
|
|
Player::StopDecoder() noexcept
|
2010-11-05 19:08:54 +01:00
|
|
|
{
|
2017-12-20 20:27:19 +01:00
|
|
|
const PlayerControl::ScopeOccupied occupied(pc);
|
|
|
|
|
2013-09-26 22:53:40 +02:00
|
|
|
dc.Stop();
|
2009-03-06 00:42:03 +01:00
|
|
|
|
2013-09-27 00:03:22 +02:00
|
|
|
if (dc.pipe != nullptr) {
|
2009-03-11 09:35:16 +01:00
|
|
|
/* clear and free the decoder pipe */
|
|
|
|
|
2017-12-30 17:24:58 +01:00
|
|
|
dc.pipe->Clear();
|
2018-06-23 18:45:57 +02:00
|
|
|
dc.pipe.reset();
|
2015-10-27 22:11:56 +01:00
|
|
|
|
|
|
|
/* just in case we've been cross-fading: cancel it
|
|
|
|
now, because we just deleted the new song's decoder
|
|
|
|
pipe */
|
|
|
|
ResetCrossFade();
|
2009-03-06 00:42:03 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-27 23:28:13 +01:00
|
|
|
bool
|
2017-12-20 13:32:38 +01:00
|
|
|
Player::ForwardDecoderError() noexcept
|
2015-10-27 23:28:13 +01:00
|
|
|
{
|
2016-09-08 17:14:11 +02:00
|
|
|
try {
|
|
|
|
dc.CheckRethrowError();
|
|
|
|
} catch (...) {
|
|
|
|
pc.SetError(PlayerError::DECODER, std::current_exception());
|
2015-10-27 23:28:13 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-10-28 18:24:42 +01:00
|
|
|
void
|
2017-12-20 13:32:38 +01:00
|
|
|
Player::ActivateDecoder() noexcept
|
2008-08-26 08:27:09 +02:00
|
|
|
{
|
2013-09-27 22:07:20 +02:00
|
|
|
assert(queued || pc.command == PlayerCommand::SEEK);
|
2013-09-27 00:03:22 +02:00
|
|
|
assert(pc.next_song != nullptr);
|
2009-11-03 21:02:54 +01:00
|
|
|
|
2013-09-26 23:57:31 +02:00
|
|
|
queued = false;
|
2009-11-03 21:02:54 +01:00
|
|
|
|
2017-12-22 00:57:40 +01:00
|
|
|
pc.ClearTaggedSong();
|
2013-10-21 23:22:16 +02:00
|
|
|
|
2017-12-22 00:57:40 +01:00
|
|
|
song = std::exchange(pc.next_song, nullptr);
|
2015-10-27 23:25:50 +01:00
|
|
|
|
2017-12-22 00:57:40 +01:00
|
|
|
elapsed_time = pc.seek_time;
|
2009-11-03 21:02:54 +01:00
|
|
|
|
2017-12-22 00:57:40 +01:00
|
|
|
/* set the "starting" flag, which will be cleared by
|
2017-12-27 14:26:14 +01:00
|
|
|
CheckDecoderStartup() */
|
2017-12-22 00:57:40 +01:00
|
|
|
decoder_starting = true;
|
2017-11-26 11:27:06 +01:00
|
|
|
pending_seek = SongTime::zero();
|
2009-11-03 21:02:54 +01:00
|
|
|
|
2017-12-22 00:57:40 +01:00
|
|
|
/* update PlayerControl's song information */
|
|
|
|
pc.total_time = song->GetDuration();
|
|
|
|
pc.bit_rate = 0;
|
|
|
|
pc.audio_format.Clear();
|
2008-10-12 00:07:54 +02:00
|
|
|
|
2017-12-22 00:57:40 +01:00
|
|
|
{
|
|
|
|
/* call syncPlaylistWithQueue() in the main thread */
|
|
|
|
const ScopeUnlock unlock(pc.mutex);
|
|
|
|
pc.listener.OnPlayerSync();
|
2016-12-14 12:54:37 +01:00
|
|
|
}
|
2008-08-26 08:27:09 +02:00
|
|
|
}
|
|
|
|
|
2009-12-25 23:12:10 +01:00
|
|
|
/**
|
|
|
|
* Returns the real duration of the song, comprising the duration
|
|
|
|
* indicated by the decoder plugin.
|
|
|
|
*/
|
2014-08-29 12:43:47 +02:00
|
|
|
static SignedSongTime
|
2017-12-20 13:32:38 +01:00
|
|
|
real_song_duration(const DetachedSong &song,
|
|
|
|
SignedSongTime decoder_duration) noexcept
|
2009-12-25 23:12:10 +01:00
|
|
|
{
|
2014-08-29 12:43:47 +02:00
|
|
|
if (decoder_duration.IsNegative())
|
2009-12-25 23:12:10 +01:00
|
|
|
/* the decoder plugin didn't provide information; fall
|
2013-07-28 13:25:12 +02:00
|
|
|
back to Song::GetDuration() */
|
2014-08-29 12:43:47 +02:00
|
|
|
return song.GetDuration();
|
2009-12-25 23:12:10 +01:00
|
|
|
|
2014-08-28 06:54:19 +02:00
|
|
|
const SongTime start_time = song.GetStartTime();
|
|
|
|
const SongTime end_time = song.GetEndTime();
|
2014-01-07 21:39:47 +01:00
|
|
|
|
2014-08-29 12:43:47 +02:00
|
|
|
if (end_time.IsPositive() && end_time < SongTime(decoder_duration))
|
|
|
|
return SignedSongTime(end_time - start_time);
|
2009-12-25 23:12:10 +01:00
|
|
|
|
2014-08-29 12:43:47 +02:00
|
|
|
return SignedSongTime(SongTime(decoder_duration) - start_time);
|
2009-12-25 23:12:10 +01:00
|
|
|
}
|
|
|
|
|
2013-09-26 23:57:31 +02:00
|
|
|
bool
|
2017-12-20 13:32:38 +01:00
|
|
|
Player::OpenOutput() noexcept
|
2011-10-06 20:55:52 +02:00
|
|
|
{
|
2013-09-26 23:57:31 +02:00
|
|
|
assert(play_audio_format.IsDefined());
|
2013-09-27 22:07:20 +02:00
|
|
|
assert(pc.state == PlayerState::PLAY ||
|
|
|
|
pc.state == PlayerState::PAUSE);
|
2011-10-06 20:55:52 +02:00
|
|
|
|
2016-11-09 12:31:23 +01:00
|
|
|
try {
|
2016-12-14 20:23:23 +01:00
|
|
|
const ScopeUnlock unlock(pc.mutex);
|
2018-06-23 18:04:09 +02:00
|
|
|
pc.outputs.Open(play_audio_format);
|
2017-12-19 10:56:23 +01:00
|
|
|
} catch (...) {
|
|
|
|
LogError(std::current_exception());
|
2012-08-08 22:47:51 +02:00
|
|
|
|
2013-09-26 23:57:31 +02:00
|
|
|
output_open = false;
|
2011-10-06 20:30:46 +02:00
|
|
|
|
2011-10-06 20:55:52 +02:00
|
|
|
/* pause: the user may resume playback as soon as an
|
|
|
|
audio output becomes available */
|
2013-09-26 23:57:31 +02:00
|
|
|
paused = true;
|
2011-10-06 20:55:52 +02:00
|
|
|
|
2016-12-14 20:23:23 +01:00
|
|
|
pc.SetOutputError(std::current_exception());
|
2011-10-06 20:55:52 +02:00
|
|
|
|
2013-02-04 10:15:34 +01:00
|
|
|
idle_add(IDLE_PLAYER);
|
|
|
|
|
2011-10-06 20:55:52 +02:00
|
|
|
return false;
|
|
|
|
}
|
2016-11-09 12:31:23 +01:00
|
|
|
|
|
|
|
output_open = true;
|
|
|
|
paused = false;
|
|
|
|
|
2016-12-14 20:23:23 +01:00
|
|
|
pc.state = PlayerState::PLAY;
|
2016-11-09 12:31:23 +01:00
|
|
|
|
|
|
|
idle_add(IDLE_PLAYER);
|
|
|
|
|
|
|
|
return true;
|
2011-10-06 20:55:52 +02:00
|
|
|
}
|
|
|
|
|
2013-09-26 23:57:31 +02:00
|
|
|
bool
|
2017-12-20 13:32:38 +01:00
|
|
|
Player::CheckDecoderStartup() noexcept
|
2009-03-07 23:11:43 +01:00
|
|
|
{
|
2013-09-26 23:57:31 +02:00
|
|
|
assert(decoder_starting);
|
2009-03-07 23:11:43 +01:00
|
|
|
|
2015-10-27 23:28:13 +01:00
|
|
|
if (!ForwardDecoderError()) {
|
2009-03-07 23:11:43 +01:00
|
|
|
/* the decoder failed */
|
|
|
|
return false;
|
2013-09-26 22:53:40 +02:00
|
|
|
} else if (!dc.IsStarting()) {
|
2009-03-07 23:11:43 +01:00
|
|
|
/* the decoder is ready and ok */
|
2009-03-09 19:25:26 +01:00
|
|
|
|
2013-09-26 23:57:31 +02:00
|
|
|
if (output_open &&
|
2016-12-14 20:13:18 +01:00
|
|
|
!pc.WaitOutputConsumed(1))
|
2009-03-09 19:25:26 +01:00
|
|
|
/* the output devices havn't finished playing
|
|
|
|
all chunks yet - wait for that */
|
|
|
|
return true;
|
|
|
|
|
2016-12-14 20:13:18 +01:00
|
|
|
pc.total_time = real_song_duration(*dc.song,
|
|
|
|
dc.total_time);
|
|
|
|
pc.audio_format = dc.in_audio_format;
|
2013-09-26 23:57:31 +02:00
|
|
|
play_audio_format = dc.out_audio_format;
|
|
|
|
decoder_starting = false;
|
2009-03-07 23:11:43 +01:00
|
|
|
|
player/Thread: calculate `buffered_before_play` based on a fixed duration
Previously, there was the setting `buffered_before_play` which
specified a percentage of the audio buffer, defaulting to `10%`. That
was working well enough for quite some time, until high-quality audio
formats became common.
At 44.1 kHz, 16 bit stereo, MPD collected 2.3 seconds worth of data in
the buffer before starting playback. With the same default settings
and 192 kHz, 24 bit stereo, that was only 0.27 seconds.
Making this depend on the byte size only leads to high latency at low
quality, and too little data at high quality. The natural choice
would be to use a duration instead of a byte size, which should give
the same good experience with all audio formats.
Since the `buffered_before_play` configuration setting was not
understood well by users and caused more harm than good, this commit
deprecates it. It has now no effect.
2018-09-23 15:26:42 +02:00
|
|
|
const size_t buffer_before_play_size =
|
|
|
|
play_audio_format.TimeToSize(buffer_before_play_duration);
|
|
|
|
buffer_before_play =
|
|
|
|
(buffer_before_play_size + sizeof(MusicChunk::data) - 1)
|
|
|
|
/ sizeof(MusicChunk::data);
|
|
|
|
|
2016-12-14 20:13:18 +01:00
|
|
|
idle_add(IDLE_PLAYER);
|
|
|
|
|
2017-11-26 11:27:06 +01:00
|
|
|
if (pending_seek > SongTime::zero()) {
|
|
|
|
assert(pc.seeking);
|
|
|
|
|
|
|
|
bool success = SeekDecoder(pending_seek);
|
|
|
|
pc.seeking = false;
|
|
|
|
pc.ClientSignal();
|
|
|
|
if (!success)
|
|
|
|
return false;
|
|
|
|
|
2017-12-30 11:31:26 +01:00
|
|
|
/* re-fill the buffer after seeking */
|
|
|
|
buffering = true;
|
|
|
|
} else if (pc.seeking) {
|
|
|
|
pc.seeking = false;
|
|
|
|
pc.ClientSignal();
|
|
|
|
|
2017-11-26 11:27:06 +01:00
|
|
|
/* re-fill the buffer after seeking */
|
|
|
|
buffering = true;
|
|
|
|
}
|
|
|
|
|
2013-09-26 23:57:31 +02:00
|
|
|
if (!paused && !OpenOutput()) {
|
2013-09-27 22:31:24 +02:00
|
|
|
FormatError(player_domain,
|
|
|
|
"problems opening audio device "
|
2014-01-07 21:39:47 +01:00
|
|
|
"while playing \"%s\"",
|
|
|
|
dc.song->GetURI());
|
2009-04-25 11:36:45 +02:00
|
|
|
return true;
|
|
|
|
}
|
2009-03-07 23:11:43 +01:00
|
|
|
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
/* the decoder is not yet ready; wait
|
|
|
|
some more */
|
2013-09-26 22:53:40 +02:00
|
|
|
dc.WaitForDecoder();
|
2009-03-07 23:11:43 +01:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-21 23:59:42 +01:00
|
|
|
bool
|
|
|
|
Player::SeekDecoder(SongTime seek_time) noexcept
|
|
|
|
{
|
|
|
|
assert(song);
|
|
|
|
assert(!decoder_starting);
|
|
|
|
|
|
|
|
if (!pc.total_time.IsNegative()) {
|
|
|
|
const SongTime total_time(pc.total_time);
|
|
|
|
if (seek_time > total_time)
|
|
|
|
seek_time = total_time;
|
|
|
|
}
|
|
|
|
|
|
|
|
try {
|
|
|
|
const PlayerControl::ScopeOccupied occupied(pc);
|
|
|
|
|
|
|
|
dc.Seek(song->GetStartTime() + seek_time);
|
|
|
|
} catch (...) {
|
|
|
|
/* decoder failure */
|
|
|
|
pc.SetError(PlayerError::DECODER, std::current_exception());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
elapsed_time = seek_time;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-09-26 23:57:31 +02:00
|
|
|
inline bool
|
2017-12-20 13:32:38 +01:00
|
|
|
Player::SeekDecoder() noexcept
|
2008-08-26 08:27:09 +02:00
|
|
|
{
|
2013-09-27 00:03:22 +02:00
|
|
|
assert(pc.next_song != nullptr);
|
2009-03-10 18:04:09 +01:00
|
|
|
|
2017-11-26 11:27:06 +01:00
|
|
|
CancelPendingSeek();
|
|
|
|
|
2017-12-22 01:05:48 +01:00
|
|
|
{
|
|
|
|
const ScopeUnlock unlock(pc.mutex);
|
|
|
|
pc.outputs.Cancel();
|
|
|
|
}
|
2017-12-22 01:04:44 +01:00
|
|
|
|
2018-10-29 23:06:32 +01:00
|
|
|
idle_add(IDLE_PLAYER);
|
2012-08-15 22:51:48 +02:00
|
|
|
|
2018-04-26 20:06:41 +02:00
|
|
|
if (!dc.IsSeekableCurrentSong(*pc.next_song)) {
|
2009-03-11 09:35:16 +01:00
|
|
|
/* the decoder is already decoding the "next" song -
|
|
|
|
stop it and start the previous song again */
|
|
|
|
|
2017-12-22 01:04:44 +01:00
|
|
|
StopDecoder();
|
2009-03-06 00:42:03 +01:00
|
|
|
|
2009-03-11 09:35:16 +01:00
|
|
|
/* clear music chunks which might still reside in the
|
|
|
|
pipe */
|
2017-12-30 17:24:58 +01:00
|
|
|
pipe->Clear();
|
2009-01-21 16:36:30 +01:00
|
|
|
|
2009-03-11 09:35:16 +01:00
|
|
|
/* re-start the decoder */
|
2018-06-23 18:45:57 +02:00
|
|
|
StartDecoder(pipe);
|
2015-10-28 18:24:42 +01:00
|
|
|
ActivateDecoder();
|
2015-11-05 00:41:54 +01:00
|
|
|
|
2017-12-30 11:31:26 +01:00
|
|
|
pc.seeking = true;
|
|
|
|
pc.CommandFinished();
|
|
|
|
|
|
|
|
assert(xfade_state == CrossFadeState::UNKNOWN);
|
|
|
|
|
|
|
|
return true;
|
2009-02-10 00:17:34 +01:00
|
|
|
} else {
|
2013-09-26 23:57:31 +02:00
|
|
|
if (!IsDecoderAtCurrentSong()) {
|
2010-11-05 19:24:42 +01:00
|
|
|
/* the decoder is already decoding the "next" song,
|
|
|
|
but it is the same song file; exchange the pipe */
|
2018-06-23 18:44:48 +02:00
|
|
|
ReplacePipe(dc.pipe);
|
2010-11-05 19:24:42 +01:00
|
|
|
}
|
|
|
|
|
2017-11-26 11:46:14 +01:00
|
|
|
pc.next_song.reset();
|
2013-09-26 23:57:31 +02:00
|
|
|
queued = false;
|
2008-08-26 08:27:18 +02:00
|
|
|
|
2017-11-26 11:27:06 +01:00
|
|
|
if (decoder_starting) {
|
|
|
|
/* wait for the decoder to complete
|
|
|
|
initialization; postpone the SEEK
|
|
|
|
command */
|
2009-03-11 09:35:16 +01:00
|
|
|
|
2017-11-26 11:27:06 +01:00
|
|
|
pending_seek = pc.seek_time;
|
|
|
|
pc.seeking = true;
|
2017-12-27 14:28:56 +01:00
|
|
|
pc.CommandFinished();
|
2017-11-26 11:27:06 +01:00
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
/* send the SEEK command */
|
|
|
|
|
|
|
|
if (!SeekDecoder(pc.seek_time)) {
|
|
|
|
pc.CommandFinished();
|
|
|
|
return false;
|
|
|
|
}
|
2017-12-27 14:28:56 +01:00
|
|
|
}
|
2015-11-05 00:41:54 +01:00
|
|
|
}
|
2009-10-30 16:28:15 +01:00
|
|
|
|
2017-12-22 01:04:44 +01:00
|
|
|
pc.CommandFinished();
|
2008-08-26 08:27:09 +02:00
|
|
|
|
2015-10-27 22:11:56 +01:00
|
|
|
assert(xfade_state == CrossFadeState::UNKNOWN);
|
2009-03-10 17:52:38 +01:00
|
|
|
|
2009-03-10 21:19:51 +01:00
|
|
|
/* re-fill the buffer after seeking */
|
2013-09-26 23:57:31 +02:00
|
|
|
buffering = true;
|
2009-03-10 17:52:38 +01:00
|
|
|
|
|
|
|
return true;
|
2008-08-26 08:27:09 +02:00
|
|
|
}
|
|
|
|
|
2017-12-28 08:30:01 +01:00
|
|
|
inline bool
|
2017-12-20 13:32:38 +01:00
|
|
|
Player::ProcessCommand() noexcept
|
2008-08-26 08:27:09 +02:00
|
|
|
{
|
2013-09-26 22:53:40 +02:00
|
|
|
switch (pc.command) {
|
2013-09-27 22:07:20 +02:00
|
|
|
case PlayerCommand::NONE:
|
2017-12-28 08:30:01 +01:00
|
|
|
break;
|
|
|
|
|
2013-09-27 22:07:20 +02:00
|
|
|
case PlayerCommand::STOP:
|
|
|
|
case PlayerCommand::EXIT:
|
|
|
|
case PlayerCommand::CLOSE_AUDIO:
|
2017-12-28 08:30:01 +01:00
|
|
|
return false;
|
2008-08-26 08:27:09 +02:00
|
|
|
|
2013-09-27 22:07:20 +02:00
|
|
|
case PlayerCommand::UPDATE_AUDIO:
|
2016-12-14 12:54:37 +01:00
|
|
|
{
|
|
|
|
const ScopeUnlock unlock(pc.mutex);
|
|
|
|
pc.outputs.EnableDisable();
|
|
|
|
}
|
|
|
|
|
2013-09-27 07:58:48 +02:00
|
|
|
pc.CommandFinished();
|
2009-10-23 10:55:52 +02:00
|
|
|
break;
|
|
|
|
|
2013-09-27 22:07:20 +02:00
|
|
|
case PlayerCommand::QUEUE:
|
2013-09-27 00:03:22 +02:00
|
|
|
assert(pc.next_song != nullptr);
|
2013-09-26 23:57:31 +02:00
|
|
|
assert(!queued);
|
|
|
|
assert(!IsDecoderAtNextSong());
|
2008-11-14 17:55:51 +01:00
|
|
|
|
2013-09-26 23:57:31 +02:00
|
|
|
queued = true;
|
2013-09-27 07:58:48 +02:00
|
|
|
pc.CommandFinished();
|
2015-06-21 15:38:48 +02:00
|
|
|
|
2017-12-22 01:01:04 +01:00
|
|
|
if (dc.IsIdle())
|
2018-06-23 18:45:57 +02:00
|
|
|
StartDecoder(std::make_shared<MusicPipe>());
|
2015-06-21 15:38:48 +02:00
|
|
|
|
2008-08-26 08:27:09 +02:00
|
|
|
break;
|
|
|
|
|
2013-09-27 22:07:20 +02:00
|
|
|
case PlayerCommand::PAUSE:
|
2013-09-26 23:57:31 +02:00
|
|
|
paused = !paused;
|
|
|
|
if (paused) {
|
2013-09-27 22:07:20 +02:00
|
|
|
pc.state = PlayerState::PAUSE;
|
2016-12-14 20:24:52 +01:00
|
|
|
|
|
|
|
const ScopeUnlock unlock(pc.mutex);
|
|
|
|
pc.outputs.Pause();
|
2013-09-26 23:57:31 +02:00
|
|
|
} else if (!play_audio_format.IsDefined()) {
|
2009-03-10 21:00:52 +01:00
|
|
|
/* the decoder hasn't provided an audio format
|
|
|
|
yet - don't open the audio device yet */
|
2013-09-27 22:07:20 +02:00
|
|
|
pc.state = PlayerState::PLAY;
|
2008-08-26 08:27:09 +02:00
|
|
|
} else {
|
2016-12-14 20:23:23 +01:00
|
|
|
OpenOutput();
|
2008-08-26 08:27:09 +02:00
|
|
|
}
|
2009-03-10 21:00:52 +01:00
|
|
|
|
2013-09-27 07:58:48 +02:00
|
|
|
pc.CommandFinished();
|
2008-08-26 08:27:09 +02:00
|
|
|
break;
|
|
|
|
|
2013-09-27 22:07:20 +02:00
|
|
|
case PlayerCommand::SEEK:
|
2017-12-28 08:30:01 +01:00
|
|
|
return SeekDecoder();
|
2008-10-12 00:07:54 +02:00
|
|
|
|
2013-09-27 22:07:20 +02:00
|
|
|
case PlayerCommand::CANCEL:
|
2017-12-28 08:30:01 +01:00
|
|
|
if (pc.next_song == nullptr)
|
2009-03-11 09:35:16 +01:00
|
|
|
/* the cancel request arrived too late, we're
|
2008-10-12 00:07:54 +02:00
|
|
|
already playing the queued song... stop
|
|
|
|
everything now */
|
2017-12-28 08:30:01 +01:00
|
|
|
return false;
|
2008-10-12 00:07:54 +02:00
|
|
|
|
2017-12-22 00:46:03 +01:00
|
|
|
if (IsDecoderAtNextSong())
|
2008-10-12 00:07:54 +02:00
|
|
|
/* the decoder is already decoding the song -
|
|
|
|
stop it and reset the position */
|
2013-09-26 23:57:31 +02:00
|
|
|
StopDecoder();
|
2008-10-12 00:07:54 +02:00
|
|
|
|
2017-11-26 11:46:14 +01:00
|
|
|
pc.next_song.reset();
|
2013-09-26 23:57:31 +02:00
|
|
|
queued = false;
|
2013-09-27 07:58:48 +02:00
|
|
|
pc.CommandFinished();
|
2008-10-12 00:07:54 +02:00
|
|
|
break;
|
2009-10-08 22:09:25 +02:00
|
|
|
|
2013-09-27 22:07:20 +02:00
|
|
|
case PlayerCommand::REFRESH:
|
2013-09-26 23:57:31 +02:00
|
|
|
if (output_open && !paused) {
|
2016-12-14 12:54:37 +01:00
|
|
|
const ScopeUnlock unlock(pc.mutex);
|
2017-12-29 16:23:19 +01:00
|
|
|
pc.outputs.CheckPipe();
|
2009-10-31 17:02:12 +01:00
|
|
|
}
|
2009-10-08 22:09:25 +02:00
|
|
|
|
2014-08-29 13:13:08 +02:00
|
|
|
pc.elapsed_time = !pc.outputs.GetElapsedTime().IsNegative()
|
|
|
|
? SongTime(pc.outputs.GetElapsedTime())
|
2014-08-29 13:07:38 +02:00
|
|
|
: elapsed_time;
|
2009-10-30 16:28:15 +01:00
|
|
|
|
2013-09-27 07:58:48 +02:00
|
|
|
pc.CommandFinished();
|
2009-10-08 22:09:25 +02:00
|
|
|
break;
|
2008-08-26 08:27:09 +02:00
|
|
|
}
|
2017-12-28 08:30:01 +01:00
|
|
|
|
|
|
|
return true;
|
2008-08-26 08:27:09 +02:00
|
|
|
}
|
|
|
|
|
2018-09-21 18:09:14 +02:00
|
|
|
inline void
|
|
|
|
PlayerControl::LockUpdateSongTag(DetachedSong &song,
|
|
|
|
const Tag &new_tag) noexcept
|
2009-07-23 12:26:26 +02:00
|
|
|
{
|
2014-01-08 00:36:59 +01:00
|
|
|
if (song.IsFile())
|
2009-07-23 12:26:26 +02:00
|
|
|
/* don't update tags of local files, only remote
|
|
|
|
streams may change tags dynamically */
|
|
|
|
return;
|
|
|
|
|
2014-01-07 21:39:47 +01:00
|
|
|
song.SetTag(new_tag);
|
2009-07-23 12:26:26 +02:00
|
|
|
|
2018-09-21 18:09:14 +02:00
|
|
|
LockSetTaggedSong(song);
|
2013-10-21 23:22:16 +02:00
|
|
|
|
2009-07-23 12:26:26 +02:00
|
|
|
/* the main thread will update the playlist version when he
|
|
|
|
receives this event */
|
2018-09-21 18:09:14 +02:00
|
|
|
listener.OnPlayerTagModified();
|
2009-07-23 12:26:26 +02:00
|
|
|
|
|
|
|
/* notify all clients that the tag of the current song has
|
|
|
|
changed */
|
|
|
|
idle_add(IDLE_PLAYER);
|
|
|
|
}
|
|
|
|
|
2018-09-21 18:09:14 +02:00
|
|
|
inline void
|
|
|
|
PlayerControl::PlayChunk(DetachedSong &song, MusicChunkPtr chunk,
|
|
|
|
const AudioFormat &format)
|
2008-08-26 08:27:09 +02:00
|
|
|
{
|
2013-08-03 21:00:50 +02:00
|
|
|
assert(chunk->CheckFormat(format));
|
2009-03-08 13:45:24 +01:00
|
|
|
|
2013-09-27 00:03:22 +02:00
|
|
|
if (chunk->tag != nullptr)
|
2018-09-21 18:09:14 +02:00
|
|
|
LockUpdateSongTag(song, *chunk->tag);
|
2008-11-02 17:13:26 +01:00
|
|
|
|
2017-12-30 18:00:40 +01:00
|
|
|
if (chunk->IsEmpty())
|
2016-11-09 12:31:23 +01:00
|
|
|
return;
|
2009-03-17 20:28:37 +01:00
|
|
|
|
2016-12-14 12:54:37 +01:00
|
|
|
{
|
2018-09-21 18:09:14 +02:00
|
|
|
const std::lock_guard<Mutex> lock(mutex);
|
|
|
|
bit_rate = chunk->bit_rate;
|
2016-12-14 12:54:37 +01:00
|
|
|
}
|
2009-03-17 20:28:37 +01:00
|
|
|
|
2009-03-11 09:35:16 +01:00
|
|
|
/* send the chunk to the audio outputs */
|
|
|
|
|
2017-12-30 18:00:40 +01:00
|
|
|
const double chunk_length(chunk->length);
|
|
|
|
|
2018-09-21 18:09:14 +02:00
|
|
|
outputs.Play(std::move(chunk));
|
2018-09-21 19:32:35 +02:00
|
|
|
total_play_time += format.SizeToTime<decltype(total_play_time)>(chunk_length);
|
2008-08-26 08:27:09 +02:00
|
|
|
}
|
|
|
|
|
2013-09-26 23:57:31 +02:00
|
|
|
inline bool
|
2017-12-20 13:32:38 +01:00
|
|
|
Player::PlayNextChunk() noexcept
|
2009-03-09 19:14:06 +01:00
|
|
|
{
|
2016-12-14 12:54:19 +01:00
|
|
|
if (!pc.LockWaitOutputConsumed(64))
|
2009-03-11 09:35:16 +01:00
|
|
|
/* the output pipe is still large enough, don't send
|
|
|
|
another chunk */
|
2009-03-09 19:25:26 +01:00
|
|
|
return true;
|
|
|
|
|
2015-10-27 21:02:53 +01:00
|
|
|
/* activate cross-fading? */
|
|
|
|
if (xfade_state == CrossFadeState::ENABLED &&
|
|
|
|
IsDecoderAtNextSong() &&
|
|
|
|
pipe->GetSize() <= cross_fade_chunks) {
|
|
|
|
/* beginning of the cross fade - adjust
|
|
|
|
cross_fade_chunks which might be bigger than the
|
|
|
|
remaining number of chunks in the old song */
|
|
|
|
cross_fade_chunks = pipe->GetSize();
|
|
|
|
xfade_state = CrossFadeState::ACTIVE;
|
|
|
|
}
|
|
|
|
|
2017-12-30 18:00:40 +01:00
|
|
|
MusicChunkPtr chunk;
|
2015-10-27 21:02:53 +01:00
|
|
|
if (xfade_state == CrossFadeState::ACTIVE) {
|
2009-03-09 19:14:06 +01:00
|
|
|
/* perform cross fade */
|
|
|
|
|
2015-10-27 21:02:53 +01:00
|
|
|
assert(IsDecoderAtNextSong());
|
|
|
|
|
|
|
|
unsigned cross_fade_position = pipe->GetSize();
|
|
|
|
assert(cross_fade_position <= cross_fade_chunks);
|
2009-03-09 19:14:06 +01:00
|
|
|
|
2017-12-30 18:00:40 +01:00
|
|
|
auto other_chunk = dc.pipe->Shift();
|
2013-09-27 00:03:22 +02:00
|
|
|
if (other_chunk != nullptr) {
|
2013-09-26 23:57:31 +02:00
|
|
|
chunk = pipe->Shift();
|
2013-09-27 00:03:22 +02:00
|
|
|
assert(chunk != nullptr);
|
|
|
|
assert(chunk->other == nullptr);
|
2009-03-09 19:14:06 +01:00
|
|
|
|
2010-03-17 21:57:35 +01:00
|
|
|
/* don't send the tags of the new song (which
|
|
|
|
is being faded in) yet; postpone it until
|
|
|
|
the current song is faded out */
|
2017-12-20 14:43:29 +01:00
|
|
|
cross_fade_tag = Tag::Merge(std::move(cross_fade_tag),
|
|
|
|
std::move(other_chunk->tag));
|
2010-03-17 21:57:35 +01:00
|
|
|
|
2018-09-22 19:24:34 +02:00
|
|
|
if (pc.cross_fade.mixramp_delay <= FloatDuration::zero()) {
|
2010-05-02 15:31:31 +02:00
|
|
|
chunk->mix_ratio = ((float)cross_fade_position)
|
2013-09-26 23:57:31 +02:00
|
|
|
/ cross_fade_chunks;
|
2010-03-21 18:21:47 +01:00
|
|
|
} else {
|
2013-10-30 17:23:49 +01:00
|
|
|
chunk->mix_ratio = -1;
|
2010-03-21 18:21:47 +01:00
|
|
|
}
|
2011-01-07 23:45:51 +01:00
|
|
|
|
2013-01-04 21:38:46 +01:00
|
|
|
if (other_chunk->IsEmpty()) {
|
2014-08-12 15:56:41 +02:00
|
|
|
/* the "other" chunk was a MusicChunk
|
2011-01-07 23:45:51 +01:00
|
|
|
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 */
|
2017-12-30 18:00:40 +01:00
|
|
|
other_chunk.reset();
|
2011-01-07 23:45:51 +01:00
|
|
|
}
|
2010-03-21 18:21:47 +01:00
|
|
|
|
2017-12-30 18:00:40 +01:00
|
|
|
chunk->other = std::move(other_chunk);
|
2009-03-09 19:14:06 +01:00
|
|
|
} else {
|
2009-03-11 09:35:16 +01:00
|
|
|
/* there are not enough decoded chunks yet */
|
2009-08-13 23:33:46 +02:00
|
|
|
|
2017-01-03 07:11:57 +01:00
|
|
|
const std::lock_guard<Mutex> lock(pc.mutex);
|
2009-08-13 23:33:46 +02:00
|
|
|
|
2013-09-26 22:53:40 +02:00
|
|
|
if (dc.IsIdle()) {
|
2009-03-11 09:35:16 +01:00
|
|
|
/* the decoder isn't running, abort
|
2009-03-09 19:14:06 +01:00
|
|
|
cross fading */
|
2013-09-27 22:19:26 +02:00
|
|
|
xfade_state = CrossFadeState::DISABLED;
|
2009-03-09 19:14:06 +01:00
|
|
|
} else {
|
2009-03-11 09:35:16 +01:00
|
|
|
/* wait for the decoder */
|
2013-09-26 22:53:40 +02:00
|
|
|
dc.Signal();
|
|
|
|
dc.WaitForDecoder();
|
2009-08-13 23:33:46 +02:00
|
|
|
|
2009-03-09 19:14:06 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-27 00:03:22 +02:00
|
|
|
if (chunk == nullptr)
|
2013-09-26 23:57:31 +02:00
|
|
|
chunk = pipe->Shift();
|
2009-03-09 19:14:06 +01:00
|
|
|
|
2013-09-27 00:03:22 +02:00
|
|
|
assert(chunk != nullptr);
|
2009-03-09 19:14:06 +01:00
|
|
|
|
2010-03-17 21:57:35 +01:00
|
|
|
/* insert the postponed tag if cross-fading is finished */
|
|
|
|
|
2015-10-27 21:02:53 +01:00
|
|
|
if (xfade_state != CrossFadeState::ACTIVE && cross_fade_tag != nullptr) {
|
2017-12-20 14:43:29 +01:00
|
|
|
chunk->tag = Tag::Merge(std::move(chunk->tag),
|
|
|
|
std::move(cross_fade_tag));
|
2013-09-26 23:57:31 +02:00
|
|
|
cross_fade_tag = nullptr;
|
2010-03-17 21:57:35 +01:00
|
|
|
}
|
|
|
|
|
2009-03-09 19:14:06 +01:00
|
|
|
/* play the current chunk */
|
|
|
|
|
2016-11-09 12:31:23 +01:00
|
|
|
try {
|
2018-09-21 18:09:14 +02:00
|
|
|
pc.PlayChunk(*song, std::move(chunk),
|
|
|
|
play_audio_format);
|
2017-12-19 10:56:23 +01:00
|
|
|
} catch (...) {
|
|
|
|
LogError(std::current_exception());
|
2012-08-08 22:47:51 +02:00
|
|
|
|
2017-12-30 18:00:40 +01:00
|
|
|
chunk.reset();
|
2009-04-25 11:55:36 +02:00
|
|
|
|
|
|
|
/* pause: the user may resume playback as soon as an
|
|
|
|
audio output becomes available */
|
2013-09-26 23:57:31 +02:00
|
|
|
paused = true;
|
2009-04-25 11:55:36 +02:00
|
|
|
|
2016-12-14 13:01:17 +01:00
|
|
|
pc.LockSetOutputError(std::current_exception());
|
2009-10-31 17:02:12 +01:00
|
|
|
|
2013-02-04 10:15:34 +01:00
|
|
|
idle_add(IDLE_PLAYER);
|
|
|
|
|
2009-03-09 19:14:06 +01:00
|
|
|
return false;
|
2009-03-09 19:25:26 +01:00
|
|
|
}
|
2009-03-09 19:14:06 +01:00
|
|
|
|
2017-01-03 07:11:57 +01:00
|
|
|
const std::lock_guard<Mutex> lock(pc.mutex);
|
2016-12-14 12:54:37 +01:00
|
|
|
|
2009-03-11 09:35:16 +01:00
|
|
|
/* this formula should prevent that the decoder gets woken up
|
|
|
|
with each chunk; it is more efficient to make it decode a
|
2009-03-09 19:14:06 +01:00
|
|
|
larger block at a time */
|
2018-09-22 19:56:00 +02:00
|
|
|
if (!dc.IsIdle() && dc.pipe->GetSize() <= decoder_wakeup_threshold) {
|
2013-11-06 23:30:29 +01:00
|
|
|
if (!decoder_woken) {
|
|
|
|
decoder_woken = true;
|
|
|
|
dc.Signal();
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
decoder_woken = false;
|
2009-03-09 19:14:06 +01:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-10-28 18:24:42 +01:00
|
|
|
inline void
|
2017-12-20 13:32:38 +01:00
|
|
|
Player::SongBorder() noexcept
|
2009-03-09 19:15:14 +01:00
|
|
|
{
|
2018-01-03 17:12:21 +01:00
|
|
|
{
|
|
|
|
const ScopeUnlock unlock(pc.mutex);
|
2009-07-06 22:29:58 +02:00
|
|
|
|
2018-01-03 17:12:21 +01:00
|
|
|
FormatDefault(player_domain, "played \"%s\"", song->GetURI());
|
2017-10-25 20:26:09 +02:00
|
|
|
|
2018-01-03 17:12:21 +01:00
|
|
|
ReplacePipe(dc.pipe);
|
2010-01-02 21:16:51 +01:00
|
|
|
|
2018-01-03 17:12:21 +01:00
|
|
|
pc.outputs.SongBorder();
|
2017-12-22 00:57:40 +01:00
|
|
|
}
|
2009-03-09 19:25:26 +01:00
|
|
|
|
2018-01-03 17:12:21 +01:00
|
|
|
ActivateDecoder();
|
|
|
|
|
|
|
|
const bool border_pause = pc.ApplyBorderPause();
|
2013-02-04 10:15:34 +01:00
|
|
|
if (border_pause) {
|
2013-09-26 23:57:31 +02:00
|
|
|
paused = true;
|
2018-02-05 17:13:00 +01:00
|
|
|
pc.listener.OnBorderPause();
|
2018-05-12 14:44:07 +02:00
|
|
|
pc.outputs.Pause();
|
2013-02-04 10:15:34 +01:00
|
|
|
idle_add(IDLE_PLAYER);
|
2016-12-14 13:09:48 +01:00
|
|
|
}
|
2009-03-09 19:15:14 +01:00
|
|
|
}
|
|
|
|
|
2013-09-26 23:57:31 +02:00
|
|
|
inline void
|
2017-12-20 13:32:38 +01:00
|
|
|
Player::Run() noexcept
|
2008-08-26 08:27:09 +02:00
|
|
|
{
|
2018-06-23 18:45:57 +02:00
|
|
|
pipe = std::make_shared<MusicPipe>();
|
2008-08-26 08:27:09 +02:00
|
|
|
|
2017-12-22 01:16:38 +01:00
|
|
|
const std::lock_guard<Mutex> lock(pc.mutex);
|
2017-12-22 01:01:04 +01:00
|
|
|
|
2018-06-23 18:45:57 +02:00
|
|
|
StartDecoder(pipe);
|
2015-10-28 18:24:42 +01:00
|
|
|
ActivateDecoder();
|
2008-08-26 08:27:09 +02:00
|
|
|
|
2013-09-27 22:07:20 +02:00
|
|
|
pc.state = PlayerState::PLAY;
|
2011-10-05 22:13:13 +02:00
|
|
|
|
2013-09-27 07:58:48 +02:00
|
|
|
pc.CommandFinished();
|
2008-08-26 08:27:09 +02:00
|
|
|
|
2018-09-21 18:58:38 +02:00
|
|
|
while (ProcessCommand()) {
|
2013-09-26 23:57:31 +02:00
|
|
|
if (buffering) {
|
2009-03-11 09:35:16 +01:00
|
|
|
/* buffering at the start of the song - wait
|
|
|
|
until the buffer is large enough, to
|
|
|
|
prevent stuttering on slow machines */
|
|
|
|
|
2018-09-23 15:23:42 +02:00
|
|
|
if (pipe->GetSize() < buffer_before_play &&
|
2018-09-21 19:05:25 +02:00
|
|
|
!dc.IsIdle() && !buffer.IsFull()) {
|
2008-08-26 08:27:09 +02:00
|
|
|
/* not enough decoded buffer space yet */
|
2009-03-10 21:19:51 +01:00
|
|
|
|
2013-09-26 22:53:40 +02:00
|
|
|
dc.WaitForDecoder();
|
2008-08-26 08:27:09 +02:00
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
/* buffering is complete */
|
2013-09-26 23:57:31 +02:00
|
|
|
buffering = false;
|
2008-08-26 08:27:09 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-26 23:57:31 +02:00
|
|
|
if (decoder_starting) {
|
2009-03-11 09:35:16 +01:00
|
|
|
/* wait until the decoder is initialized completely */
|
2008-10-29 22:17:42 +01:00
|
|
|
|
2017-12-22 01:16:38 +01:00
|
|
|
if (!CheckDecoderStartup())
|
2009-03-07 23:11:43 +01:00
|
|
|
break;
|
2009-10-31 17:02:12 +01:00
|
|
|
|
2009-03-07 23:11:43 +01:00
|
|
|
continue;
|
2008-08-26 08:27:09 +02:00
|
|
|
}
|
|
|
|
|
2017-12-22 01:13:01 +01:00
|
|
|
if (dc.IsIdle() && queued && dc.pipe == pipe) {
|
2008-08-26 08:27:09 +02:00
|
|
|
/* the decoder has finished the current song;
|
|
|
|
make it decode the next song */
|
2008-10-12 00:07:54 +02:00
|
|
|
|
2013-09-27 00:03:22 +02:00
|
|
|
assert(dc.pipe == nullptr || dc.pipe == pipe);
|
2008-10-12 00:07:54 +02:00
|
|
|
|
2018-06-23 18:45:57 +02:00
|
|
|
StartDecoder(std::make_shared<MusicPipe>());
|
2008-08-26 08:27:09 +02:00
|
|
|
}
|
2009-03-06 00:42:03 +01:00
|
|
|
|
2012-08-25 08:44:31 +02:00
|
|
|
if (/* no cross-fading if MPD is going to pause at the
|
|
|
|
end of the current song */
|
2013-09-26 22:53:40 +02:00
|
|
|
!pc.border_pause &&
|
2013-09-26 23:57:31 +02:00
|
|
|
IsDecoderAtNextSong() &&
|
2013-09-27 22:19:26 +02:00
|
|
|
xfade_state == CrossFadeState::UNKNOWN &&
|
2017-12-22 01:13:01 +01:00
|
|
|
!dc.IsStarting()) {
|
2008-08-26 08:27:09 +02:00
|
|
|
/* enable cross fading in this song? if yes,
|
|
|
|
calculate how many chunks will be required
|
|
|
|
for it */
|
2013-09-26 23:57:31 +02:00
|
|
|
cross_fade_chunks =
|
2014-08-29 23:41:34 +02:00
|
|
|
pc.cross_fade.Calculate(dc.total_time,
|
2013-10-29 00:14:27 +01:00
|
|
|
dc.replay_gain_db,
|
|
|
|
dc.replay_gain_prev_db,
|
|
|
|
dc.GetMixRampStart(),
|
|
|
|
dc.GetMixRampPreviousEnd(),
|
|
|
|
dc.out_audio_format,
|
|
|
|
play_audio_format,
|
|
|
|
buffer.GetSize() -
|
2018-09-23 15:23:42 +02:00
|
|
|
buffer_before_play);
|
2015-10-27 21:02:53 +01:00
|
|
|
if (cross_fade_chunks > 0)
|
2013-09-27 22:19:26 +02:00
|
|
|
xfade_state = CrossFadeState::ENABLED;
|
2015-10-27 21:02:53 +01:00
|
|
|
else
|
2008-08-26 08:27:09 +02:00
|
|
|
/* cross fading is disabled or the
|
|
|
|
next song is too short */
|
2013-09-27 22:19:26 +02:00
|
|
|
xfade_state = CrossFadeState::DISABLED;
|
2008-08-26 08:27:09 +02:00
|
|
|
}
|
|
|
|
|
2013-09-26 23:57:31 +02:00
|
|
|
if (paused) {
|
2013-09-27 22:07:20 +02:00
|
|
|
if (pc.command == PlayerCommand::NONE)
|
2013-09-26 22:53:40 +02:00
|
|
|
pc.Wait();
|
2013-09-26 23:57:31 +02:00
|
|
|
} else if (!pipe->IsEmpty()) {
|
2009-03-09 19:14:06 +01:00
|
|
|
/* at least one music chunk is ready - send it
|
|
|
|
to the audio output */
|
2009-03-06 00:42:03 +01:00
|
|
|
|
2017-12-22 01:16:38 +01:00
|
|
|
const ScopeUnlock unlock(pc.mutex);
|
2013-09-26 23:57:31 +02:00
|
|
|
PlayNextChunk();
|
2017-12-22 01:16:38 +01:00
|
|
|
} else if (UnlockCheckOutputs() > 0) {
|
2009-03-09 19:25:26 +01:00
|
|
|
/* not enough data from decoder, but the
|
|
|
|
output thread is still busy, so it's
|
|
|
|
okay */
|
|
|
|
|
2013-11-08 11:54:30 +01:00
|
|
|
/* wake up the decoder (just in case it's
|
|
|
|
waiting for space in the MusicBuffer) and
|
|
|
|
wait for it */
|
2018-01-12 14:30:40 +01:00
|
|
|
// TODO: eliminate this kludge
|
2013-11-08 11:54:30 +01:00
|
|
|
dc.Signal();
|
2018-01-12 14:30:40 +01:00
|
|
|
|
2013-11-08 11:54:30 +01:00
|
|
|
dc.WaitForDecoder();
|
2013-09-26 23:57:31 +02:00
|
|
|
} else if (IsDecoderAtNextSong()) {
|
2008-08-26 08:27:09 +02:00
|
|
|
/* at the beginning of a new song */
|
|
|
|
|
2015-10-28 18:24:42 +01:00
|
|
|
SongBorder();
|
2017-12-22 01:16:38 +01:00
|
|
|
} else if (dc.IsIdle()) {
|
2009-06-02 08:39:17 +02:00
|
|
|
/* check the size of the pipe again, because
|
|
|
|
the decoder thread may have added something
|
|
|
|
since we last checked */
|
2013-09-26 23:57:31 +02:00
|
|
|
if (pipe->IsEmpty()) {
|
2009-11-09 22:22:27 +01:00
|
|
|
/* wait for the hardware to finish
|
|
|
|
playback */
|
2017-12-22 01:16:38 +01:00
|
|
|
const ScopeUnlock unlock(pc.mutex);
|
2014-01-27 08:20:25 +01:00
|
|
|
pc.outputs.Drain();
|
2009-06-02 08:39:17 +02:00
|
|
|
break;
|
2009-11-09 22:22:27 +01:00
|
|
|
}
|
2013-09-26 23:57:31 +02:00
|
|
|
} else if (output_open) {
|
2009-03-09 19:25:26 +01:00
|
|
|
/* the decoder is too busy and hasn't provided
|
2018-01-02 22:03:38 +01:00
|
|
|
new PCM data in time: wait for the
|
|
|
|
decoder */
|
2017-10-25 20:26:09 +02:00
|
|
|
|
2018-01-12 14:30:40 +01:00
|
|
|
/* wake up the decoder (just in case it's
|
|
|
|
waiting for space in the MusicBuffer) and
|
|
|
|
wait for it */
|
|
|
|
// TODO: eliminate this kludge
|
|
|
|
dc.Signal();
|
|
|
|
|
2018-01-02 22:03:38 +01:00
|
|
|
dc.WaitForDecoder();
|
2008-08-26 08:27:09 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-26 11:27:06 +01:00
|
|
|
CancelPendingSeek();
|
2013-09-26 23:57:31 +02:00
|
|
|
StopDecoder();
|
2009-03-06 00:42:03 +01:00
|
|
|
|
2018-06-23 18:45:57 +02:00
|
|
|
pipe.reset();
|
2009-03-11 09:20:34 +01:00
|
|
|
|
2017-12-20 14:43:29 +01:00
|
|
|
cross_fade_tag.reset();
|
2010-03-17 21:57:35 +01:00
|
|
|
|
2013-12-24 11:58:10 +01:00
|
|
|
if (song != nullptr) {
|
2014-01-07 21:39:47 +01:00
|
|
|
FormatDefault(player_domain, "played \"%s\"", song->GetURI());
|
2017-11-26 11:46:14 +01:00
|
|
|
song.reset();
|
2013-12-24 11:58:10 +01:00
|
|
|
}
|
2012-08-09 22:19:39 +02:00
|
|
|
|
2013-10-21 23:22:16 +02:00
|
|
|
pc.ClearTaggedSong();
|
|
|
|
|
2013-09-26 23:57:31 +02:00
|
|
|
if (queued) {
|
2013-09-27 00:03:22 +02:00
|
|
|
assert(pc.next_song != nullptr);
|
2017-11-26 11:46:14 +01:00
|
|
|
pc.next_song.reset();
|
2009-11-03 23:32:37 +01:00
|
|
|
}
|
|
|
|
|
2013-09-27 22:07:20 +02:00
|
|
|
pc.state = PlayerState::STOP;
|
2008-08-26 08:27:09 +02:00
|
|
|
}
|
|
|
|
|
2013-09-26 23:57:31 +02:00
|
|
|
static void
|
2013-10-28 10:12:21 +01:00
|
|
|
do_play(PlayerControl &pc, DecoderControl &dc,
|
2017-12-20 13:32:38 +01:00
|
|
|
MusicBuffer &buffer) noexcept
|
2013-09-26 23:57:31 +02:00
|
|
|
{
|
2013-09-27 22:22:11 +02:00
|
|
|
Player player(pc, dc, buffer);
|
2013-09-26 23:57:31 +02:00
|
|
|
player.Run();
|
|
|
|
}
|
|
|
|
|
2017-02-10 22:41:11 +01:00
|
|
|
void
|
2017-11-26 12:02:08 +01:00
|
|
|
PlayerControl::RunThread() noexcept
|
2018-09-21 17:35:32 +02:00
|
|
|
try {
|
2014-01-23 10:07:14 +01:00
|
|
|
SetThreadName("player");
|
|
|
|
|
2017-02-10 22:41:11 +01:00
|
|
|
DecoderControl dc(mutex, cond,
|
|
|
|
configured_audio_format,
|
|
|
|
replay_gain_config);
|
2018-09-21 16:57:54 +02:00
|
|
|
dc.StartThread();
|
2009-01-25 13:44:39 +01:00
|
|
|
|
2017-02-10 22:41:11 +01:00
|
|
|
MusicBuffer buffer(buffer_chunks);
|
2009-03-09 19:12:06 +01:00
|
|
|
|
2017-12-22 09:35:31 +01:00
|
|
|
const std::lock_guard<Mutex> lock(mutex);
|
2009-10-31 17:02:12 +01:00
|
|
|
|
2008-08-26 08:27:09 +02:00
|
|
|
while (1) {
|
2017-02-10 22:41:11 +01:00
|
|
|
switch (command) {
|
2013-09-27 22:07:20 +02:00
|
|
|
case PlayerCommand::SEEK:
|
|
|
|
case PlayerCommand::QUEUE:
|
2017-02-10 22:41:11 +01:00
|
|
|
assert(next_song != nullptr);
|
2009-02-10 08:18:28 +01:00
|
|
|
|
2017-12-22 09:35:31 +01:00
|
|
|
{
|
|
|
|
const ScopeUnlock unlock(mutex);
|
|
|
|
do_play(*this, dc, buffer);
|
|
|
|
listener.OnPlayerSync();
|
|
|
|
}
|
|
|
|
|
2008-08-26 08:27:09 +02:00
|
|
|
break;
|
|
|
|
|
2013-09-27 22:07:20 +02:00
|
|
|
case PlayerCommand::STOP:
|
2017-12-22 09:35:31 +01:00
|
|
|
{
|
|
|
|
const ScopeUnlock unlock(mutex);
|
|
|
|
outputs.Cancel();
|
|
|
|
}
|
2009-10-31 17:02:12 +01:00
|
|
|
|
2009-03-09 19:25:26 +01:00
|
|
|
/* fall through */
|
|
|
|
|
2013-09-27 22:07:20 +02:00
|
|
|
case PlayerCommand::PAUSE:
|
2017-11-26 11:46:14 +01:00
|
|
|
next_song.reset();
|
2012-08-09 22:19:39 +02:00
|
|
|
|
2017-02-10 22:41:11 +01:00
|
|
|
CommandFinished();
|
2008-08-26 08:27:09 +02:00
|
|
|
break;
|
|
|
|
|
2013-09-27 22:07:20 +02:00
|
|
|
case PlayerCommand::CLOSE_AUDIO:
|
2017-12-22 09:35:31 +01:00
|
|
|
{
|
|
|
|
const ScopeUnlock unlock(mutex);
|
|
|
|
outputs.Release();
|
|
|
|
}
|
2009-10-31 17:02:12 +01:00
|
|
|
|
2017-02-10 22:41:11 +01:00
|
|
|
CommandFinished();
|
2009-05-29 23:34:51 +02:00
|
|
|
|
2013-09-26 22:45:49 +02:00
|
|
|
assert(buffer.IsEmptyUnsafe());
|
2009-05-29 23:34:51 +02:00
|
|
|
|
2008-08-26 08:27:09 +02:00
|
|
|
break;
|
|
|
|
|
2013-09-27 22:07:20 +02:00
|
|
|
case PlayerCommand::UPDATE_AUDIO:
|
2017-12-22 09:35:31 +01:00
|
|
|
{
|
|
|
|
const ScopeUnlock unlock(mutex);
|
|
|
|
outputs.EnableDisable();
|
|
|
|
}
|
|
|
|
|
2017-02-10 22:41:11 +01:00
|
|
|
CommandFinished();
|
2009-10-23 10:55:52 +02:00
|
|
|
break;
|
|
|
|
|
2013-09-27 22:07:20 +02:00
|
|
|
case PlayerCommand::EXIT:
|
2017-12-22 09:35:31 +01:00
|
|
|
{
|
|
|
|
const ScopeUnlock unlock(mutex);
|
|
|
|
dc.Quit();
|
|
|
|
outputs.Close();
|
|
|
|
}
|
2009-10-31 17:02:12 +01:00
|
|
|
|
2017-12-22 09:35:31 +01:00
|
|
|
CommandFinished();
|
2013-10-17 18:42:14 +02:00
|
|
|
return;
|
2008-08-26 08:27:16 +02:00
|
|
|
|
2013-09-27 22:07:20 +02:00
|
|
|
case PlayerCommand::CANCEL:
|
2017-11-26 11:46:14 +01:00
|
|
|
next_song.reset();
|
2012-08-09 22:19:39 +02:00
|
|
|
|
2017-02-10 22:41:11 +01:00
|
|
|
CommandFinished();
|
2008-08-26 08:27:09 +02:00
|
|
|
break;
|
|
|
|
|
2013-09-27 22:07:20 +02:00
|
|
|
case PlayerCommand::REFRESH:
|
2009-10-08 22:09:25 +02:00
|
|
|
/* no-op when not playing */
|
2017-02-10 22:41:11 +01:00
|
|
|
CommandFinished();
|
2009-10-08 22:09:25 +02:00
|
|
|
break;
|
|
|
|
|
2013-09-27 22:07:20 +02:00
|
|
|
case PlayerCommand::NONE:
|
2017-02-10 22:41:11 +01:00
|
|
|
Wait();
|
2008-08-26 08:27:09 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2018-09-21 17:35:32 +02:00
|
|
|
} catch (...) {
|
|
|
|
/* exceptions caught here are thrown during initialization;
|
|
|
|
the main loop doesn't throw */
|
|
|
|
|
|
|
|
LogError(std::current_exception());
|
|
|
|
|
|
|
|
/* TODO: what now? How will the main thread learn about this
|
|
|
|
failure? */
|
2008-08-26 08:27:09 +02:00
|
|
|
}
|