mpd/src/decoder/DecoderThread.cxx

577 lines
14 KiB
C++
Raw Normal View History

/*
2017-01-03 20:48:59 +01:00
* Copyright 2003-2017 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 "DecoderThread.hxx"
2013-01-04 08:41:16 +01:00
#include "DecoderControl.hxx"
#include "Bridge.hxx"
2013-07-28 13:18:48 +02:00
#include "DecoderError.hxx"
#include "DecoderPlugin.hxx"
#include "DetachedSong.hxx"
#include "MusicPipe.hxx"
#include "fs/Traits.hxx"
#include "fs/AllocatedPath.hxx"
2013-07-28 13:18:48 +02:00
#include "DecoderAPI.hxx"
2014-01-24 16:18:21 +01:00
#include "input/InputStream.hxx"
#include "input/LocalOpen.hxx"
2013-01-30 17:18:48 +01:00
#include "DecoderList.hxx"
#include "system/Error.hxx"
#include "util/MimeType.hxx"
2013-04-08 23:30:21 +02:00
#include "util/UriUtil.hxx"
#include "util/RuntimeError.hxx"
#include "util/Domain.hxx"
#include "util/ScopeExit.hxx"
#include "thread/Name.hxx"
#include "tag/ApeReplayGain.hxx"
#include "Log.hxx"
#include <stdexcept>
#include <functional>
#include <memory>
static constexpr Domain decoder_thread_domain("decoder_thread");
/**
* Opens the input stream with InputStream::Open(), and waits until
* the stream gets ready.
*
* Unlock the decoder before calling this function.
*/
static InputStreamPtr
decoder_input_stream_open(DecoderControl &dc, const char *uri)
{
auto is = InputStream::Open(uri, dc.mutex, dc.cond);
/* wait for the input stream to become ready; its metadata
will be available then */
const std::lock_guard<Mutex> protect(dc.mutex);
is->Update();
while (!is->IsReady()) {
if (dc.command == DecoderCommand::STOP)
throw StopDecoder();
2013-10-19 18:48:38 +02:00
dc.Wait();
is->Update();
}
is->Check();
return is;
}
static InputStreamPtr
decoder_input_stream_open(DecoderControl &dc, Path path)
{
auto is = OpenLocalInputStream(path, dc.mutex, dc.cond);
assert(is->IsReady());
return is;
}
2015-12-31 12:24:57 +01:00
/**
* Decode a stream with the given decoder plugin.
*
* Caller holds DecoderControl::mutex.
*/
static bool
decoder_stream_decode(const DecoderPlugin &plugin,
DecoderBridge &bridge,
InputStream &input_stream)
{
2013-10-19 18:48:38 +02:00
assert(plugin.stream_decode != nullptr);
assert(bridge.stream_tag == nullptr);
assert(bridge.decoder_tag == nullptr);
2014-05-11 15:34:48 +02:00
assert(input_stream.IsReady());
assert(bridge.dc.state == DecoderState::START);
2013-10-19 18:48:38 +02:00
FormatDebug(decoder_thread_domain, "probing plugin %s", plugin.name);
if (bridge.dc.command == DecoderCommand::STOP)
throw StopDecoder();
/* rewind the stream, so each plugin gets a fresh start */
try {
input_stream.Rewind();
} catch (...) {
}
{
const ScopeUnlock unlock(bridge.dc.mutex);
FormatThreadName("decoder:%s", plugin.name);
plugin.StreamDecode(bridge, input_stream);
SetThreadName("decoder");
}
assert(bridge.dc.state == DecoderState::START ||
bridge.dc.state == DecoderState::DECODE);
return bridge.dc.state != DecoderState::START;
}
2015-12-31 12:24:57 +01:00
/**
* Decode a file with the given decoder plugin.
*
* Caller holds DecoderControl::mutex.
*/
static bool
decoder_file_decode(const DecoderPlugin &plugin,
DecoderBridge &bridge, Path path)
{
2013-10-19 18:48:38 +02:00
assert(plugin.file_decode != nullptr);
assert(bridge.stream_tag == nullptr);
assert(bridge.decoder_tag == nullptr);
assert(!path.IsNull());
assert(path.IsAbsolute());
assert(bridge.dc.state == DecoderState::START);
2013-10-19 18:48:38 +02:00
FormatDebug(decoder_thread_domain, "probing plugin %s", plugin.name);
if (bridge.dc.command == DecoderCommand::STOP)
throw StopDecoder();
{
const ScopeUnlock unlock(bridge.dc.mutex);
FormatThreadName("decoder:%s", plugin.name);
plugin.FileDecode(bridge, path);
SetThreadName("decoder");
}
assert(bridge.dc.state == DecoderState::START ||
bridge.dc.state == DecoderState::DECODE);
return bridge.dc.state != DecoderState::START;
}
gcc_pure
static bool
decoder_check_plugin_mime(const DecoderPlugin &plugin,
const InputStream &is) noexcept
{
assert(plugin.stream_decode != nullptr);
2014-05-11 15:34:48 +02:00
const char *mime_type = is.GetMimeType();
return mime_type != nullptr &&
plugin.SupportsMimeType(GetMimeTypeBase(mime_type).c_str());
}
gcc_pure
static bool
decoder_check_plugin_suffix(const DecoderPlugin &plugin,
const char *suffix) noexcept
{
assert(plugin.stream_decode != nullptr);
return suffix != nullptr && plugin.SupportsSuffix(suffix);
}
gcc_pure
static bool
decoder_check_plugin(const DecoderPlugin &plugin, const InputStream &is,
const char *suffix) noexcept
{
return plugin.stream_decode != nullptr &&
(decoder_check_plugin_mime(plugin, is) ||
decoder_check_plugin_suffix(plugin, suffix));
}
static bool
decoder_run_stream_plugin(DecoderBridge &bridge, InputStream &is,
const char *suffix,
const DecoderPlugin &plugin,
bool &tried_r)
{
if (!decoder_check_plugin(plugin, is, suffix))
return false;
bridge.error = std::exception_ptr();
tried_r = true;
return decoder_stream_decode(plugin, bridge, is);
}
static bool
decoder_run_stream_locked(DecoderBridge &bridge, InputStream &is,
const char *uri, bool &tried_r)
{
UriSuffixBuffer suffix_buffer;
const char *const suffix = uri_get_suffix(uri, suffix_buffer);
using namespace std::placeholders;
const auto f = std::bind(decoder_run_stream_plugin,
std::ref(bridge), std::ref(is), suffix,
_1, std::ref(tried_r));
return decoder_plugins_try(f);
}
/**
* Try decoding a stream, using the fallback plugin.
*/
static bool
decoder_run_stream_fallback(DecoderBridge &bridge, InputStream &is)
{
const struct DecoderPlugin *plugin;
#ifdef ENABLE_FFMPEG
plugin = decoder_plugin_from_name("ffmpeg");
#else
plugin = decoder_plugin_from_name("mad");
#endif
2013-10-19 18:19:03 +02:00
return plugin != nullptr && plugin->stream_decode != nullptr &&
decoder_stream_decode(*plugin, bridge, is);
}
/**
* Attempt to load replay gain data, and pass it to
* DecoderClient::SubmitReplayGain().
*/
static void
LoadReplayGain(DecoderClient &client, InputStream &is)
{
ReplayGainInfo info;
if (replay_gain_ape_read(is, info))
client.SubmitReplayGain(&info);
}
/**
* Call LoadReplayGain() unless ReplayGain is disabled. This saves
* the I/O overhead when the user is not interested in the feature.
*/
static void
MaybeLoadReplayGain(DecoderBridge &bridge, InputStream &is)
{
{
const std::lock_guard<Mutex> protect(bridge.dc.mutex);
if (bridge.dc.replay_gain_mode == ReplayGainMode::OFF)
/* ReplayGain is disabled */
return;
}
LoadReplayGain(bridge, is);
}
/**
* Try decoding a stream.
2015-12-31 12:24:57 +01:00
*
* DecoderControl::mutex is not locked by caller.
*/
static bool
decoder_run_stream(DecoderBridge &bridge, const char *uri)
{
DecoderControl &dc = bridge.dc;
auto input_stream = decoder_input_stream_open(dc, uri);
assert(input_stream);
MaybeLoadReplayGain(bridge, *input_stream);
const std::lock_guard<Mutex> protect(dc.mutex);
bool tried = false;
return dc.command == DecoderCommand::STOP ||
decoder_run_stream_locked(bridge, *input_stream, uri,
tried) ||
/* fallback to mp3: this is needed for bastard streams
that don't have a suffix or set the mimeType */
(!tried &&
decoder_run_stream_fallback(bridge, *input_stream));
}
2015-12-31 12:24:57 +01:00
/**
* Decode a file with the given decoder plugin.
*
* DecoderControl::mutex is not locked by caller.
2015-12-31 12:24:57 +01:00
*/
static bool
TryDecoderFile(DecoderBridge &bridge, Path path_fs, const char *suffix,
InputStream &input_stream,
const DecoderPlugin &plugin)
{
if (!plugin.SupportsSuffix(suffix))
return false;
bridge.error = std::exception_ptr();
DecoderControl &dc = bridge.dc;
if (plugin.file_decode != nullptr) {
const std::lock_guard<Mutex> protect(dc.mutex);
return decoder_file_decode(plugin, bridge, path_fs);
} else if (plugin.stream_decode != nullptr) {
const std::lock_guard<Mutex> protect(dc.mutex);
return decoder_stream_decode(plugin, bridge, input_stream);
} else
return false;
}
/**
* Decode a container file with the given decoder plugin.
*
* DecoderControl::mutex is not locked by caller.
*/
static bool
TryContainerDecoder(DecoderBridge &bridge, Path path_fs, const char *suffix,
const DecoderPlugin &plugin)
{
if (plugin.container_scan == nullptr ||
plugin.file_decode == nullptr ||
!plugin.SupportsSuffix(suffix))
return false;
bridge.error = nullptr;
DecoderControl &dc = bridge.dc;
const std::lock_guard<Mutex> protect(dc.mutex);
return decoder_file_decode(plugin, bridge, path_fs);
}
/**
* Decode a container file.
*
* DecoderControl::mutex is not locked by caller.
*/
static bool
TryContainerDecoder(DecoderBridge &bridge, Path path_fs, const char *suffix)
{
return decoder_plugins_try([&bridge, path_fs,
suffix](const DecoderPlugin &plugin){
return TryContainerDecoder(bridge,
path_fs,
suffix,
plugin);
});
}
/**
* Try decoding a file.
2015-12-31 12:24:57 +01:00
*
* DecoderControl::mutex is not locked by caller.
*/
static bool
decoder_run_file(DecoderBridge &bridge, const char *uri_utf8, Path path_fs)
{
const char *suffix = uri_get_suffix(uri_utf8);
if (suffix == nullptr)
return false;
InputStreamPtr input_stream;
try {
input_stream = decoder_input_stream_open(bridge.dc, path_fs);
} catch (const std::system_error &e) {
if (IsPathNotFound(e) &&
/* ENOTDIR means this may be a path inside a
"container" file */
TryContainerDecoder(bridge, path_fs, suffix))
return true;
throw;
}
assert(input_stream);
MaybeLoadReplayGain(bridge, *input_stream);
auto &is = *input_stream;
return decoder_plugins_try([&bridge, path_fs, suffix,
&is](const DecoderPlugin &plugin){
return TryDecoderFile(bridge,
path_fs,
suffix,
is,
plugin);
});
}
/**
* Decode a song.
*
* DecoderControl::mutex is not locked.
*/
static bool
DecoderUnlockedRunUri(DecoderBridge &bridge,
const char *real_uri, Path path_fs)
try {
return !path_fs.IsNull()
? decoder_run_file(bridge, real_uri, path_fs)
: decoder_run_stream(bridge, real_uri);
2016-05-13 13:12:21 +02:00
} catch (StopDecoder) {
return true;
} catch (...) {
const char *error_uri = real_uri;
const std::string allocated = uri_remove_auth(error_uri);
if (!allocated.empty())
error_uri = allocated.c_str();
std::throw_with_nested(FormatRuntimeError("Failed to decode %s",
error_uri));
}
2015-12-31 12:24:57 +01:00
/**
* Decode a song addressed by a #DetachedSong.
*
* Caller holds DecoderControl::mutex.
*/
static void
decoder_run_song(DecoderControl &dc,
const DetachedSong &song, const char *uri, Path path_fs)
{
DecoderBridge bridge(dc, dc.start_time.IsPositive(),
/* pass the song tag only if it's
authoritative, i.e. if it's a local
file - tags on "stream" songs are just
remembered from the last time we
played it*/
song.IsFile() ? std::make_unique<Tag>(song.GetTag()) : nullptr);
2013-10-19 18:48:38 +02:00
dc.state = DecoderState::START;
dc.CommandFinishedLocked();
bool success;
{
const ScopeUnlock unlock(dc.mutex);
AtScopeExit(&bridge) {
/* flush the last chunk */
if (bridge.current_chunk != nullptr)
bridge.FlushChunk();
};
success = DecoderUnlockedRunUri(bridge, uri, path_fs);
}
if (bridge.error) {
2016-02-26 16:48:23 +01:00
/* copy the Error from struct Decoder to
DecoderControl */
std::rethrow_exception(bridge.error);
} else if (success)
2013-10-19 18:48:38 +02:00
dc.state = DecoderState::STOP;
2012-08-08 21:54:54 +02:00
else {
const char *error_uri = song.GetURI();
const std::string allocated = uri_remove_auth(error_uri);
if (!allocated.empty())
error_uri = allocated.c_str();
2012-08-08 21:54:54 +02:00
throw FormatRuntimeError("Failed to decode %s", error_uri);
2012-08-08 21:54:54 +02:00
}
2013-10-19 18:48:38 +02:00
dc.client_cond.signal();
}
2015-12-31 12:24:57 +01:00
/**
*
* Caller holds DecoderControl::mutex.
*/
static void
decoder_run(DecoderControl &dc)
try {
2013-10-19 18:48:38 +02:00
dc.ClearError();
2012-08-08 21:54:54 +02:00
2014-01-08 00:35:28 +01:00
assert(dc.song != nullptr);
const DetachedSong &song = *dc.song;
const char *const uri_utf8 = song.GetRealURI();
Path path_fs = Path::Null();
AllocatedPath path_buffer = AllocatedPath::Null();
if (PathTraitsUTF8::IsAbsolute(uri_utf8)) {
path_buffer = AllocatedPath::FromUTF8Throw(uri_utf8);
path_fs = path_buffer;
}
decoder_run_song(dc, song, uri_utf8, path_fs);
} catch (...) {
dc.state = DecoderState::ERROR;
dc.command = DecoderCommand::NONE;
dc.error = std::current_exception();
dc.client_cond.signal();
}
2017-02-10 22:41:11 +01:00
void
2017-11-26 12:11:29 +01:00
DecoderControl::RunThread() noexcept
{
SetThreadName("decoder");
2017-02-10 22:41:11 +01:00
const std::lock_guard<Mutex> protect(mutex);
do {
2017-02-10 22:41:11 +01:00
assert(state == DecoderState::STOP ||
state == DecoderState::ERROR);
2017-02-10 22:41:11 +01:00
switch (command) {
case DecoderCommand::START:
2017-02-10 22:41:11 +01:00
CycleMixRamp();
replay_gain_prev_db = replay_gain_db;
replay_gain_db = 0;
2017-02-10 22:41:11 +01:00
decoder_run(*this);
2015-12-31 13:38:27 +01:00
2017-02-10 22:41:11 +01:00
if (state == DecoderState::ERROR) {
try {
2017-02-10 22:41:11 +01:00
std::rethrow_exception(error);
} catch (const std::exception &e) {
LogError(e);
} catch (...) {
}
}
2015-12-31 13:38:27 +01:00
break;
case DecoderCommand::SEEK:
/* this seek was too late, and the decoder had
already finished; start a new decoder */
/* we need to clear the pipe here; usually the
PlayerThread is responsible, but it is not
aware that the decoder has finished */
2017-02-10 22:41:11 +01:00
pipe->Clear(*buffer);
2017-02-10 22:41:11 +01:00
decoder_run(*this);
break;
case DecoderCommand::STOP:
2017-02-10 22:41:11 +01:00
CommandFinishedLocked();
break;
case DecoderCommand::NONE:
2017-02-10 22:41:11 +01:00
Wait();
break;
}
2017-02-10 22:41:11 +01:00
} while (command != DecoderCommand::NONE || !quit);
Initial cut of fork() => pthreads() for decoder and player I initially started to do a heavy rewrite that changed the way processes communicated, but that was too much to do at once. So this change only focuses on replacing the player and decode processes with threads and using condition variables instead of polling in loops; so the changeset itself is quiet small. * The shared output buffer variables will still need locking to guard against race conditions. So in this effect, we're probably just as buggy as before. The reduced context-switching overhead of using threads instead of processes may even make bugs show up more or less often... * Basic functionality appears to be working for playing local (and NFS) audio, including: play, pause, stop, seek, previous, next, and main playlist editing * I haven't tested HTTP streams yet, they should work. * I've only tested ALSA and Icecast. ALSA works fine, Icecast metadata seems to get screwy at times and breaks song advancement in the playlist at times. * state file loading works, too (after some last-minute hacks with non-blocking wakeup functions) * The non-blocking (*_nb) variants of the task management functions are probably overused. They're more lenient and easier to use because much of our code is still based on our previous polling-based system. * It currently segfaults on exit. I haven't paid much attention to the exit/signal-handling routines other than ensuring it compiles. At least the state file seems to work. We don't do any cleanups of the threads on exit, yet. * Update is still done in a child process and not in a thread. To do this in a thread, we'll need to ensure it does proper locking and communication with the main thread; but should require less memory in the end because we'll be updating the database "in-place" rather than updating a copy and then bulk-loading when done. * We're more sensitive to bugs in 3rd party libraries now. My plan is to eventually use a master process which forks() and restarts the child when it dies: locking and communication with the main thread; but should require less memory in the end because we'll be updating the database "in-place" rather than updating a copy and then bulk-loading when done. * We're more sensitive to bugs in 3rd party libraries now. My plan is to eventually use a master process which forks() and restarts the child when it dies: master - just does waitpid() + fork() in a loop \- main thread \- decoder thread \- player thread At the beginning of every song, the main thread will set a dirty flag and update the state file. This way, if we encounter a song that triggers a segfault killing the main thread, the master will start the replacement main on the next song. * The main thread still wakes up every second on select() to check for signals; which affects power management. [merged r7138 from branches/ew] git-svn-id: https://svn.musicpd.org/mpd/trunk@7240 09075e82-0dd4-0310-85a5-a0d7c8717e4f
2008-04-12 06:08:00 +02:00
}
void
decoder_thread_start(DecoderControl &dc)
Initial cut of fork() => pthreads() for decoder and player I initially started to do a heavy rewrite that changed the way processes communicated, but that was too much to do at once. So this change only focuses on replacing the player and decode processes with threads and using condition variables instead of polling in loops; so the changeset itself is quiet small. * The shared output buffer variables will still need locking to guard against race conditions. So in this effect, we're probably just as buggy as before. The reduced context-switching overhead of using threads instead of processes may even make bugs show up more or less often... * Basic functionality appears to be working for playing local (and NFS) audio, including: play, pause, stop, seek, previous, next, and main playlist editing * I haven't tested HTTP streams yet, they should work. * I've only tested ALSA and Icecast. ALSA works fine, Icecast metadata seems to get screwy at times and breaks song advancement in the playlist at times. * state file loading works, too (after some last-minute hacks with non-blocking wakeup functions) * The non-blocking (*_nb) variants of the task management functions are probably overused. They're more lenient and easier to use because much of our code is still based on our previous polling-based system. * It currently segfaults on exit. I haven't paid much attention to the exit/signal-handling routines other than ensuring it compiles. At least the state file seems to work. We don't do any cleanups of the threads on exit, yet. * Update is still done in a child process and not in a thread. To do this in a thread, we'll need to ensure it does proper locking and communication with the main thread; but should require less memory in the end because we'll be updating the database "in-place" rather than updating a copy and then bulk-loading when done. * We're more sensitive to bugs in 3rd party libraries now. My plan is to eventually use a master process which forks() and restarts the child when it dies: locking and communication with the main thread; but should require less memory in the end because we'll be updating the database "in-place" rather than updating a copy and then bulk-loading when done. * We're more sensitive to bugs in 3rd party libraries now. My plan is to eventually use a master process which forks() and restarts the child when it dies: master - just does waitpid() + fork() in a loop \- main thread \- decoder thread \- player thread At the beginning of every song, the main thread will set a dirty flag and update the state file. This way, if we encounter a song that triggers a segfault killing the main thread, the master will start the replacement main on the next song. * The main thread still wakes up every second on select() to check for signals; which affects power management. [merged r7138 from branches/ew] git-svn-id: https://svn.musicpd.org/mpd/trunk@7240 09075e82-0dd4-0310-85a5-a0d7c8717e4f
2008-04-12 06:08:00 +02:00
{
2013-10-19 18:48:38 +02:00
assert(!dc.thread.IsDefined());
2013-10-19 18:48:38 +02:00
dc.quit = false;
2017-02-10 22:41:11 +01:00
dc.thread.Start();
}