static void
alsa_configure(struct alsa_data *ad, const struct config_param *param)
{
ad->device = config_dup_block_string(param, "device", NULL);
ad->use_mmap = config_get_block_bool(param, "use_mmap", false);
ad->buffer_time = config_get_block_unsigned(param, "buffer_time",
MPD_ALSA_BUFFER_TIME_US);
ad->period_time = config_get_block_unsigned(param, "period_time", 0);
#ifdef SND_PCM_NO_AUTO_RESAMPLE
if (!config_get_block_bool(param, "auto_resample", true))
ad->mode |= SND_PCM_NO_AUTO_RESAMPLE;
#endif
#ifdef SND_PCM_NO_AUTO_CHANNELS
if (!config_get_block_bool(param, "auto_channels", true))
ad->mode |= SND_PCM_NO_AUTO_CHANNELS;
#endif
#ifdef SND_PCM_NO_AUTO_FORMAT
if (!config_get_block_bool(param, "auto_format", true))
ad->mode |= SND_PCM_NO_AUTO_FORMAT;
#endif
}
static bool
input_curl_init(const struct config_param *param,
G_GNUC_UNUSED GError **error_r)
{
CURLcode code = curl_global_init(CURL_GLOBAL_ALL);
if (code != CURLE_OK) {
g_warning("curl_global_init() failed: %s\n",
curl_easy_strerror(code));
return false;
}
http_200_aliases = curl_slist_append(http_200_aliases, "ICY 200 OK");
proxy = config_get_block_string(param, "proxy", NULL);
proxy_port = config_get_block_unsigned(param, "proxy_port", 0);
proxy_user = config_get_block_string(param, "proxy_user", NULL);
proxy_password = config_get_block_string(param, "proxy_password",
NULL);
if (proxy == NULL) {
/* deprecated proxy configuration */
proxy = config_get_string(CONF_HTTP_PROXY_HOST, NULL);
proxy_port = config_get_positive(CONF_HTTP_PROXY_PORT, 0);
proxy_user = config_get_string(CONF_HTTP_PROXY_USER, NULL);
proxy_password = config_get_string(CONF_HTTP_PROXY_PASSWORD,
"");
}
return true;
}
static bool
flac_encoder_configure(struct flac_encoder *encoder,
const struct config_param *param, G_GNUC_UNUSED GError **error)
{
encoder->compression = config_get_block_unsigned(param,
"compression", 5);
return true;
}
static void *
my_shout_init_driver(const struct audio_format *audio_format,
const struct config_param *param,
GError **error)
{
struct shout_data *sd;
char *test;
unsigned port;
char *host;
char *mount;
char *passwd;
const char *encoding;
const struct encoder_plugin *encoder_plugin;
unsigned shout_format;
unsigned protocol;
const char *user;
char *name;
const char *value;
struct block_param *block_param;
int public;
if (audio_format == NULL ||
!audio_format_fully_defined(audio_format)) {
g_set_error(error, shout_output_quark(), 0,
"Need full audio format specification");
return NULL;
}
sd = new_shout_data();
if (shout_init_count == 0)
shout_init();
shout_init_count++;
check_block_param("host");
host = block_param->value;
check_block_param("mount");
mount = block_param->value;
port = config_get_block_unsigned(param, "port", 0);
if (port == 0) {
g_set_error(error, shout_output_quark(), 0,
"shout port must be configured");
return NULL;
}
check_block_param("password");
passwd = block_param->value;
check_block_param("name");
name = block_param->value;
public = config_get_block_bool(param, "public", false);
static void *
httpd_output_init(G_GNUC_UNUSED const struct audio_format *audio_format,
const struct config_param *param,
GError **error)
{
struct httpd_output *httpd = g_new(struct httpd_output, 1);
const char *encoder_name;
const struct encoder_plugin *encoder_plugin;
guint port;
struct sockaddr_in *sin;
/* read configuration */
port = config_get_block_unsigned(param, "port", 8000);
encoder_name = config_get_block_string(param, "encoder", "vorbis");
encoder_plugin = encoder_plugin_get(encoder_name);
if (encoder_plugin == NULL) {
g_set_error(error, httpd_output_quark(), 0,
"No such encoder: %s", encoder_name);
return NULL;
}
if (strcmp(encoder_name, "vorbis") == 0)
httpd->content_type = "application/x-ogg";
else if (strcmp(encoder_name, "lame") == 0)
httpd->content_type = "audio/mpeg";
else
httpd->content_type = "application/octet-stream";
/* initialize listen address */
sin = (struct sockaddr_in *)&httpd->address;
memset(sin, 0, sizeof(sin));
sin->sin_port = htons(port);
sin->sin_family = AF_INET;
sin->sin_addr.s_addr = INADDR_ANY;
httpd->address_size = sizeof(*sin);
/* initialize encoder */
httpd->encoder = encoder_init(encoder_plugin, param, error);
if (httpd->encoder == NULL)
return NULL;
httpd->mutex = g_mutex_new();
return httpd;
}
static struct mixer *
alsa_mixer_init(G_GNUC_UNUSED void *ao, const struct config_param *param,
G_GNUC_UNUSED GError **error_r)
{
struct alsa_mixer *am = g_new(struct alsa_mixer, 1);
mixer_init(&am->base, &alsa_mixer_plugin);
am->device = config_get_block_string(param, "mixer_device",
VOLUME_MIXER_ALSA_DEFAULT);
am->control = config_get_block_string(param, "mixer_control",
VOLUME_MIXER_ALSA_CONTROL_DEFAULT);
am->index = config_get_block_unsigned(param, "mixer_index",
VOLUME_MIXER_ALSA_INDEX_DEFAULT);
return &am->base;
}
static bool
fluidsynth_init(const struct config_param *param)
{
GError *error = NULL;
sample_rate = config_get_block_unsigned(param, "sample_rate", 48000);
if (!audio_check_sample_rate(sample_rate, &error)) {
g_warning("%s\n", error->message);
g_error_free(error);
return false;
}
soundfont_path =
config_get_block_string(param, "soundfont",
"/usr/share/sounds/sf2/FluidR3_GM.sf2");
fluid_set_log_function(LAST_LOG_LEVEL,
fluidsynth_mpd_log_function, NULL);
return true;
}
static struct audio_output *
ao_output_init(const struct config_param *param,
GError **error)
{
struct ao_data *ad = g_new(struct ao_data, 1);
if (!ao_base_init(&ad->base, &ao_output_plugin, param, error)) {
g_free(ad);
return NULL;
}
ao_info *ai;
const char *value;
ad->options = NULL;
ad->write_size = config_get_block_unsigned(param, "write_size", 1024);
if (ao_output_ref == 0) {
ao_initialize();
}
ao_output_ref++;
value = config_get_block_string(param, "driver", "default");
if (0 == strcmp(value, "default"))
ad->driver = ao_default_driver_id();
else
ad->driver = ao_driver_id(value);
if (ad->driver < 0) {
g_set_error(error, ao_output_quark(), 0,
"\"%s\" is not a valid ao driver",
value);
ao_base_finish(&ad->base);
g_free(ad);
return NULL;
}
if ((ai = ao_driver_info(ad->driver)) == NULL) {
g_set_error(error, ao_output_quark(), 0,
"problems getting driver info");
ao_base_finish(&ad->base);
g_free(ad);
return NULL;
}
g_debug("using ao driver \"%s\" for \"%s\"\n", ai->short_name,
config_get_block_string(param, "name", NULL));
value = config_get_block_string(param, "options", NULL);
if (value != NULL) {
gchar **options = g_strsplit(value, ";", 0);
for (unsigned i = 0; options[i] != NULL; ++i) {
gchar **key_value = g_strsplit(options[i], "=", 2);
if (key_value[0] == NULL || key_value[1] == NULL) {
g_set_error(error, ao_output_quark(), 0,
"problems parsing options \"%s\"",
options[i]);
ao_base_finish(&ad->base);
g_free(ad);
return NULL;
}
ao_append_option(&ad->options, key_value[0],
key_value[1]);
g_strfreev(key_value);
}
g_strfreev(options);
}
return &ad->base;
}
static struct audio_output *
httpd_output_init(const struct config_param *param,
GError **error)
{
struct httpd_output *httpd = g_new(struct httpd_output, 1);
if (!ao_base_init(&httpd->base, &httpd_output_plugin, param, error)) {
g_free(httpd);
return NULL;
}
const char *encoder_name, *bind_to_address;
const struct encoder_plugin *encoder_plugin;
guint port;
/* read configuration */
httpd->name =
config_get_block_string(param, "name", "Set name in config");
httpd->genre =
config_get_block_string(param, "genre", "Set genre in config");
httpd->website =
config_get_block_string(param, "website", "Set website in config");
port = config_get_block_unsigned(param, "port", 8000);
encoder_name = config_get_block_string(param, "encoder", "vorbis");
encoder_plugin = encoder_plugin_get(encoder_name);
if (encoder_plugin == NULL) {
g_set_error(error, httpd_output_quark(), 0,
"No such encoder: %s", encoder_name);
ao_base_finish(&httpd->base);
g_free(httpd);
return NULL;
}
httpd->clients_max = config_get_block_unsigned(param,"max_clients", 0);
/* set up bind_to_address */
httpd->server_socket = server_socket_new(httpd_listen_in_event, httpd);
bind_to_address =
config_get_block_string(param, "bind_to_address", NULL);
bool success = bind_to_address != NULL &&
strcmp(bind_to_address, "any") != 0
? server_socket_add_host(httpd->server_socket, bind_to_address,
port, error)
: server_socket_add_port(httpd->server_socket, port, error);
if (!success) {
ao_base_finish(&httpd->base);
g_free(httpd);
return NULL;
}
/* initialize metadata */
httpd->metadata = NULL;
httpd->unflushed_input = 0;
/* initialize encoder */
httpd->encoder = encoder_init(encoder_plugin, param, error);
if (httpd->encoder == NULL) {
ao_base_finish(&httpd->base);
g_free(httpd);
return NULL;
}
/* determine content type */
httpd->content_type = encoder_get_mime_type(httpd->encoder);
if (httpd->content_type == NULL) {
httpd->content_type = "application/octet-stream";
}
httpd->mutex = g_mutex_new();
return &httpd->base;
}