2009-08-24 18:57:06 +02:00
|
|
|
/*
|
2015-01-01 19:48:13 +01:00
|
|
|
* Copyright (C) 2003-2015 The Music Player Daemon Project
|
2009-08-24 18:57:06 +02:00
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2009-11-12 09:12:38 +01:00
|
|
|
#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"
|
2015-01-14 20:11:00 +01:00
|
|
|
#include "encoder/ToOutputStream.hxx"
|
2015-01-08 19:31:57 +01:00
|
|
|
#include "encoder/EncoderInterface.hxx"
|
2014-01-23 23:09:14 +01:00
|
|
|
#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"
|
2015-01-05 19:49:54 +01:00
|
|
|
#include "fs/AllocatedPath.hxx"
|
2015-01-07 19:07:59 +01:00
|
|
|
#include "fs/io/FileOutputStream.hxx"
|
2013-08-10 18:02:44 +02:00
|
|
|
#include "util/Error.hxx"
|
2015-01-10 08:58:31 +01:00
|
|
|
#include "util/Domain.hxx"
|
2009-08-24 18:57:06 +02:00
|
|
|
|
|
|
|
#include <assert.h>
|
2015-01-10 08:58:31 +01:00
|
|
|
#include <stdlib.h>
|
|
|
|
|
|
|
|
static constexpr Domain recorder_domain("recorder");
|
2009-08-24 18:57:06 +02:00
|
|
|
|
2015-01-08 16:54:18 +01:00
|
|
|
class RecorderOutput {
|
|
|
|
friend struct AudioOutputWrapper<RecorderOutput>;
|
|
|
|
|
2014-01-28 11:34:09 +01:00
|
|
|
AudioOutput base;
|
2011-09-16 23:31:48 +02:00
|
|
|
|
2009-08-24 18:57:06 +02:00
|
|
|
/**
|
|
|
|
* The configured encoder plugin.
|
|
|
|
*/
|
2013-07-30 09:04:05 +02:00
|
|
|
Encoder *encoder;
|
2009-08-24 18:57:06 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The destination file name.
|
|
|
|
*/
|
2015-01-05 19:49:54 +01:00
|
|
|
AllocatedPath path;
|
2009-08-24 18:57:06 +02:00
|
|
|
|
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;
|
|
|
|
|
2009-08-24 18:57:06 +02:00
|
|
|
/**
|
2015-01-07 19:07:59 +01:00
|
|
|
* The destination file.
|
2009-08-24 18:57:06 +02:00
|
|
|
*/
|
2015-01-07 19:07:59 +01:00
|
|
|
FileOutputStream *file;
|
2009-08-24 18:57:06 +02:00
|
|
|
|
2014-01-28 23:39:48 +01:00
|
|
|
RecorderOutput()
|
2015-01-05 19:49:54 +01:00
|
|
|
:base(recorder_output_plugin),
|
2015-01-08 16:56:13 +01:00
|
|
|
encoder(nullptr),
|
2015-01-05 19:49:54 +01:00
|
|
|
path(AllocatedPath::Null()) {}
|
2014-01-28 23:39:48 +01:00
|
|
|
|
2015-01-08 16:56:13 +01:00
|
|
|
~RecorderOutput() {
|
|
|
|
if (encoder != nullptr)
|
2015-01-08 19:36:19 +01:00
|
|
|
encoder->Dispose();
|
2015-01-08 16:56:13 +01:00
|
|
|
}
|
|
|
|
|
2015-01-21 22:13:44 +01:00
|
|
|
bool Initialize(const ConfigBlock &block, Error &error_r) {
|
|
|
|
return base.Configure(block, error_r);
|
2013-04-16 23:55:26 +02:00
|
|
|
}
|
|
|
|
|
2015-01-21 22:13:44 +01:00
|
|
|
static RecorderOutput *Create(const ConfigBlock &block, Error &error);
|
2015-01-07 18:52:47 +01:00
|
|
|
|
2015-01-21 22:13:44 +01:00
|
|
|
bool Configure(const ConfigBlock &block, Error &error);
|
2013-04-16 23:55:26 +02:00
|
|
|
|
2014-12-26 14:57:29 +01: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.
|
|
|
|
*/
|
2015-12-16 10:24:43 +01:00
|
|
|
void EncoderToFile();
|
2014-12-26 14:57:21 +01:00
|
|
|
|
|
|
|
void SendTag(const Tag &tag);
|
2015-01-07 18:52:47 +01:00
|
|
|
|
|
|
|
size_t Play(const void *chunk, size_t size, Error &error);
|
2015-01-07 19:11:04 +01:00
|
|
|
|
|
|
|
private:
|
2015-01-10 08:58:31 +01:00
|
|
|
gcc_pure
|
|
|
|
bool HasDynamicPath() const {
|
|
|
|
return !format_path.empty();
|
|
|
|
}
|
|
|
|
|
2015-01-07 19:11:04 +01:00
|
|
|
/**
|
|
|
|
* 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);
|
2009-08-24 18:57:06 +02:00
|
|
|
};
|
|
|
|
|
2013-04-16 23:55:26 +02:00
|
|
|
inline bool
|
2015-01-21 22:13:44 +01:00
|
|
|
RecorderOutput::Configure(const ConfigBlock &block, Error &error)
|
2009-08-24 18:57:06 +02:00
|
|
|
{
|
|
|
|
/* read configuration */
|
|
|
|
|
2012-10-01 23:56:10 +02:00
|
|
|
const char *encoder_name =
|
2015-01-21 22:13:44 +01:00
|
|
|
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) {
|
2013-08-10 18:02:44 +02:00
|
|
|
error.Format(config_domain,
|
|
|
|
"No such encoder: %s", encoder_name);
|
2013-04-16 23:55:26 +02:00
|
|
|
return false;
|
2009-08-24 18:57:06 +02:00
|
|
|
}
|
|
|
|
|
2015-01-21 22:13:44 +01:00
|
|
|
path = block.GetBlockPath("path", error);
|
2015-01-10 08:58:31 +01:00
|
|
|
if (error.IsDefined())
|
|
|
|
return false;
|
|
|
|
|
2015-01-21 22:13:44 +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) {
|
|
|
|
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;
|
2009-08-24 18:57:06 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* initialize encoder */
|
|
|
|
|
2015-01-21 22:13:44 +01:00
|
|
|
encoder = encoder_init(*encoder_plugin, block, error);
|
2013-04-16 23:55:26 +02:00
|
|
|
if (encoder == nullptr)
|
|
|
|
return false;
|
2009-08-24 18:57:06 +02:00
|
|
|
|
2013-04-16 23:55:26 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-01-07 18:52:47 +01:00
|
|
|
RecorderOutput *
|
2015-01-21 22:13:44 +01:00
|
|
|
RecorderOutput::Create(const ConfigBlock &block, Error &error)
|
2013-04-16 23:55:26 +02:00
|
|
|
{
|
|
|
|
RecorderOutput *recorder = new RecorderOutput();
|
|
|
|
|
2015-01-21 22:13:44 +01:00
|
|
|
if (!recorder->Initialize(block, error)) {
|
2013-04-16 23:55:26 +02:00
|
|
|
delete recorder;
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2015-01-21 22:13:44 +01:00
|
|
|
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
|
|
|
|
2015-01-07 18:52:47 +01:00
|
|
|
return recorder;
|
2009-08-24 18:57:06 +02:00
|
|
|
}
|
|
|
|
|
2015-12-16 10:24:43 +01:00
|
|
|
inline void
|
|
|
|
RecorderOutput::EncoderToFile()
|
2012-10-01 23:59:50 +02:00
|
|
|
{
|
2015-01-07 19:07:59 +01:00
|
|
|
assert(file != nullptr);
|
2012-10-01 23:59:50 +02:00
|
|
|
|
2015-12-16 10:24:43 +01:00
|
|
|
EncoderToOutputStream(*file, *encoder);
|
2012-10-01 23:59:50 +02:00
|
|
|
}
|
|
|
|
|
2014-12-26 14:57:29 +01:00
|
|
|
inline bool
|
|
|
|
RecorderOutput::Open(AudioFormat &audio_format, Error &error)
|
2009-08-24 18:57:06 +02:00
|
|
|
{
|
|
|
|
/* create the output file */
|
|
|
|
|
2015-01-10 08:58:31 +01:00
|
|
|
if (!HasDynamicPath()) {
|
|
|
|
assert(!path.IsNull());
|
|
|
|
|
2015-12-15 22:26:26 +01:00
|
|
|
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-12-15 22:26:26 +01:00
|
|
|
}
|
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;
|
|
|
|
}
|
2009-08-24 18:57:06 +02:00
|
|
|
|
|
|
|
/* open the encoder */
|
|
|
|
|
2015-01-08 19:36:19 +01:00
|
|
|
if (!encoder->Open(audio_format, error)) {
|
2015-01-07 19:07:59 +01:00
|
|
|
delete file;
|
2012-10-01 23:17:13 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-01-10 08:58:31 +01:00
|
|
|
if (!HasDynamicPath()) {
|
2015-12-16 10:24:43 +01:00
|
|
|
try {
|
|
|
|
EncoderToFile();
|
|
|
|
} catch (const std::exception &e) {
|
2015-01-10 08:58:31 +01:00
|
|
|
encoder->Close();
|
2015-12-16 10:24:43 +01:00
|
|
|
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 */
|
2015-01-08 19:36:19 +01:00
|
|
|
encoder->Close();
|
2009-08-24 18:57:06 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-01-07 19:11:04 +01:00
|
|
|
inline bool
|
|
|
|
RecorderOutput::Commit(Error &error)
|
2014-12-26 14:57:29 +01:00
|
|
|
{
|
2015-01-10 08:58:31 +01:00
|
|
|
assert(!path.IsNull());
|
|
|
|
|
2009-08-24 18:57:06 +02:00
|
|
|
/* flush the encoder and write the rest to the file */
|
|
|
|
|
2015-12-16 10:24:43 +01:00
|
|
|
bool success = encoder_end(encoder, error);
|
|
|
|
if (success) {
|
|
|
|
try {
|
|
|
|
EncoderToFile();
|
|
|
|
} catch (...) {
|
|
|
|
encoder->Close();
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
}
|
2009-08-24 18:57:06 +02:00
|
|
|
|
|
|
|
/* now really close everything */
|
|
|
|
|
2015-01-08 19:36:19 +01:00
|
|
|
encoder->Close();
|
2014-12-26 14:57:29 +01:00
|
|
|
|
2015-12-16 00:24:41 +01:00
|
|
|
if (success) {
|
|
|
|
try {
|
|
|
|
file->Commit();
|
|
|
|
} catch (...) {
|
|
|
|
delete file;
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
}
|
2015-01-07 19:07:59 +01:00
|
|
|
|
|
|
|
delete file;
|
2015-01-07 19:11:04 +01:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2015-12-16 00:24:41 +01:00
|
|
|
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;
|
|
|
|
|
2015-12-16 00:24:41 +01:00
|
|
|
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);
|
|
|
|
|
2015-12-15 22:26:26 +01:00
|
|
|
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-12-15 22:26:26 +01:00
|
|
|
}
|
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);
|
|
|
|
|
2015-12-16 10:24:43 +01:00
|
|
|
try {
|
|
|
|
EncoderToOutputStream(*new_file, *encoder);
|
|
|
|
} catch (const std::exception &e) {
|
2015-01-10 08:58:31 +01:00
|
|
|
encoder->Close();
|
|
|
|
delete new_file;
|
2015-12-16 10:24:43 +01:00
|
|
|
error.Set(recorder_domain, e.what());
|
2015-01-10 08:58:31 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
path = std::move(new_path);
|
|
|
|
file = new_file;
|
|
|
|
|
2015-03-05 10:15:04 +01:00
|
|
|
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:29 +01:00
|
|
|
}
|
|
|
|
|
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;
|
2015-12-16 10:24:43 +01:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2015-01-07 18:52:47 +01:00
|
|
|
inline size_t
|
|
|
|
RecorderOutput::Play(const void *chunk, size_t size, Error &error)
|
2009-08-24 18:57:06 +02:00
|
|
|
{
|
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;
|
|
|
|
}
|
|
|
|
|
2015-12-16 10:24:43 +01:00
|
|
|
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;
|
2009-08-24 18:57:06 +02:00
|
|
|
}
|
|
|
|
|
2014-12-29 23:45:14 +01:00
|
|
|
typedef AudioOutputWrapper<RecorderOutput> Wrapper;
|
|
|
|
|
2014-01-28 11:22:27 +01:00
|
|
|
const struct AudioOutputPlugin recorder_output_plugin = {
|
2013-04-16 23:55:26 +02:00
|
|
|
"recorder",
|
|
|
|
nullptr,
|
2015-01-07 18:52:47 +01:00
|
|
|
&Wrapper::Init,
|
2015-01-08 16:56:13 +01:00
|
|
|
&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,
|
2015-01-07 18:52:47 +01:00
|
|
|
&Wrapper::Play,
|
2013-04-16 23:55:26 +02:00
|
|
|
nullptr,
|
|
|
|
nullptr,
|
|
|
|
nullptr,
|
|
|
|
nullptr,
|
2009-08-24 18:57:06 +02:00
|
|
|
};
|