output/shout: convert to C++
This commit is contained in:
Max Kellermann
564
src/output/ShoutOutputPlugin.cxx
Normal file
564
src/output/ShoutOutputPlugin.cxx
Normal file
@@ -0,0 +1,564 @@
|
||||
/*
|
||||
* Copyright (C) 2003-2013 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"
|
||||
#include "ShoutOutputPlugin.hxx"
|
||||
#include "output_api.h"
|
||||
#include "encoder_plugin.h"
|
||||
#include "encoder_list.h"
|
||||
#include "mpd_error.h"
|
||||
|
||||
#include <shout/shout.h>
|
||||
#include <glib.h>
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#undef G_LOG_DOMAIN
|
||||
#define G_LOG_DOMAIN "shout"
|
||||
|
||||
#define DEFAULT_CONN_TIMEOUT 2
|
||||
|
||||
struct ShoutOutput final {
|
||||
struct audio_output base;
|
||||
|
||||
shout_t *shout_conn;
|
||||
shout_metadata_t *shout_meta;
|
||||
|
||||
struct encoder *encoder;
|
||||
|
||||
float quality;
|
||||
int bitrate;
|
||||
|
||||
int timeout;
|
||||
|
||||
uint8_t buffer[32768];
|
||||
|
||||
ShoutOutput()
|
||||
:shout_conn(shout_new()),
|
||||
shout_meta(shout_metadata_new()),
|
||||
quality(-2.0),
|
||||
bitrate(-1),
|
||||
timeout(DEFAULT_CONN_TIMEOUT) {}
|
||||
|
||||
~ShoutOutput() {
|
||||
if (shout_meta != nullptr)
|
||||
shout_metadata_free(shout_meta);
|
||||
if (shout_conn != nullptr)
|
||||
shout_free(shout_conn);
|
||||
}
|
||||
|
||||
bool Initialize(const config_param *param, GError **error_r) {
|
||||
return ao_base_init(&base, &shout_output_plugin, param,
|
||||
error_r);
|
||||
}
|
||||
|
||||
void Deinitialize() {
|
||||
ao_base_finish(&base);
|
||||
}
|
||||
|
||||
bool Configure(const config_param *param, GError **error_r);
|
||||
};
|
||||
|
||||
static int shout_init_count;
|
||||
|
||||
/**
|
||||
* The quark used for GError.domain.
|
||||
*/
|
||||
static inline GQuark
|
||||
shout_output_quark(void)
|
||||
{
|
||||
return g_quark_from_static_string("shout_output");
|
||||
}
|
||||
|
||||
static const struct encoder_plugin *
|
||||
shout_encoder_plugin_get(const char *name)
|
||||
{
|
||||
if (strcmp(name, "ogg") == 0)
|
||||
name = "vorbis";
|
||||
else if (strcmp(name, "mp3") == 0)
|
||||
name = "lame";
|
||||
|
||||
return encoder_plugin_get(name);
|
||||
}
|
||||
|
||||
gcc_pure
|
||||
static const char *
|
||||
require_block_string(const struct config_param *param, const char *name)
|
||||
{
|
||||
const char *value = config_get_block_string(param, name, nullptr);
|
||||
if (value == nullptr)
|
||||
MPD_ERROR("no \"%s\" defined for shout device defined at line " \
|
||||
"%i\n", name, param->line); \
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
inline bool
|
||||
ShoutOutput::Configure(const config_param *param, GError **error_r)
|
||||
{
|
||||
|
||||
const struct audio_format *audio_format =
|
||||
&base.config_audio_format;
|
||||
if (!audio_format_fully_defined(audio_format)) {
|
||||
g_set_error(error_r, shout_output_quark(), 0,
|
||||
"Need full audio format specification");
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const char *host = require_block_string(param, "host");
|
||||
const char *mount = require_block_string(param, "mount");
|
||||
|
||||
unsigned port = config_get_block_unsigned(param, "port", 0);
|
||||
if (port == 0) {
|
||||
g_set_error(error_r, shout_output_quark(), 0,
|
||||
"shout port must be configured");
|
||||
return false;
|
||||
}
|
||||
|
||||
const char *passwd = require_block_string(param, "password");
|
||||
const char *name = require_block_string(param, "name");
|
||||
|
||||
bool is_public = config_get_block_bool(param, "public", false);
|
||||
|
||||
const char *user = config_get_block_string(param, "user", "source");
|
||||
|
||||
const char *value = config_get_block_string(param, "quality", nullptr);
|
||||
if (value != nullptr) {
|
||||
char *test;
|
||||
quality = strtod(value, &test);
|
||||
|
||||
if (*test != '\0' || quality < -1.0 || quality > 10.0) {
|
||||
g_set_error(error_r, shout_output_quark(), 0,
|
||||
"shout quality \"%s\" is not a number in the "
|
||||
"range -1 to 10, line %i",
|
||||
value, param->line);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (config_get_block_string(param, "bitrate", nullptr) != nullptr) {
|
||||
g_set_error(error_r, shout_output_quark(), 0,
|
||||
"quality and bitrate are "
|
||||
"both defined");
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
value = config_get_block_string(param, "bitrate", nullptr);
|
||||
if (value == nullptr) {
|
||||
g_set_error(error_r, shout_output_quark(), 0,
|
||||
"neither bitrate nor quality defined");
|
||||
return false;
|
||||
}
|
||||
|
||||
char *test;
|
||||
bitrate = strtol(value, &test, 10);
|
||||
|
||||
if (*test != '\0' || bitrate <= 0) {
|
||||
g_set_error(error_r, shout_output_quark(), 0,
|
||||
"bitrate must be a positive integer");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
const char *encoding = config_get_block_string(param, "encoding",
|
||||
"ogg");
|
||||
const struct encoder_plugin *encoder_plugin =
|
||||
shout_encoder_plugin_get(encoding);
|
||||
if (encoder_plugin == nullptr) {
|
||||
g_set_error(error_r, shout_output_quark(), 0,
|
||||
"couldn't find shout encoder plugin \"%s\"",
|
||||
encoding);
|
||||
return false;
|
||||
}
|
||||
|
||||
encoder = encoder_init(encoder_plugin, param, error_r);
|
||||
if (encoder == nullptr)
|
||||
return false;
|
||||
|
||||
unsigned shout_format;
|
||||
if (strcmp(encoding, "mp3") == 0 || strcmp(encoding, "lame") == 0)
|
||||
shout_format = SHOUT_FORMAT_MP3;
|
||||
else
|
||||
shout_format = SHOUT_FORMAT_OGG;
|
||||
|
||||
unsigned protocol;
|
||||
value = config_get_block_string(param, "protocol", nullptr);
|
||||
if (value != nullptr) {
|
||||
if (0 == strcmp(value, "shoutcast") &&
|
||||
0 != strcmp(encoding, "mp3")) {
|
||||
g_set_error(error_r, shout_output_quark(), 0,
|
||||
"you cannot stream \"%s\" to shoutcast, use mp3",
|
||||
encoding);
|
||||
return false;
|
||||
} else if (0 == strcmp(value, "shoutcast"))
|
||||
protocol = SHOUT_PROTOCOL_ICY;
|
||||
else if (0 == strcmp(value, "icecast1"))
|
||||
protocol = SHOUT_PROTOCOL_XAUDIOCAST;
|
||||
else if (0 == strcmp(value, "icecast2"))
|
||||
protocol = SHOUT_PROTOCOL_HTTP;
|
||||
else {
|
||||
g_set_error(error_r, shout_output_quark(), 0,
|
||||
"shout protocol \"%s\" is not \"shoutcast\" or "
|
||||
"\"icecast1\"or \"icecast2\"",
|
||||
value);
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
protocol = SHOUT_PROTOCOL_HTTP;
|
||||
}
|
||||
|
||||
if (shout_set_host(shout_conn, host) != SHOUTERR_SUCCESS ||
|
||||
shout_set_port(shout_conn, port) != SHOUTERR_SUCCESS ||
|
||||
shout_set_password(shout_conn, passwd) != SHOUTERR_SUCCESS ||
|
||||
shout_set_mount(shout_conn, mount) != SHOUTERR_SUCCESS ||
|
||||
shout_set_name(shout_conn, name) != SHOUTERR_SUCCESS ||
|
||||
shout_set_user(shout_conn, user) != SHOUTERR_SUCCESS ||
|
||||
shout_set_public(shout_conn, is_public) != SHOUTERR_SUCCESS ||
|
||||
shout_set_format(shout_conn, shout_format)
|
||||
!= SHOUTERR_SUCCESS ||
|
||||
shout_set_protocol(shout_conn, protocol) != SHOUTERR_SUCCESS ||
|
||||
shout_set_agent(shout_conn, "MPD") != SHOUTERR_SUCCESS) {
|
||||
g_set_error(error_r, shout_output_quark(), 0,
|
||||
"%s", shout_get_error(shout_conn));
|
||||
return false;
|
||||
}
|
||||
|
||||
/* optional paramters */
|
||||
timeout = config_get_block_unsigned(param, "timeout",
|
||||
DEFAULT_CONN_TIMEOUT);
|
||||
|
||||
value = config_get_block_string(param, "genre", nullptr);
|
||||
if (value != nullptr && shout_set_genre(shout_conn, value)) {
|
||||
g_set_error(error_r, shout_output_quark(), 0,
|
||||
"%s", shout_get_error(shout_conn));
|
||||
return false;
|
||||
}
|
||||
|
||||
value = config_get_block_string(param, "description", nullptr);
|
||||
if (value != nullptr && shout_set_description(shout_conn, value)) {
|
||||
g_set_error(error_r, shout_output_quark(), 0,
|
||||
"%s", shout_get_error(shout_conn));
|
||||
return false;
|
||||
}
|
||||
|
||||
value = config_get_block_string(param, "url", nullptr);
|
||||
if (value != nullptr && shout_set_url(shout_conn, value)) {
|
||||
g_set_error(error_r, shout_output_quark(), 0,
|
||||
"%s", shout_get_error(shout_conn));
|
||||
return false;
|
||||
}
|
||||
|
||||
{
|
||||
char temp[11];
|
||||
memset(temp, 0, sizeof(temp));
|
||||
|
||||
snprintf(temp, sizeof(temp), "%u", audio_format->channels);
|
||||
shout_set_audio_info(shout_conn, SHOUT_AI_CHANNELS, temp);
|
||||
|
||||
snprintf(temp, sizeof(temp), "%u", audio_format->sample_rate);
|
||||
|
||||
shout_set_audio_info(shout_conn, SHOUT_AI_SAMPLERATE, temp);
|
||||
|
||||
if (quality >= -1.0) {
|
||||
snprintf(temp, sizeof(temp), "%2.2f", quality);
|
||||
shout_set_audio_info(shout_conn, SHOUT_AI_QUALITY,
|
||||
temp);
|
||||
} else {
|
||||
snprintf(temp, sizeof(temp), "%d", bitrate);
|
||||
shout_set_audio_info(shout_conn, SHOUT_AI_BITRATE,
|
||||
temp);
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static struct audio_output *
|
||||
my_shout_init_driver(const config_param *param, GError **error_r)
|
||||
{
|
||||
ShoutOutput *sd = new ShoutOutput();
|
||||
if (!sd->Initialize(param, error_r)) {
|
||||
delete sd;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (!sd->Configure(param, error_r)) {
|
||||
sd->Deinitialize();
|
||||
delete sd;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (shout_init_count == 0)
|
||||
shout_init();
|
||||
|
||||
shout_init_count++;
|
||||
|
||||
return &sd->base;
|
||||
}
|
||||
|
||||
static bool
|
||||
handle_shout_error(ShoutOutput *sd, int err, GError **error)
|
||||
{
|
||||
switch (err) {
|
||||
case SHOUTERR_SUCCESS:
|
||||
break;
|
||||
|
||||
case SHOUTERR_UNCONNECTED:
|
||||
case SHOUTERR_SOCKET:
|
||||
g_set_error(error, shout_output_quark(), err,
|
||||
"Lost shout connection to %s:%i: %s",
|
||||
shout_get_host(sd->shout_conn),
|
||||
shout_get_port(sd->shout_conn),
|
||||
shout_get_error(sd->shout_conn));
|
||||
return false;
|
||||
|
||||
default:
|
||||
g_set_error(error, shout_output_quark(), err,
|
||||
"connection to %s:%i error: %s",
|
||||
shout_get_host(sd->shout_conn),
|
||||
shout_get_port(sd->shout_conn),
|
||||
shout_get_error(sd->shout_conn));
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool
|
||||
write_page(ShoutOutput *sd, GError **error)
|
||||
{
|
||||
assert(sd->encoder != nullptr);
|
||||
|
||||
while (true) {
|
||||
size_t nbytes = encoder_read(sd->encoder,
|
||||
sd->buffer, sizeof(sd->buffer));
|
||||
if (nbytes == 0)
|
||||
return true;
|
||||
|
||||
int err = shout_send(sd->shout_conn, sd->buffer, nbytes);
|
||||
if (!handle_shout_error(sd, err, error))
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static void close_shout_conn(ShoutOutput * sd)
|
||||
{
|
||||
if (sd->encoder != nullptr) {
|
||||
if (encoder_end(sd->encoder, nullptr))
|
||||
write_page(sd, nullptr);
|
||||
|
||||
encoder_close(sd->encoder);
|
||||
}
|
||||
|
||||
if (shout_get_connected(sd->shout_conn) != SHOUTERR_UNCONNECTED &&
|
||||
shout_close(sd->shout_conn) != SHOUTERR_SUCCESS) {
|
||||
g_warning("problem closing connection to shout server: %s\n",
|
||||
shout_get_error(sd->shout_conn));
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
my_shout_finish_driver(struct audio_output *ao)
|
||||
{
|
||||
ShoutOutput *sd = (ShoutOutput *)ao;
|
||||
|
||||
encoder_finish(sd->encoder);
|
||||
|
||||
sd->Deinitialize();
|
||||
delete sd;
|
||||
|
||||
shout_init_count--;
|
||||
|
||||
if (shout_init_count == 0)
|
||||
shout_shutdown();
|
||||
}
|
||||
|
||||
static void
|
||||
my_shout_drop_buffered_audio(struct audio_output *ao)
|
||||
{
|
||||
G_GNUC_UNUSED
|
||||
ShoutOutput *sd = (ShoutOutput *)ao;
|
||||
|
||||
/* needs to be implemented for shout */
|
||||
}
|
||||
|
||||
static void
|
||||
my_shout_close_device(struct audio_output *ao)
|
||||
{
|
||||
ShoutOutput *sd = (ShoutOutput *)ao;
|
||||
|
||||
close_shout_conn(sd);
|
||||
}
|
||||
|
||||
static bool
|
||||
shout_connect(ShoutOutput *sd, GError **error)
|
||||
{
|
||||
switch (shout_open(sd->shout_conn)) {
|
||||
case SHOUTERR_SUCCESS:
|
||||
case SHOUTERR_CONNECTED:
|
||||
return true;
|
||||
|
||||
default:
|
||||
g_set_error(error, shout_output_quark(), 0,
|
||||
"problem opening connection to shout server %s:%i: %s",
|
||||
shout_get_host(sd->shout_conn),
|
||||
shout_get_port(sd->shout_conn),
|
||||
shout_get_error(sd->shout_conn));
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
static bool
|
||||
my_shout_open_device(struct audio_output *ao, struct audio_format *audio_format,
|
||||
GError **error)
|
||||
{
|
||||
ShoutOutput *sd = (ShoutOutput *)ao;
|
||||
|
||||
if (!shout_connect(sd, error))
|
||||
return false;
|
||||
|
||||
if (!encoder_open(sd->encoder, audio_format, error)) {
|
||||
shout_close(sd->shout_conn);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!write_page(sd, error)) {
|
||||
encoder_close(sd->encoder);
|
||||
shout_close(sd->shout_conn);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static unsigned
|
||||
my_shout_delay(struct audio_output *ao)
|
||||
{
|
||||
ShoutOutput *sd = (ShoutOutput *)ao;
|
||||
|
||||
int delay = shout_delay(sd->shout_conn);
|
||||
if (delay < 0)
|
||||
delay = 0;
|
||||
|
||||
return delay;
|
||||
}
|
||||
|
||||
static size_t
|
||||
my_shout_play(struct audio_output *ao, const void *chunk, size_t size,
|
||||
GError **error)
|
||||
{
|
||||
ShoutOutput *sd = (ShoutOutput *)ao;
|
||||
|
||||
return encoder_write(sd->encoder, chunk, size, error) &&
|
||||
write_page(sd, error)
|
||||
? size
|
||||
: 0;
|
||||
}
|
||||
|
||||
static bool
|
||||
my_shout_pause(struct audio_output *ao)
|
||||
{
|
||||
static char silence[1020];
|
||||
|
||||
return my_shout_play(ao, silence, sizeof(silence), nullptr);
|
||||
}
|
||||
|
||||
static void
|
||||
shout_tag_to_metadata(const struct tag *tag, char *dest, size_t size)
|
||||
{
|
||||
char artist[size];
|
||||
char title[size];
|
||||
|
||||
artist[0] = 0;
|
||||
title[0] = 0;
|
||||
|
||||
for (unsigned i = 0; i < tag->num_items; i++) {
|
||||
switch (tag->items[i]->type) {
|
||||
case TAG_ARTIST:
|
||||
strncpy(artist, tag->items[i]->value, size);
|
||||
break;
|
||||
case TAG_TITLE:
|
||||
strncpy(title, tag->items[i]->value, size);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
snprintf(dest, size, "%s - %s", artist, title);
|
||||
}
|
||||
|
||||
static void my_shout_set_tag(struct audio_output *ao,
|
||||
const struct tag *tag)
|
||||
{
|
||||
ShoutOutput *sd = (ShoutOutput *)ao;
|
||||
GError *error = nullptr;
|
||||
|
||||
if (sd->encoder->plugin->tag != nullptr) {
|
||||
/* encoder plugin supports stream tags */
|
||||
|
||||
if (!encoder_pre_tag(sd->encoder, &error)) {
|
||||
g_warning("%s", error->message);
|
||||
g_error_free(error);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!write_page(sd, nullptr))
|
||||
return;
|
||||
|
||||
if (!encoder_tag(sd->encoder, tag, &error)) {
|
||||
g_warning("%s", error->message);
|
||||
g_error_free(error);
|
||||
}
|
||||
} else {
|
||||
/* no stream tag support: fall back to icy-metadata */
|
||||
char song[1024];
|
||||
shout_tag_to_metadata(tag, song, sizeof(song));
|
||||
|
||||
shout_metadata_add(sd->shout_meta, "song", song);
|
||||
if (SHOUTERR_SUCCESS != shout_set_metadata(sd->shout_conn,
|
||||
sd->shout_meta)) {
|
||||
g_warning("error setting shout metadata\n");
|
||||
}
|
||||
}
|
||||
|
||||
write_page(sd, nullptr);
|
||||
}
|
||||
|
||||
const struct audio_output_plugin shout_output_plugin = {
|
||||
"shout",
|
||||
nullptr,
|
||||
my_shout_init_driver,
|
||||
my_shout_finish_driver,
|
||||
nullptr,
|
||||
nullptr,
|
||||
my_shout_open_device,
|
||||
my_shout_close_device,
|
||||
my_shout_delay,
|
||||
my_shout_set_tag,
|
||||
my_shout_play,
|
||||
nullptr,
|
||||
my_shout_drop_buffered_audio,
|
||||
my_shout_pause,
|
||||
nullptr,
|
||||
};
|
||||
Reference in New Issue
Block a user