static void
xmms_medialib_entry_send_update (xmms_medialib_t *medialib, xmms_medialib_entry_t entry)
{
xmms_object_emit (XMMS_OBJECT (medialib),
XMMS_IPC_SIGNAL_MEDIALIB_ENTRY_UPDATE,
xmmsv_new_int (entry));
}
/**
* Trigger a removed siginal to the client. This should be
* called when an entry has been removed from the medialib
*
* @param entry Entry to signal a remove for.
*/
static void
xmms_medialib_entry_send_removed (xmms_medialib_t *medialib, xmms_medialib_entry_t entry)
{
xmms_object_emit (XMMS_OBJECT (medialib),
XMMS_IPC_SIGNAL_MEDIALIB_ENTRY_REMOVED,
xmmsv_new_int (entry));
}
static void
update_playtime (xmms_output_t *output, int advance)
{
guint buffersize = 0;
g_mutex_lock (&output->playtime_mutex);
output->played += advance;
g_mutex_unlock (&output->playtime_mutex);
buffersize = xmms_output_plugin_method_latency_get (output->plugin, output);
if (output->played < buffersize) {
buffersize = output->played;
}
g_mutex_lock (&output->playtime_mutex);
if (output->format) {
guint ms = xmms_sample_bytes_to_ms (output->format,
output->played - buffersize);
if ((ms / 100) != (output->played_time / 100)) {
xmms_object_emit (XMMS_OBJECT (output),
XMMS_IPC_SIGNAL_PLAYBACK_PLAYTIME,
xmmsv_new_int (ms));
}
output->played_time = ms;
}
g_mutex_unlock (&output->playtime_mutex);
}
static void
xmms_playlist_client_load (xmms_playlist_t *playlist, const gchar *name, xmms_error_t *err)
{
xmmsv_coll_t *plcoll, *active_coll;
if (strcmp (name, XMMS_ACTIVE_PLAYLIST) == 0) {
xmms_error_set (err, XMMS_ERROR_INVAL, "invalid playlist to load");
return;
}
active_coll = xmms_playlist_get_coll (playlist, XMMS_ACTIVE_PLAYLIST, err);
if (active_coll == NULL) {
xmms_error_set (err, XMMS_ERROR_GENERIC, "no active playlist");
return;
}
plcoll = xmms_playlist_get_coll (playlist, name, err);
if (plcoll == NULL) {
xmms_error_set (err, XMMS_ERROR_NOENT, "no such playlist");
return;
}
if (active_coll == plcoll) {
XMMS_DBG ("Not loading %s playlist, already active!", name);
return;
}
XMMS_DBG ("Loading new playlist! %s", name);
xmms_collection_update_pointer (playlist->colldag, XMMS_ACTIVE_PLAYLIST,
XMMS_COLLECTION_NSID_PLAYLISTS, plcoll);
xmms_object_emit (XMMS_OBJECT (playlist),
XMMS_IPC_SIGNAL_PLAYLIST_LOADED,
xmmsv_new_string (name));
}
static void
xmms_playlist_current_pos_msg_send (xmms_playlist_t *playlist,
xmmsv_t *dict)
{
g_return_if_fail (playlist);
g_return_if_fail (dict);
xmms_object_emit (XMMS_OBJECT (playlist),
XMMS_IPC_SIGNAL_PLAYLIST_CURRENT_POS,
dict);
}
static gboolean
kill_server (gpointer object) {
xmms_main_t *mainobj = (xmms_main_t *) object;
gint uptime = time (NULL) - mainobj->starttime;
xmms_object_emit (XMMS_OBJECT (object),
XMMS_IPC_SIGNAL_QUIT,
xmmsv_new_int (uptime));
xmms_object_unref (object);
exit (EXIT_SUCCESS);
}
void
xmms_object_emit_f (xmms_object_t *object, guint32 signalid,
xmmsv_type_t type, ...)
{
va_list ap;
xmmsv_t *arg;
va_start (ap, type);
switch (type) {
case XMMSV_TYPE_NONE:
arg = xmmsv_new_none ();
break;
case XMMSV_TYPE_INT32:
arg = xmmsv_new_int (va_arg (ap, gint32));
break;
case XMMSV_TYPE_STRING:
arg = xmmsv_new_string (va_arg (ap, gchar *));
break;
case XMMSV_TYPE_DICT:
arg = xmms_create_xmmsv_dict (va_arg (ap, GTree *));
break;
case XMMSV_TYPE_END:
default:
XMMS_DBG ("OBJECT: trying to emit value of unsupported type (%d)!", (int)type);
g_assert_not_reached ();
break;
}
va_end (ap);
xmms_object_emit (object, signalid, arg);
/* In all cases above, we created a new xmmsv_t, which we
* now destroy.
* In some cases, those xmmsv_t's are created from GLib objects,
* such as GTrees. Here we must not destroy those GLib objects,
* because the caller wants to do that. However, the xmmsv_t's
* don't hold onto those GLib objects, so unreffing the
* xmmsv_t doesn't kill the GLib object.
*/
xmmsv_unref (arg);
}
void
xmms_playlist_changed_msg_send (xmms_playlist_t *playlist, xmmsv_t *dict)
{
const gchar *plname;
gint type;
g_return_if_fail (playlist);
g_return_if_fail (dict);
/* If local playlist change, trigger a COLL_CHANGED signal */
if (xmmsv_dict_entry_get_int (dict, "type", &type) &&
xmmsv_dict_entry_get_string (dict, "name", &plname) &&
type != XMMS_PLAYLIST_CHANGED_UPDATE) {
XMMS_COLLECTION_PLAYLIST_CHANGED_MSG (playlist->colldag, plname);
}
xmms_object_emit (XMMS_OBJECT (playlist),
XMMS_IPC_SIGNAL_PLAYLIST_CHANGED,
dict);
}
static gboolean
song_changed (void *data)
{
/* executes in the output thread; NOT the filler thread */
xmms_output_song_changed_arg_t *arg = (xmms_output_song_changed_arg_t *)data;
xmms_medialib_entry_t entry;
xmms_stream_type_t *type;
entry = xmms_xform_entry_get (arg->chain);
XMMS_DBG ("Running hotspot! Song changed!! %d", entry);
arg->output->played = 0;
arg->output->current_entry = entry;
type = xmms_xform_outtype_get (arg->chain);
if (!xmms_output_format_set (arg->output, type)) {
gint fmt, rate, chn;
fmt = xmms_stream_type_get_int (type, XMMS_STREAM_TYPE_FMT_FORMAT);
rate = xmms_stream_type_get_int (type, XMMS_STREAM_TYPE_FMT_SAMPLERATE);
chn = xmms_stream_type_get_int (type, XMMS_STREAM_TYPE_FMT_CHANNELS);
XMMS_DBG ("Couldn't set format %s/%d/%d, stopping filler..",
xmms_sample_name_get (fmt), rate, chn);
xmms_output_filler_state_nolock (arg->output, FILLER_STOP);
xmms_ringbuf_set_eos (arg->output->filler_buffer, TRUE);
return FALSE;
}
if (arg->flush)
xmms_output_flush (arg->output);
xmms_object_emit (XMMS_OBJECT (arg->output),
XMMS_IPC_SIGNAL_PLAYBACK_CURRENTID,
xmmsv_new_int (entry));
return TRUE;
}
static gboolean
xmms_output_status_set (xmms_output_t *output, gint status)
{
gboolean ret = TRUE;
if (!output->plugin) {
XMMS_DBG ("No plugin to set status on..");
return FALSE;
}
g_mutex_lock (&output->status_mutex);
if (output->status != status) {
if (status == XMMS_PLAYBACK_STATUS_PAUSE &&
output->status != XMMS_PLAYBACK_STATUS_PLAY) {
XMMS_DBG ("Can only pause from play.");
ret = FALSE;
} else {
output->status = status;
if (status == XMMS_PLAYBACK_STATUS_STOP) {
xmms_object_unref (output->format);
output->format = NULL;
}
if (!xmms_output_plugin_method_status (output->plugin, output, status)) {
xmms_log_error ("Status method returned an error!");
output->status = XMMS_PLAYBACK_STATUS_STOP;
ret = FALSE;
}
xmms_object_emit (XMMS_OBJECT (output),
XMMS_IPC_SIGNAL_PLAYBACK_STATUS,
xmmsv_new_int (output->status));
}
}
g_mutex_unlock (&output->status_mutex);
return ret;
}
static gpointer
xmms_output_monitor_volume_thread (gpointer data)
{
xmms_output_t *output = data;
xmms_volume_map_t old, cur;
if (!xmms_output_plugin_method_volume_get_available (output->plugin)) {
return NULL;
}
xmms_volume_map_init (&old);
xmms_volume_map_init (&cur);
while (output->monitor_volume_running) {
cur.num_channels = 0;
cur.status = xmms_output_plugin_method_volume_get (output->plugin,
output, NULL, NULL,
&cur.num_channels);
if (cur.status) {
/* check for sane values */
if (cur.num_channels < 1 ||
cur.num_channels > VOLUME_MAX_CHANNELS) {
cur.status = FALSE;
} else {
cur.names = g_renew (const gchar *, cur.names,
cur.num_channels);
cur.values = g_renew (guint, cur.values, cur.num_channels);
}
}
if (cur.status) {
cur.status =
xmms_output_plugin_method_volume_get (output->plugin,
output, cur.names,
cur.values,
&cur.num_channels);
}
/* we failed at getting volume for one of the two maps or
* we succeeded both times and they differ -> changed
*/
if ((cur.status ^ old.status) ||
(cur.status && old.status &&
!xmms_volume_map_equal (&old, &cur))) {
/* emit the broadcast */
if (cur.status) {
xmms_object_emit (XMMS_OBJECT (output),
XMMS_IPC_SIGNAL_PLAYBACK_VOLUME_CHANGED,
xmms_volume_map_to_dict (&cur));
} else {
/** @todo When bug 691 is solved, emit an error here */
xmms_object_emit (XMMS_OBJECT (output),
XMMS_IPC_SIGNAL_PLAYBACK_VOLUME_CHANGED,
xmmsv_new_none ());
}
}
xmms_volume_map_copy (&cur, &old);
g_usleep (G_USEC_PER_SEC);
}
xmms_volume_map_free (&old);
xmms_volume_map_free (&cur);
return NULL;
}
