2011-02-08 00:17:58 +01:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2003-2010 The Music Player Daemon Project
|
|
|
|
* Copyright (C) 2010-2011 Philipp 'ph3-der-loewe' Schafft
|
|
|
|
* Copyright (C) 2010-2011 Hans-Kristian 'maister' Arntzen
|
|
|
|
*
|
|
|
|
* 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"
|
2011-09-17 08:54:28 +02:00
|
|
|
#include "roar_output_plugin.h"
|
2011-02-08 00:17:58 +01:00
|
|
|
#include "output_api.h"
|
|
|
|
#include "mixer_list.h"
|
|
|
|
#include "roar_output_plugin.h"
|
|
|
|
|
|
|
|
#include <glib.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
|
2011-09-17 19:33:51 +02:00
|
|
|
#include <roaraudio.h>
|
2011-02-08 00:17:58 +01:00
|
|
|
|
|
|
|
#undef G_LOG_DOMAIN
|
|
|
|
#define G_LOG_DOMAIN "roaraudio"
|
|
|
|
|
2011-09-17 19:33:51 +02:00
|
|
|
typedef struct roar
|
|
|
|
{
|
2011-09-16 23:31:48 +02:00
|
|
|
struct audio_output base;
|
|
|
|
|
2011-09-17 19:33:51 +02:00
|
|
|
roar_vs_t * vss;
|
|
|
|
int err;
|
|
|
|
char *host;
|
|
|
|
char *name;
|
|
|
|
int role;
|
|
|
|
struct roar_connection con;
|
|
|
|
struct roar_audio_info info;
|
|
|
|
GMutex *lock;
|
|
|
|
volatile bool alive;
|
|
|
|
} roar_t;
|
|
|
|
|
2011-02-08 00:17:58 +01:00
|
|
|
static inline GQuark
|
|
|
|
roar_output_quark(void)
|
|
|
|
{
|
|
|
|
return g_quark_from_static_string("roar_output");
|
|
|
|
}
|
|
|
|
|
2011-09-18 11:51:18 +02:00
|
|
|
static int
|
|
|
|
roar_output_get_volume_locked(struct roar *roar)
|
|
|
|
{
|
|
|
|
if (roar->vss == NULL || !roar->alive)
|
2011-09-18 12:06:46 +02:00
|
|
|
return -1;
|
2011-09-18 11:51:18 +02:00
|
|
|
|
|
|
|
float l, r;
|
|
|
|
int error;
|
2011-09-18 11:54:14 +02:00
|
|
|
if (roar_vs_volume_get(roar->vss, &l, &r, &error) < 0)
|
|
|
|
return -1;
|
|
|
|
|
2011-09-18 11:51:18 +02:00
|
|
|
return (l + r) * 50;
|
|
|
|
}
|
|
|
|
|
2011-09-17 19:33:51 +02:00
|
|
|
int
|
|
|
|
roar_output_get_volume(struct roar *roar)
|
|
|
|
{
|
|
|
|
g_mutex_lock(roar->lock);
|
2011-09-18 11:51:18 +02:00
|
|
|
int volume = roar_output_get_volume_locked(roar);
|
|
|
|
g_mutex_unlock(roar->lock);
|
|
|
|
return volume;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
roar_output_set_volume_locked(struct roar *roar, unsigned volume)
|
|
|
|
{
|
|
|
|
assert(volume <= 100);
|
|
|
|
|
|
|
|
if (roar->vss == NULL || !roar->alive)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
int error;
|
|
|
|
float level = volume / 100.0;
|
|
|
|
|
|
|
|
roar_vs_volume_mono(roar->vss, level, &error);
|
|
|
|
return true;
|
2011-09-17 19:33:51 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
roar_output_set_volume(struct roar *roar, unsigned volume)
|
|
|
|
{
|
|
|
|
g_mutex_lock(roar->lock);
|
2011-09-18 11:51:18 +02:00
|
|
|
bool success = roar_output_set_volume_locked(roar, volume);
|
|
|
|
g_mutex_unlock(roar->lock);
|
|
|
|
return success;
|
2011-09-17 19:33:51 +02:00
|
|
|
}
|
|
|
|
|
2011-02-08 00:17:58 +01:00
|
|
|
static void
|
|
|
|
roar_configure(struct roar * self, const struct config_param *param)
|
|
|
|
{
|
|
|
|
self->host = config_dup_block_string(param, "server", NULL);
|
|
|
|
self->name = config_dup_block_string(param, "name", "MPD");
|
2011-09-17 20:11:51 +02:00
|
|
|
|
|
|
|
const char *role = config_get_block_string(param, "role", "music");
|
|
|
|
self->role = role != NULL
|
|
|
|
? roar_str2role(role)
|
|
|
|
: ROAR_ROLE_MUSIC;
|
2011-02-08 00:17:58 +01:00
|
|
|
}
|
|
|
|
|
2011-09-16 23:31:48 +02:00
|
|
|
static struct audio_output *
|
|
|
|
roar_init(const struct config_param *param, GError **error_r)
|
2011-02-08 00:17:58 +01:00
|
|
|
{
|
2011-09-17 20:12:45 +02:00
|
|
|
struct roar *self = g_new0(struct roar, 1);
|
2011-09-16 23:31:48 +02:00
|
|
|
|
|
|
|
if (!ao_base_init(&self->base, &roar_output_plugin, param, error_r)) {
|
|
|
|
g_free(self);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-09-17 20:12:45 +02:00
|
|
|
self->lock = g_mutex_new();
|
2011-02-08 00:17:58 +01:00
|
|
|
self->err = ROAR_ERROR_NONE;
|
|
|
|
roar_configure(self, param);
|
2011-09-16 23:31:48 +02:00
|
|
|
return &self->base;
|
2011-02-08 00:17:58 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-09-16 23:31:48 +02:00
|
|
|
roar_finish(struct audio_output *ao)
|
2011-02-08 00:17:58 +01:00
|
|
|
{
|
2011-09-16 23:31:48 +02:00
|
|
|
struct roar *self = (struct roar *)ao;
|
2011-02-08 00:17:58 +01:00
|
|
|
|
|
|
|
g_free(self->host);
|
|
|
|
g_free(self->name);
|
|
|
|
g_mutex_free(self->lock);
|
|
|
|
|
2011-09-16 23:31:48 +02:00
|
|
|
ao_base_finish(&self->base);
|
2011-09-17 20:12:45 +02:00
|
|
|
g_free(self);
|
2011-02-08 00:17:58 +01:00
|
|
|
}
|
|
|
|
|
2011-10-08 14:46:17 +02:00
|
|
|
static void
|
|
|
|
roar_use_audio_format(struct roar_audio_info *info,
|
|
|
|
struct audio_format *audio_format)
|
|
|
|
{
|
|
|
|
info->rate = audio_format->sample_rate;
|
|
|
|
info->channels = audio_format->channels;
|
|
|
|
info->codec = ROAR_CODEC_PCM_S;
|
|
|
|
|
|
|
|
switch (audio_format->format) {
|
|
|
|
case SAMPLE_FORMAT_UNDEFINED:
|
|
|
|
info->bits = 16;
|
|
|
|
audio_format->format = SAMPLE_FORMAT_S16;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SAMPLE_FORMAT_S8:
|
|
|
|
info->bits = 8;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SAMPLE_FORMAT_S16:
|
|
|
|
info->bits = 16;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SAMPLE_FORMAT_S24_P32:
|
|
|
|
info->bits = 32;
|
|
|
|
audio_format->format = SAMPLE_FORMAT_S32;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SAMPLE_FORMAT_S32:
|
|
|
|
info->bits = 32;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-08 00:17:58 +01:00
|
|
|
static bool
|
2011-09-16 23:31:48 +02:00
|
|
|
roar_open(struct audio_output *ao, struct audio_format *audio_format, GError **error)
|
2011-02-08 00:17:58 +01:00
|
|
|
{
|
2011-09-16 23:31:48 +02:00
|
|
|
struct roar *self = (struct roar *)ao;
|
2011-02-08 00:17:58 +01:00
|
|
|
g_mutex_lock(self->lock);
|
|
|
|
|
|
|
|
if (roar_simple_connect(&(self->con), self->host, self->name) < 0)
|
|
|
|
{
|
|
|
|
g_set_error(error, roar_output_quark(), 0,
|
|
|
|
"Failed to connect to Roar server");
|
|
|
|
g_mutex_unlock(self->lock);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
self->vss = roar_vs_new_from_con(&(self->con), &(self->err));
|
|
|
|
|
|
|
|
if (self->vss == NULL || self->err != ROAR_ERROR_NONE)
|
|
|
|
{
|
|
|
|
g_set_error(error, roar_output_quark(), 0,
|
|
|
|
"Failed to connect to server");
|
|
|
|
g_mutex_unlock(self->lock);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-10-08 14:46:17 +02:00
|
|
|
roar_use_audio_format(&self->info, audio_format);
|
2011-02-08 00:17:58 +01:00
|
|
|
|
|
|
|
if (roar_vs_stream(self->vss, &(self->info), ROAR_DIR_PLAY,
|
|
|
|
&(self->err)) < 0)
|
|
|
|
{
|
|
|
|
g_set_error(error, roar_output_quark(), 0, "Failed to start stream");
|
|
|
|
g_mutex_unlock(self->lock);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
roar_vs_role(self->vss, self->role, &(self->err));
|
|
|
|
self->alive = true;
|
|
|
|
|
|
|
|
g_mutex_unlock(self->lock);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-09-17 20:10:26 +02:00
|
|
|
static void
|
2011-09-16 23:31:48 +02:00
|
|
|
roar_close(struct audio_output *ao)
|
2011-09-17 20:10:26 +02:00
|
|
|
{
|
2011-09-16 23:31:48 +02:00
|
|
|
struct roar *self = (struct roar *)ao;
|
2011-09-17 20:10:26 +02:00
|
|
|
g_mutex_lock(self->lock);
|
|
|
|
self->alive = false;
|
|
|
|
|
|
|
|
if (self->vss != NULL)
|
|
|
|
roar_vs_close(self->vss, ROAR_VS_TRUE, &(self->err));
|
|
|
|
self->vss = NULL;
|
|
|
|
roar_disconnect(&(self->con));
|
|
|
|
g_mutex_unlock(self->lock);
|
|
|
|
}
|
|
|
|
|
2011-09-18 11:51:18 +02:00
|
|
|
static void
|
|
|
|
roar_cancel_locked(struct roar *self)
|
|
|
|
{
|
|
|
|
if (self->vss == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
roar_vs_t *vss = self->vss;
|
|
|
|
self->vss = NULL;
|
|
|
|
roar_vs_close(vss, ROAR_VS_TRUE, &(self->err));
|
|
|
|
self->alive = false;
|
|
|
|
|
|
|
|
vss = roar_vs_new_from_con(&(self->con), &(self->err));
|
|
|
|
if (vss == NULL)
|
|
|
|
return;
|
|
|
|
|
2011-09-18 11:54:14 +02:00
|
|
|
if (roar_vs_stream(vss, &(self->info), ROAR_DIR_PLAY,
|
|
|
|
&(self->err)) < 0) {
|
|
|
|
roar_vs_close(vss, ROAR_VS_TRUE, &(self->err));
|
|
|
|
g_warning("Failed to start stream");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-09-18 11:51:18 +02:00
|
|
|
roar_vs_role(vss, self->role, &(self->err));
|
|
|
|
self->vss = vss;
|
|
|
|
self->alive = true;
|
|
|
|
}
|
|
|
|
|
2011-02-08 00:17:58 +01:00
|
|
|
static void
|
2011-09-16 23:31:48 +02:00
|
|
|
roar_cancel(struct audio_output *ao)
|
2011-02-08 00:17:58 +01:00
|
|
|
{
|
2011-09-16 23:31:48 +02:00
|
|
|
struct roar *self = (struct roar *)ao;
|
2011-02-08 00:17:58 +01:00
|
|
|
|
|
|
|
g_mutex_lock(self->lock);
|
2011-09-18 11:51:18 +02:00
|
|
|
roar_cancel_locked(self);
|
2011-02-08 00:17:58 +01:00
|
|
|
g_mutex_unlock(self->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
2011-09-16 23:31:48 +02:00
|
|
|
roar_play(struct audio_output *ao, const void *chunk, size_t size, GError **error)
|
2011-02-08 00:17:58 +01:00
|
|
|
{
|
2011-09-16 23:31:48 +02:00
|
|
|
struct roar *self = (struct roar *)ao;
|
2011-02-08 00:17:58 +01:00
|
|
|
ssize_t rc;
|
|
|
|
|
|
|
|
if (self->vss == NULL)
|
|
|
|
{
|
|
|
|
g_set_error(error, roar_output_quark(), 0, "Connection is invalid");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = roar_vs_write(self->vss, chunk, size, &(self->err));
|
|
|
|
if ( rc <= 0 )
|
|
|
|
{
|
|
|
|
g_set_error(error, roar_output_quark(), 0, "Failed to play data");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char*
|
|
|
|
roar_tag_convert(enum tag_type type, bool *is_uuid)
|
|
|
|
{
|
|
|
|
*is_uuid = false;
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case TAG_ARTIST:
|
|
|
|
case TAG_ALBUM_ARTIST:
|
|
|
|
return "AUTHOR";
|
|
|
|
case TAG_ALBUM:
|
|
|
|
return "ALBUM";
|
|
|
|
case TAG_TITLE:
|
|
|
|
return "TITLE";
|
|
|
|
case TAG_TRACK:
|
|
|
|
return "TRACK";
|
|
|
|
case TAG_NAME:
|
|
|
|
return "NAME";
|
|
|
|
case TAG_GENRE:
|
|
|
|
return "GENRE";
|
|
|
|
case TAG_DATE:
|
|
|
|
return "DATE";
|
|
|
|
case TAG_PERFORMER:
|
|
|
|
return "PERFORMER";
|
|
|
|
case TAG_COMMENT:
|
|
|
|
return "COMMENT";
|
|
|
|
case TAG_DISC:
|
|
|
|
return "DISCID";
|
|
|
|
case TAG_COMPOSER:
|
|
|
|
#ifdef ROAR_META_TYPE_COMPOSER
|
|
|
|
return "COMPOSER";
|
|
|
|
#else
|
|
|
|
return "AUTHOR";
|
|
|
|
#endif
|
|
|
|
case TAG_MUSICBRAINZ_ARTISTID:
|
|
|
|
case TAG_MUSICBRAINZ_ALBUMID:
|
|
|
|
case TAG_MUSICBRAINZ_ALBUMARTISTID:
|
|
|
|
case TAG_MUSICBRAINZ_TRACKID:
|
|
|
|
*is_uuid = true;
|
|
|
|
return "HASH";
|
|
|
|
|
|
|
|
default:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-09-16 23:31:48 +02:00
|
|
|
roar_send_tag(struct audio_output *ao, const struct tag *meta)
|
2011-02-08 00:17:58 +01:00
|
|
|
{
|
2011-09-16 23:31:48 +02:00
|
|
|
struct roar *self = (struct roar *)ao;
|
2011-02-08 00:17:58 +01:00
|
|
|
|
|
|
|
if (self->vss == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
g_mutex_lock(self->lock);
|
|
|
|
size_t cnt = 1;
|
|
|
|
struct roar_keyval vals[32];
|
|
|
|
memset(vals, 0, sizeof(vals));
|
|
|
|
char uuid_buf[32][64];
|
|
|
|
|
|
|
|
char timebuf[16];
|
|
|
|
snprintf(timebuf, sizeof(timebuf), "%02d:%02d:%02d",
|
|
|
|
meta->time / 3600, (meta->time % 3600) / 60, meta->time % 60);
|
|
|
|
|
|
|
|
vals[0].key = g_strdup("LENGTH");
|
|
|
|
vals[0].value = timebuf;
|
|
|
|
|
|
|
|
for (unsigned i = 0; i < meta->num_items && cnt < 32; i++)
|
|
|
|
{
|
|
|
|
bool is_uuid = false;
|
|
|
|
const char *key = roar_tag_convert(meta->items[i]->type, &is_uuid);
|
|
|
|
if (key != NULL)
|
|
|
|
{
|
|
|
|
if (is_uuid)
|
|
|
|
{
|
|
|
|
snprintf(uuid_buf[cnt], sizeof(uuid_buf[0]), "{UUID}%s",
|
|
|
|
meta->items[i]->value);
|
|
|
|
vals[cnt].key = g_strdup(key);
|
|
|
|
vals[cnt].value = uuid_buf[cnt];
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
vals[cnt].key = g_strdup(key);
|
|
|
|
vals[cnt].value = meta->items[i]->value;
|
|
|
|
}
|
|
|
|
cnt++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
roar_vs_meta(self->vss, vals, cnt, &(self->err));
|
|
|
|
|
|
|
|
for (unsigned i = 0; i < 32; i++)
|
|
|
|
g_free(vals[i].key);
|
|
|
|
|
|
|
|
g_mutex_unlock(self->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
const struct audio_output_plugin roar_output_plugin = {
|
|
|
|
.name = "roar",
|
|
|
|
.init = roar_init,
|
|
|
|
.finish = roar_finish,
|
|
|
|
.open = roar_open,
|
|
|
|
.play = roar_play,
|
|
|
|
.cancel = roar_cancel,
|
|
|
|
.close = roar_close,
|
|
|
|
.send_tag = roar_send_tag,
|
|
|
|
|
|
|
|
.mixer_plugin = &roar_mixer_plugin
|
|
|
|
};
|