mpd/src/output/plugins/RecorderOutputPlugin.cxx

387 lines
7.5 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"
2013-04-16 23:55:26 +02:00
#include "RecorderOutputPlugin.hxx"
2014-01-23 23:49:50 +01:00
#include "../OutputAPI.hxx"
2014-12-29 23:45:14 +01:00
#include "../Wrapper.hxx"
2015-01-10 08:58:31 +01:00
#include "tag/Format.hxx"
#include "encoder/ToOutputStream.hxx"
#include "encoder/EncoderInterface.hxx"
#include "encoder/EncoderPlugin.hxx"
#include "encoder/EncoderList.hxx"
2014-01-24 00:20:01 +01:00
#include "config/ConfigError.hxx"
2015-01-10 08:58:31 +01:00
#include "config/ConfigPath.hxx"
2014-12-26 14:57:21 +01:00
#include "Log.hxx"
#include "fs/AllocatedPath.hxx"
2015-01-07 19:07:59 +01:00
#include "fs/io/FileOutputStream.hxx"
#include "util/RuntimeError.hxx"
2015-01-10 08:58:31 +01:00
#include "util/Domain.hxx"
#include "util/ScopeExit.hxx"
#include <stdexcept>
#include <assert.h>
2015-01-10 08:58:31 +01:00
#include <stdlib.h>
static constexpr Domain recorder_domain("recorder");
class RecorderOutput {
friend struct AudioOutputWrapper<RecorderOutput>;
FilteredAudioOutput base;
/**
* The configured encoder plugin.
*/
PreparedEncoder *prepared_encoder = nullptr;
Encoder *encoder;
/**
* The destination file name.
*/
AllocatedPath path = AllocatedPath::Null();
2015-01-10 08:58:31 +01:00
/**
* A string that will be used with FormatTag() to build the
* destination path.
*/
std::string format_path;
/**
* The #AudioFormat that is currently active. This is used
* for switching to another file.
*/
AudioFormat effective_audio_format;
/**
2015-01-07 19:07:59 +01:00
* The destination file.
*/
2015-01-07 19:07:59 +01:00
FileOutputStream *file;
RecorderOutput(const ConfigBlock &block);
~RecorderOutput() {
delete prepared_encoder;
}
static RecorderOutput *Create(EventLoop &event_loop,
const ConfigBlock &block);
void Open(AudioFormat &audio_format);
void Close();
2013-04-16 23:55:26 +02:00
/**
* Writes pending data from the encoder to the output file.
*/
void EncoderToFile();
2014-12-26 14:57:21 +01:00
void SendTag(const Tag &tag);
size_t Play(const void *chunk, size_t size);
private:
2015-01-10 08:58:31 +01:00
gcc_pure
bool HasDynamicPath() const noexcept {
2015-01-10 08:58:31 +01:00
return !format_path.empty();
}
/**
* Finish the encoder and commit the file.
*
* Throws #std::runtime_error on error.
*/
void Commit();
2015-01-10 08:58:31 +01:00
void FinishFormat();
void ReopenFormat(AllocatedPath &&new_path);
};
RecorderOutput::RecorderOutput(const ConfigBlock &block)
:base(recorder_output_plugin, block)
{
/* read configuration */
const char *encoder_name =
block.GetBlockValue("encoder", "vorbis");
2013-07-30 09:04:05 +02:00
const auto encoder_plugin = encoder_plugin_get(encoder_name);
if (encoder_plugin == nullptr)
throw FormatRuntimeError("No such encoder: %s", encoder_name);
path = block.GetPath("path");
2015-01-10 08:58:31 +01:00
const char *fmt = block.GetBlockValue("format_path", nullptr);
2015-01-10 08:58:31 +01:00
if (fmt != nullptr)
format_path = fmt;
if (path.IsNull() && fmt == nullptr)
throw std::runtime_error("'path' not configured");
2015-01-10 08:58:31 +01:00
if (!path.IsNull() && fmt != nullptr)
throw std::runtime_error("Cannot have both 'path' and 'format_path'");
/* initialize encoder */
prepared_encoder = encoder_init(*encoder_plugin, block);
2013-04-16 23:55:26 +02:00
}
RecorderOutput *
RecorderOutput::Create(EventLoop &, const ConfigBlock &block)
2013-04-16 23:55:26 +02:00
{
return new RecorderOutput(block);
}
inline void
RecorderOutput::EncoderToFile()
{
2015-01-07 19:07:59 +01:00
assert(file != nullptr);
EncoderToOutputStream(*file, *encoder);
}
inline void
RecorderOutput::Open(AudioFormat &audio_format)
{
/* create the output file */
2015-01-10 08:58:31 +01:00
if (!HasDynamicPath()) {
assert(!path.IsNull());
file = new FileOutputStream(path);
2015-01-10 08:58:31 +01:00
} else {
/* don't open the file just yet; wait until we have
a tag that we can use to build the path */
assert(path.IsNull());
file = nullptr;
}
/* open the encoder */
try {
encoder = prepared_encoder->Open(audio_format);
} catch (const std::runtime_error &) {
2015-01-07 19:07:59 +01:00
delete file;
throw;
}
2015-01-10 08:58:31 +01:00
if (!HasDynamicPath()) {
try {
EncoderToFile();
} catch (const std::runtime_error &) {
delete encoder;
throw;
2015-01-10 08:58:31 +01:00
}
} else {
/* remember the AudioFormat for ReopenFormat() */
effective_audio_format = audio_format;
/* close the encoder for now; it will be opened as
soon as we have received a tag */
delete encoder;
}
}
inline void
RecorderOutput::Commit()
{
2015-01-10 08:58:31 +01:00
assert(!path.IsNull());
/* flush the encoder and write the rest to the file */
try {
encoder->End();
EncoderToFile();
} catch (...) {
delete encoder;
throw;
}
/* now really close everything */
delete encoder;
try {
file->Commit();
} catch (...) {
delete file;
throw;
}
2015-01-07 19:07:59 +01:00
delete file;
}
inline void
RecorderOutput::Close()
{
2015-01-10 08:58:31 +01:00
if (file == nullptr) {
/* not currently encoding to a file; nothing needs to
be done now */
assert(HasDynamicPath());
assert(path.IsNull());
return;
}
try {
Commit();
} catch (const std::exception &e) {
LogError(e);
}
2015-01-10 08:58:31 +01:00
if (HasDynamicPath()) {
assert(!path.IsNull());
path.SetNull();
}
}
void
RecorderOutput::FinishFormat()
{
assert(HasDynamicPath());
if (file == nullptr)
return;
try {
Commit();
} catch (const std::exception &e) {
LogError(e);
}
2015-01-10 08:58:31 +01:00
file = nullptr;
path.SetNull();
}
inline void
RecorderOutput::ReopenFormat(AllocatedPath &&new_path)
2015-01-10 08:58:31 +01:00
{
assert(HasDynamicPath());
assert(path.IsNull());
assert(file == nullptr);
FileOutputStream *new_file = new FileOutputStream(new_path);
2015-01-10 08:58:31 +01:00
AudioFormat new_audio_format = effective_audio_format;
try {
encoder = prepared_encoder->Open(new_audio_format);
} catch (...) {
2015-01-10 08:58:31 +01:00
delete new_file;
throw;
2015-01-10 08:58:31 +01:00
}
/* reopening the encoder must always result in the same
AudioFormat as before */
assert(new_audio_format == effective_audio_format);
try {
EncoderToOutputStream(*new_file, *encoder);
} catch (const std::exception &e) {
delete encoder;
2015-01-10 08:58:31 +01:00
delete new_file;
throw;
2015-01-10 08:58:31 +01:00
}
path = std::move(new_path);
file = new_file;
FormatDebug(recorder_domain, "Recording to \"%s\"",
path.ToUTF8().c_str());
}
2014-12-26 14:57:21 +01:00
inline void
RecorderOutput::SendTag(const Tag &tag)
{
2015-01-10 08:58:31 +01:00
if (HasDynamicPath()) {
char *p = FormatTag(tag, format_path.c_str());
if (p == nullptr || *p == 0) {
/* no path could be composed with this tag:
don't write a file */
free(p);
FinishFormat();
return;
}
AtScopeExit(p) { free(p); };
AllocatedPath new_path = AllocatedPath::Null();
try {
new_path = ParsePath(p);
} catch (const std::runtime_error &e) {
LogError(e);
2015-01-10 08:58:31 +01:00
FinishFormat();
return;
}
if (new_path != path) {
FinishFormat();
try {
ReopenFormat(std::move(new_path));
} catch (const std::runtime_error &e) {
LogError(e);
2015-01-10 08:58:31 +01:00
return;
}
}
}
encoder->PreTag();
EncoderToFile();
encoder->SendTag(tag);
2014-12-26 14:57:21 +01:00
}
inline size_t
RecorderOutput::Play(const void *chunk, size_t size)
{
2015-01-10 08:58:31 +01:00
if (file == nullptr) {
/* not currently encoding to a file; discard incoming
data */
assert(HasDynamicPath());
assert(path.IsNull());
return size;
}
encoder->Write(chunk, size);
EncoderToFile();
return size;
}
2014-12-29 23:45:14 +01:00
typedef AudioOutputWrapper<RecorderOutput> Wrapper;
const struct AudioOutputPlugin recorder_output_plugin = {
2013-04-16 23:55:26 +02:00
"recorder",
nullptr,
&Wrapper::Init,
&Wrapper::Finish,
2013-04-16 23:55:26 +02:00
nullptr,
nullptr,
2014-12-29 23:45:14 +01:00
&Wrapper::Open,
&Wrapper::Close,
2013-04-16 23:55:26 +02:00
nullptr,
2015-01-07 19:20:09 +01:00
&Wrapper::SendTag,
&Wrapper::Play,
2013-04-16 23:55:26 +02:00
nullptr,
nullptr,
nullptr,
nullptr,
};