mpd/src/output/plugins/RecorderOutputPlugin.cxx

450 lines
8.7 KiB
C++
Raw Normal View History

/*
2015-01-01 19:48:13 +01:00
* Copyright (C) 2003-2015 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/Error.hxx"
2015-01-10 08:58:31 +01:00
#include "util/Domain.hxx"
#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>;
AudioOutput base;
/**
* The configured encoder plugin.
*/
2013-07-30 09:04:05 +02:00
Encoder *encoder;
/**
* The destination file name.
*/
AllocatedPath path;
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()
:base(recorder_output_plugin),
encoder(nullptr),
path(AllocatedPath::Null()) {}
~RecorderOutput() {
if (encoder != nullptr)
encoder->Dispose();
}
bool Initialize(const ConfigBlock &block, Error &error_r) {
return base.Configure(block, error_r);
2013-04-16 23:55:26 +02:00
}
static RecorderOutput *Create(const ConfigBlock &block, Error &error);
bool Configure(const ConfigBlock &block, Error &error);
2013-04-16 23:55:26 +02:00
bool Open(AudioFormat &audio_format, Error &error);
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, Error &error);
private:
2015-01-10 08:58:31 +01:00
gcc_pure
bool HasDynamicPath() const {
return !format_path.empty();
}
/**
* Finish the encoder and commit the file.
*/
bool Commit(Error &error);
2015-01-10 08:58:31 +01:00
void FinishFormat();
bool ReopenFormat(AllocatedPath &&new_path, Error &error);
};
2013-04-16 23:55:26 +02:00
inline bool
RecorderOutput::Configure(const ConfigBlock &block, Error &error)
{
/* 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);
2013-04-16 23:55:26 +02:00
if (encoder_plugin == nullptr) {
error.Format(config_domain,
"No such encoder: %s", encoder_name);
2013-04-16 23:55:26 +02:00
return false;
}
path = block.GetBlockPath("path", error);
2015-01-10 08:58:31 +01:00
if (error.IsDefined())
return false;
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) {
error.Set(config_domain, "'path' not configured");
return false;
}
if (!path.IsNull() && fmt != nullptr) {
error.Set(config_domain, "Cannot have both 'path' and 'format_path'");
2013-04-16 23:55:26 +02:00
return false;
}
/* initialize encoder */
encoder = encoder_init(*encoder_plugin, block, error);
2013-04-16 23:55:26 +02:00
if (encoder == nullptr)
return false;
2013-04-16 23:55:26 +02:00
return true;
}
RecorderOutput *
RecorderOutput::Create(const ConfigBlock &block, Error &error)
2013-04-16 23:55:26 +02:00
{
RecorderOutput *recorder = new RecorderOutput();
if (!recorder->Initialize(block, error)) {
2013-04-16 23:55:26 +02:00
delete recorder;
return nullptr;
}
if (!recorder->Configure(block, error)) {
2013-04-16 23:55:26 +02:00
delete recorder;
return nullptr;
}
2011-07-18 15:39:19 +02:00
return recorder;
}
inline void
RecorderOutput::EncoderToFile()
{
2015-01-07 19:07:59 +01:00
assert(file != nullptr);
EncoderToOutputStream(*file, *encoder);
}
inline bool
RecorderOutput::Open(AudioFormat &audio_format, Error &error)
{
/* create the output file */
2015-01-10 08:58:31 +01:00
if (!HasDynamicPath()) {
assert(!path.IsNull());
try {
file = new FileOutputStream(path);
} catch (const std::exception &e) {
error.Set(recorder_domain, e.what());
2015-01-10 08:58:31 +01:00
return false;
}
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 */
if (!encoder->Open(audio_format, error)) {
2015-01-07 19:07:59 +01:00
delete file;
return false;
}
2015-01-10 08:58:31 +01:00
if (!HasDynamicPath()) {
try {
EncoderToFile();
} catch (const std::exception &e) {
2015-01-10 08:58:31 +01:00
encoder->Close();
error.Set(recorder_domain, e.what());
2015-01-10 08:58:31 +01:00
return false;
}
} 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 */
encoder->Close();
}
return true;
}
inline bool
RecorderOutput::Commit(Error &error)
{
2015-01-10 08:58:31 +01:00
assert(!path.IsNull());
/* flush the encoder and write the rest to the file */
bool success = encoder_end(encoder, error);
if (success) {
try {
EncoderToFile();
} catch (...) {
encoder->Close();
throw;
}
}
/* now really close everything */
encoder->Close();
if (success) {
try {
file->Commit();
} catch (...) {
delete file;
throw;
}
}
2015-01-07 19:07:59 +01:00
delete file;
return success;
}
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 {
Error error;
if (!Commit(error))
LogError(error);
} 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 {
Error error;
if (!Commit(error))
LogError(error);
} catch (const std::exception &e) {
LogError(e);
}
2015-01-10 08:58:31 +01:00
file = nullptr;
path.SetNull();
}
inline bool
RecorderOutput::ReopenFormat(AllocatedPath &&new_path, Error &error)
{
assert(HasDynamicPath());
assert(path.IsNull());
assert(file == nullptr);
FileOutputStream *new_file;
try {
new_file = new FileOutputStream(path);
} catch (const std::exception &e) {
error.Set(recorder_domain, e.what());
2015-01-10 08:58:31 +01:00
return false;
}
2015-01-10 08:58:31 +01:00
AudioFormat new_audio_format = effective_audio_format;
if (!encoder->Open(new_audio_format, error)) {
delete new_file;
return false;
}
/* 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) {
2015-01-10 08:58:31 +01:00
encoder->Close();
delete new_file;
error.Set(recorder_domain, e.what());
2015-01-10 08:58:31 +01:00
return false;
}
path = std::move(new_path);
file = new_file;
FormatDebug(recorder_domain, "Recording to \"%s\"",
path.ToUTF8().c_str());
2015-01-10 08:58:31 +01:00
return true;
}
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;
}
Error error;
AllocatedPath new_path = ParsePath(p, error);
free(p);
if (new_path.IsNull()) {
LogError(error);
FinishFormat();
return;
}
if (new_path != path) {
FinishFormat();
if (!ReopenFormat(std::move(new_path), error)) {
LogError(error);
return;
}
}
}
2014-12-26 14:57:21 +01:00
Error error;
if (!encoder_pre_tag(encoder, error)) {
LogError(error);
return;
}
try {
EncoderToFile();
} catch (const std::exception &e) {
LogError(e);
return;
}
if (!encoder_tag(encoder, tag, error))
2014-12-26 14:57:21 +01:00
LogError(error);
}
inline size_t
RecorderOutput::Play(const void *chunk, size_t size, Error &error)
{
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;
}
if (!encoder_write(encoder, chunk, size, error))
return 0;
try {
EncoderToFile();
} catch (const std::exception &e) {
error.Set(recorder_domain, e.what());
return 0;
}
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,
};