2009-08-24 18:57:06 +02:00
|
|
|
/*
|
2017-01-03 20:48:59 +01:00
|
|
|
* Copyright 2003-2017 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"
|
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"
|
2017-11-10 21:37:56 +01:00
|
|
|
#include "encoder/Configured.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"
|
2015-01-10 08:58:31 +01:00
|
|
|
#include "util/Domain.hxx"
|
2016-11-07 09:07:50 +01:00
|
|
|
#include "util/ScopeExit.hxx"
|
|
|
|
|
|
|
|
#include <stdexcept>
|
2017-11-10 21:35:22 +01:00
|
|
|
#include <memory>
|
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
|
|
|
|
2017-08-09 16:58:44 +02:00
|
|
|
class RecorderOutput final : AudioOutput {
|
2009-08-24 18:57:06 +02:00
|
|
|
/**
|
|
|
|
* The configured encoder plugin.
|
|
|
|
*/
|
2017-11-10 21:35:22 +01:00
|
|
|
std::unique_ptr<PreparedEncoder> prepared_encoder;
|
2016-05-04 09:31:21 +02:00
|
|
|
Encoder *encoder;
|
2009-08-24 18:57:06 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The destination file name.
|
|
|
|
*/
|
2018-01-17 12:17:41 +01:00
|
|
|
AllocatedPath path = nullptr;
|
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
|
|
|
|
2016-11-07 09:16:43 +01:00
|
|
|
RecorderOutput(const ConfigBlock &block);
|
2014-01-28 23:39:48 +01:00
|
|
|
|
2017-08-09 16:58:44 +02:00
|
|
|
public:
|
|
|
|
static AudioOutput *Create(EventLoop &, const ConfigBlock &block) {
|
|
|
|
return new RecorderOutput(block);
|
|
|
|
}
|
2015-01-07 18:52:47 +01:00
|
|
|
|
2017-08-09 16:58:44 +02:00
|
|
|
private:
|
|
|
|
void Open(AudioFormat &audio_format) override;
|
|
|
|
void Close() noexcept override;
|
2014-12-26 14:57:29 +01:00
|
|
|
|
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
|
|
|
|
2017-08-09 16:58:44 +02:00
|
|
|
void SendTag(const Tag &tag) override;
|
2015-01-07 18:52:47 +01:00
|
|
|
|
2017-08-09 16:58:44 +02:00
|
|
|
size_t Play(const void *chunk, size_t size) override;
|
2015-01-07 19:11:04 +01:00
|
|
|
|
|
|
|
private:
|
2015-01-10 08:58:31 +01:00
|
|
|
gcc_pure
|
2017-06-03 21:33:44 +02:00
|
|
|
bool HasDynamicPath() const noexcept {
|
2015-01-10 08:58:31 +01:00
|
|
|
return !format_path.empty();
|
|
|
|
}
|
|
|
|
|
2015-01-07 19:11:04 +01:00
|
|
|
/**
|
|
|
|
* Finish the encoder and commit the file.
|
2016-11-07 09:20:12 +01:00
|
|
|
*
|
|
|
|
* Throws #std::runtime_error on error.
|
2015-01-07 19:11:04 +01:00
|
|
|
*/
|
2016-11-07 09:20:12 +01:00
|
|
|
void Commit();
|
2015-01-10 08:58:31 +01:00
|
|
|
|
|
|
|
void FinishFormat();
|
2016-11-07 09:16:43 +01:00
|
|
|
void ReopenFormat(AllocatedPath &&new_path);
|
2009-08-24 18:57:06 +02:00
|
|
|
};
|
|
|
|
|
2016-11-07 09:16:43 +01:00
|
|
|
RecorderOutput::RecorderOutput(const ConfigBlock &block)
|
2017-11-10 21:37:56 +01:00
|
|
|
:AudioOutput(0),
|
|
|
|
prepared_encoder(CreateConfiguredEncoder(block))
|
2009-08-24 18:57:06 +02:00
|
|
|
{
|
|
|
|
/* read configuration */
|
|
|
|
|
2016-10-28 23:08:42 +02:00
|
|
|
path = block.GetPath("path");
|
2015-01-10 08:58:31 +01:00
|
|
|
|
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;
|
|
|
|
|
2016-11-07 09:16:43 +01:00
|
|
|
if (path.IsNull() && fmt == nullptr)
|
|
|
|
throw std::runtime_error("'path' not configured");
|
2015-01-10 08:58:31 +01:00
|
|
|
|
2016-11-07 09:16:43 +01:00
|
|
|
if (!path.IsNull() && fmt != nullptr)
|
|
|
|
throw std::runtime_error("Cannot have both 'path' and 'format_path'");
|
2013-04-16 23:55:26 +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
|
|
|
}
|
|
|
|
|
2017-08-09 16:58:44 +02:00
|
|
|
void
|
2016-11-09 11:56:01 +01:00
|
|
|
RecorderOutput::Open(AudioFormat &audio_format)
|
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());
|
|
|
|
|
2016-11-07 09:16:43 +01:00
|
|
|
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;
|
|
|
|
}
|
2009-08-24 18:57:06 +02:00
|
|
|
|
|
|
|
/* open the encoder */
|
|
|
|
|
2016-11-07 09:20:12 +01:00
|
|
|
try {
|
|
|
|
encoder = prepared_encoder->Open(audio_format);
|
2017-12-19 10:56:23 +01:00
|
|
|
} catch (...) {
|
2015-01-07 19:07:59 +01:00
|
|
|
delete file;
|
2016-11-07 09:20:12 +01:00
|
|
|
throw;
|
2012-10-01 23:17:13 +02:00
|
|
|
}
|
|
|
|
|
2015-01-10 08:58:31 +01:00
|
|
|
if (!HasDynamicPath()) {
|
2015-12-16 10:24:43 +01:00
|
|
|
try {
|
|
|
|
EncoderToFile();
|
2017-12-19 10:56:23 +01:00
|
|
|
} catch (...) {
|
2016-05-04 09:31:21 +02:00
|
|
|
delete encoder;
|
2016-11-07 09:16:43 +01:00
|
|
|
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 */
|
2016-05-04 09:31:21 +02:00
|
|
|
delete encoder;
|
2009-08-24 18:57:06 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-07 09:20:12 +01:00
|
|
|
inline void
|
|
|
|
RecorderOutput::Commit()
|
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 */
|
|
|
|
|
2016-11-07 09:20:12 +01:00
|
|
|
try {
|
|
|
|
encoder->End();
|
|
|
|
EncoderToFile();
|
|
|
|
} catch (...) {
|
|
|
|
delete encoder;
|
|
|
|
throw;
|
2015-12-16 10:24:43 +01:00
|
|
|
}
|
2009-08-24 18:57:06 +02:00
|
|
|
|
|
|
|
/* now really close everything */
|
|
|
|
|
2016-05-04 09:31:21 +02:00
|
|
|
delete encoder;
|
2014-12-26 14:57:29 +01:00
|
|
|
|
2016-11-07 09:20:12 +01:00
|
|
|
try {
|
|
|
|
file->Commit();
|
|
|
|
} catch (...) {
|
|
|
|
delete file;
|
|
|
|
throw;
|
2015-12-16 00:24:41 +01:00
|
|
|
}
|
2015-01-07 19:07:59 +01:00
|
|
|
|
|
|
|
delete file;
|
2015-01-07 19:11:04 +01:00
|
|
|
}
|
|
|
|
|
2017-08-09 16:58:44 +02:00
|
|
|
void
|
|
|
|
RecorderOutput::Close() noexcept
|
2015-01-07 19:11:04 +01:00
|
|
|
{
|
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 {
|
2016-11-07 09:20:12 +01:00
|
|
|
Commit();
|
2017-12-19 10:56:23 +01:00
|
|
|
} catch (...) {
|
|
|
|
LogError(std::current_exception());
|
2015-12-16 00:24:41 +01:00
|
|
|
}
|
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 {
|
2016-11-07 09:20:12 +01:00
|
|
|
Commit();
|
2017-12-19 10:56:23 +01:00
|
|
|
} catch (...) {
|
|
|
|
LogError(std::current_exception());
|
2015-12-16 00:24:41 +01:00
|
|
|
}
|
2015-01-10 08:58:31 +01:00
|
|
|
|
|
|
|
file = nullptr;
|
|
|
|
path.SetNull();
|
|
|
|
}
|
|
|
|
|
2016-11-07 09:16:43 +01:00
|
|
|
inline void
|
|
|
|
RecorderOutput::ReopenFormat(AllocatedPath &&new_path)
|
2015-01-10 08:58:31 +01:00
|
|
|
{
|
|
|
|
assert(HasDynamicPath());
|
|
|
|
assert(path.IsNull());
|
|
|
|
assert(file == nullptr);
|
|
|
|
|
2017-01-12 21:36:32 +01:00
|
|
|
FileOutputStream *new_file = new FileOutputStream(new_path);
|
2015-01-10 08:58:31 +01:00
|
|
|
|
|
|
|
AudioFormat new_audio_format = effective_audio_format;
|
2016-11-07 09:20:12 +01:00
|
|
|
|
|
|
|
try {
|
|
|
|
encoder = prepared_encoder->Open(new_audio_format);
|
|
|
|
} catch (...) {
|
2015-01-10 08:58:31 +01:00
|
|
|
delete new_file;
|
2016-11-07 09:20:12 +01:00
|
|
|
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);
|
|
|
|
|
2015-12-16 10:24:43 +01:00
|
|
|
try {
|
|
|
|
EncoderToOutputStream(*new_file, *encoder);
|
2017-12-19 10:56:23 +01:00
|
|
|
} catch (...) {
|
2016-05-04 09:31:21 +02:00
|
|
|
delete encoder;
|
2015-01-10 08:58:31 +01:00
|
|
|
delete new_file;
|
2016-11-07 09:16:43 +01:00
|
|
|
throw;
|
2015-01-10 08:58:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
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());
|
2014-12-26 14:57:29 +01:00
|
|
|
}
|
|
|
|
|
2017-08-09 16:58:44 +02:00
|
|
|
void
|
2014-12-26 14:57:21 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2016-11-07 09:07:50 +01:00
|
|
|
AtScopeExit(p) { free(p); };
|
|
|
|
|
2018-01-17 12:17:41 +01:00
|
|
|
AllocatedPath new_path = nullptr;
|
2016-11-07 09:07:50 +01:00
|
|
|
|
|
|
|
try {
|
|
|
|
new_path = ParsePath(p);
|
2017-12-19 10:56:23 +01:00
|
|
|
} catch (...) {
|
|
|
|
LogError(std::current_exception());
|
2015-01-10 08:58:31 +01:00
|
|
|
FinishFormat();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (new_path != path) {
|
|
|
|
FinishFormat();
|
|
|
|
|
2016-11-07 09:16:43 +01:00
|
|
|
try {
|
|
|
|
ReopenFormat(std::move(new_path));
|
2017-12-19 10:56:23 +01:00
|
|
|
} catch (...) {
|
|
|
|
LogError(std::current_exception());
|
2015-01-10 08:58:31 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-07 09:20:12 +01:00
|
|
|
encoder->PreTag();
|
|
|
|
EncoderToFile();
|
|
|
|
encoder->SendTag(tag);
|
2014-12-26 14:57:21 +01:00
|
|
|
}
|
|
|
|
|
2017-08-09 16:58:44 +02:00
|
|
|
size_t
|
2016-11-09 11:56:01 +01:00
|
|
|
RecorderOutput::Play(const void *chunk, size_t size)
|
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;
|
|
|
|
}
|
|
|
|
|
2016-11-07 09:20:12 +01:00
|
|
|
encoder->Write(chunk, size);
|
2015-12-16 10:24:43 +01:00
|
|
|
|
2016-11-07 09:16:43 +01:00
|
|
|
EncoderToFile();
|
2015-12-16 10:24:43 +01:00
|
|
|
|
|
|
|
return size;
|
2009-08-24 18:57:06 +02:00
|
|
|
}
|
|
|
|
|
2014-01-28 11:22:27 +01:00
|
|
|
const struct AudioOutputPlugin recorder_output_plugin = {
|
2013-04-16 23:55:26 +02:00
|
|
|
"recorder",
|
|
|
|
nullptr,
|
2017-08-09 16:58:44 +02:00
|
|
|
&RecorderOutput::Create,
|
2013-04-16 23:55:26 +02:00
|
|
|
nullptr,
|
2009-08-24 18:57:06 +02:00
|
|
|
};
|