mpd/src/output/plugins/AoOutputPlugin.cxx

277 lines
5.5 KiB
C++
Raw Normal View History

/*
2016-02-26 17:54:05 +01:00
* Copyright 2003-2016 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-17 00:56:09 +02:00
#include "AoOutputPlugin.hxx"
2014-01-23 23:49:50 +01:00
#include "../OutputAPI.hxx"
#include "util/DivideString.hxx"
#include "util/SplitString.hxx"
#include "util/Error.hxx"
#include "util/Domain.hxx"
#include "Log.hxx"
#include <ao/ao.h>
2008-11-25 16:10:01 +01:00
2013-07-30 20:11:57 +02:00
#include <string.h>
/* An ao_sample_format, with all fields set to zero: */
2013-04-17 00:56:09 +02:00
static ao_sample_format OUR_AO_FORMAT_INITIALIZER;
static unsigned ao_output_ref;
2013-04-17 00:56:09 +02:00
struct AoOutput {
AudioOutput base;
size_t write_size;
int driver;
ao_option *options;
ao_device *device;
2013-04-17 00:56:09 +02:00
AoOutput()
:base(ao_output_plugin) {}
bool Initialize(const ConfigBlock &block, Error &error) {
return base.Configure(block, error);
2013-04-17 00:56:09 +02:00
}
bool Configure(const ConfigBlock &block, Error &error);
2013-04-17 00:56:09 +02:00
};
static constexpr Domain ao_output_domain("ao_output");
static void
ao_output_error(Error &error_r)
{
const char *error;
switch (errno) {
case AO_ENODRIVER:
error = "No such libao driver";
break;
case AO_ENOTLIVE:
error = "This driver is not a libao live device";
break;
case AO_EBADOPTION:
error = "Invalid libao option";
break;
case AO_EOPENDEVICE:
error = "Cannot open the libao device";
break;
case AO_EFAIL:
error = "Generic libao failure";
break;
default:
error_r.SetErrno();
return;
}
error_r.Set(ao_output_domain, errno, error);
}
2013-04-17 00:56:09 +02:00
inline bool
AoOutput::Configure(const ConfigBlock &block, Error &error)
{
const char *value;
2013-04-17 00:56:09 +02:00
options = nullptr;
write_size = block.GetBlockValue("write_size", 1024u);
if (ao_output_ref == 0) {
ao_initialize();
}
ao_output_ref++;
value = block.GetBlockValue("driver", "default");
if (0 == strcmp(value, "default"))
2013-04-17 00:56:09 +02:00
driver = ao_default_driver_id();
else
2013-04-17 00:56:09 +02:00
driver = ao_driver_id(value);
2013-04-17 00:56:09 +02:00
if (driver < 0) {
error.Format(ao_output_domain,
"\"%s\" is not a valid ao driver",
value);
2013-04-17 00:56:09 +02:00
return false;
}
2013-04-17 00:56:09 +02:00
ao_info *ai = ao_driver_info(driver);
if (ai == nullptr) {
error.Set(ao_output_domain, "problems getting driver info");
2013-04-17 00:56:09 +02:00
return false;
}
FormatDebug(ao_output_domain, "using ao driver \"%s\" for \"%s\"\n",
ai->short_name, block.GetBlockValue("name", nullptr));
value = block.GetBlockValue("options", nullptr);
2013-04-17 00:56:09 +02:00
if (value != nullptr) {
for (const auto &i : SplitString(value, ';')) {
2014-12-04 23:05:44 +01:00
const DivideString ss(i.c_str(), '=', true);
if (!ss.IsDefined()) {
error.Format(ao_output_domain,
"problems parsing options \"%s\"",
i.c_str());
2013-04-17 00:56:09 +02:00
return false;
}
ao_append_option(&options, ss.GetFirst(), ss.GetSecond());
}
2013-04-17 00:56:09 +02:00
}
return true;
}
static AudioOutput *
ao_output_init(const ConfigBlock &block, Error &error)
2013-04-17 00:56:09 +02:00
{
AoOutput *ad = new AoOutput();
if (!ad->Initialize(block, error)) {
2013-04-17 00:56:09 +02:00
delete ad;
return nullptr;
}
if (!ad->Configure(block, error)) {
2013-04-17 00:56:09 +02:00
delete ad;
return nullptr;
}
return &ad->base;
}
static void
ao_output_finish(AudioOutput *ao)
{
2013-04-17 00:56:09 +02:00
AoOutput *ad = (AoOutput *)ao;
ao_free_options(ad->options);
2013-04-17 00:56:09 +02:00
delete ad;
ao_output_ref--;
if (ao_output_ref == 0)
ao_shutdown();
}
static void
ao_output_close(AudioOutput *ao)
{
2013-04-17 00:56:09 +02:00
AoOutput *ad = (AoOutput *)ao;
ao_close(ad->device);
}
static bool
ao_output_open(AudioOutput *ao, AudioFormat &audio_format,
Error &error)
{
ao_sample_format format = OUR_AO_FORMAT_INITIALIZER;
2013-04-17 00:56:09 +02:00
AoOutput *ad = (AoOutput *)ao;
2013-08-03 21:00:50 +02:00
switch (audio_format.format) {
case SampleFormat::S8:
format.bits = 8;
break;
2013-08-03 21:00:50 +02:00
case SampleFormat::S16:
format.bits = 16;
break;
default:
/* support for 24 bit samples in libao is currently
dubious, and until we have sorted that out,
convert everything to 16 bit */
2013-08-03 21:00:50 +02:00
audio_format.format = SampleFormat::S16;
format.bits = 16;
break;
}
2013-08-03 21:00:50 +02:00
format.rate = audio_format.sample_rate;
format.byte_format = AO_FMT_NATIVE;
2013-08-03 21:00:50 +02:00
format.channels = audio_format.channels;
ad->device = ao_open_live(ad->driver, &format, ad->options);
2013-04-17 00:56:09 +02:00
if (ad->device == nullptr) {
ao_output_error(error);
return false;
}
return true;
}
/**
* For whatever reason, libao wants a non-const pointer. Let's hope
* it does not write to the buffer, and use the union deconst hack to
* work around this API misdesign.
*/
static int ao_play_deconst(ao_device *device, const void *output_samples,
uint_32 num_bytes)
{
union {
const void *in;
2013-04-17 00:56:09 +02:00
char *out;
} u;
u.in = output_samples;
return ao_play(device, u.out, num_bytes);
}
static size_t
ao_output_play(AudioOutput *ao, const void *chunk, size_t size,
Error &error)
{
2013-04-17 00:56:09 +02:00
AoOutput *ad = (AoOutput *)ao;
if (size > ad->write_size)
size = ad->write_size;
if (ao_play_deconst(ad->device, chunk, size) == 0) {
ao_output_error(error);
return 0;
}
return size;
}
const struct AudioOutputPlugin ao_output_plugin = {
2013-04-17 00:56:09 +02:00
"ao",
nullptr,
ao_output_init,
ao_output_finish,
nullptr,
nullptr,
ao_output_open,
ao_output_close,
nullptr,
nullptr,
ao_output_play,
nullptr,
nullptr,
nullptr,
nullptr,
};