void
xmms_output_set_error (xmms_output_t *output, xmms_error_t *error)
{
g_return_if_fail (output);
xmms_output_status_set (output, XMMS_PLAYBACK_STATUS_STOP);
if (error) {
xmms_log_error ("Output plugin %s reported error, '%s'",
xmms_plugin_shortname_get ((xmms_plugin_t *)output->plugin),
xmms_error_message_get (error));
}
}
/**
* Performance test predicate
*/
static gboolean
run_performance_test (xmms_medialib_t *medialib, const gchar *name, xmmsv_t *content,
xmmsv_t *coll, xmmsv_t *specification, xmmsv_t *expected,
gint format, const gchar *datasetname)
{
xmms_medialib_session_t *session;
xmms_error_t err;
GTimeVal t0, t1;
guint64 duration;
xmmsv_t *ret;
session = xmms_medialib_session_begin (medialib);
g_get_current_time (&t0);
ret = xmms_medialib_query (session, coll, specification, &err);
g_get_current_time (&t1);
xmms_medialib_session_commit (session);
duration = (guint64)((t1.tv_sec - t0.tv_sec) * G_USEC_PER_SEC) + (t1.tv_usec - t0.tv_usec);
if (format == FORMAT_PRETTY)
g_print ("* Test %s\n", name);
if (xmms_error_iserror (&err)) {
if (format == FORMAT_CSV) {
g_print ("\"%s\",\"%s\",0,0\n", datasetname, name);
} else {
g_print (" - Query failed: %s\n", xmms_error_message_get (&err));
}
} else {
if (format == FORMAT_CSV) {
g_print ("\"%s\",\"%s\",1,%" G_GUINT64_FORMAT "\n", datasetname, name, duration);
} else {
g_print (" - Time elapsed: %.3fms\n", duration / 1000.0);
}
}
xmmsv_unref (ret);
return TRUE;
}
static gchar *
get_root_node_name (xmms_xform_t *xform)
{
guint8 buf[BUFFER_SIZE];
gint read, i, start, len;
gchar *ret = NULL;
xmms_error_t error;
xmms_error_reset (&error);
read = xmms_xform_peek (xform, buf, BUFFER_SIZE, &error);
if (read < 1) {
xmms_log_error ("Couldn't get data: %s", xmms_error_message_get (&error));
return NULL;
}
start = -1;
len = 0;
for (i = 0; i < read; i++) {
if (start < 0) {
if (buf[i] == '<' && buf[i + 1] != '!' && buf[i + 1] != '?') {
start = i;
}
} else {
if (isalpha (buf[i])) {
len++;
} else if (len) {
ret = g_malloc (len + 1);
memcpy (ret, buf + start + 1, len);
ret[len] = '\0';
break;
}
}
}
return ret;
}
static void
process_msg (xmms_ipc_client_t *client, xmms_ipc_msg_t *msg)
{
xmms_object_t *object;
xmms_object_cmd_arg_t arg;
xmms_ipc_msg_t *retmsg;
xmmsv_t *error, *arguments;
uint32_t objid, cmdid;
g_return_if_fail (msg);
objid = xmms_ipc_msg_get_object (msg);
cmdid = xmms_ipc_msg_get_cmd (msg);
if (!xmms_ipc_msg_get_value (msg, &arguments)) {
xmms_log_error ("Cannot read command arguments. "
"Ignoring command.");
return;
}
if (objid == XMMS_IPC_OBJECT_SIGNAL) {
if (cmdid == XMMS_IPC_CMD_SIGNAL) {
xmms_ipc_register_signal (client, msg, arguments);
} else if (cmdid == XMMS_IPC_CMD_BROADCAST) {
xmms_ipc_register_broadcast (client, msg, arguments);
} else {
xmms_log_error ("Bad command id (%d) for signal object", cmdid);
}
goto out;
}
if (objid >= XMMS_IPC_OBJECT_END) {
xmms_log_error ("Bad object id (%d)", objid);
goto out;
}
g_mutex_lock (ipc_object_pool_lock);
object = ipc_object_pool->objects[objid];
g_mutex_unlock (ipc_object_pool_lock);
if (!object) {
xmms_log_error ("Object %d was not found!", objid);
goto out;
}
if (!g_tree_lookup (object->cmds, GUINT_TO_POINTER (cmdid))) {
xmms_log_error ("No such cmd %d on object %d", cmdid, objid);
goto out;
}
xmms_object_cmd_arg_init (&arg);
arg.args = arguments;
xmms_object_cmd_call (object, cmdid, &arg);
if (xmms_error_isok (&arg.error)) {
retmsg = xmms_ipc_msg_new (objid, XMMS_IPC_CMD_REPLY);
xmms_ipc_handle_cmd_value (retmsg, arg.retval);
} else {
/* FIXME: or we could omit setting the command to _CMD_ERROR
* and let the client check whether the value it got is an
* error xmmsv_t. If so, don't forget to
* update the client-side of IPC too. */
retmsg = xmms_ipc_msg_new (objid, XMMS_IPC_CMD_ERROR);
error = xmmsv_new_error (xmms_error_message_get (&arg.error));
xmms_ipc_msg_put_value (retmsg, error);
xmmsv_unref (error);
/*
retmsg = xmms_ipc_msg_new (objid, XMMS_IPC_CMD_REPLY);
xmms_ipc_handle_cmd_value (retmsg, arg.retval);
*/
}
if (arg.retval)
xmmsv_unref (arg.retval);
err:
xmms_ipc_msg_set_cookie (retmsg, xmms_ipc_msg_get_cookie (msg));
g_mutex_lock (client->lock);
xmms_ipc_client_msg_write (client, retmsg);
g_mutex_unlock (client->lock);
out:
if (arguments) {
xmmsv_unref (arguments);
}
}
static void *
xmms_output_filler (void *arg)
{
xmms_output_t *output = (xmms_output_t *)arg;
xmms_xform_t *chain = NULL;
gboolean last_was_kill = FALSE;
char buf[4096];
xmms_error_t err;
gint ret;
xmms_error_reset (&err);
g_mutex_lock (output->filler_mutex);
while (output->filler_state != FILLER_QUIT) {
if (output->filler_state == FILLER_STOP) {
if (chain) {
xmms_object_unref (chain);
chain = NULL;
}
xmms_ringbuf_set_eos (output->filler_buffer, TRUE);
g_cond_wait (output->filler_state_cond, output->filler_mutex);
last_was_kill = FALSE;
continue;
}
if (output->filler_state == FILLER_KILL) {
if (chain) {
xmms_object_unref (chain);
chain = NULL;
output->filler_state = FILLER_RUN;
last_was_kill = TRUE;
} else {
output->filler_state = FILLER_STOP;
}
continue;
}
if (output->filler_state == FILLER_SEEK) {
if (!chain) {
XMMS_DBG ("Seek without chain, ignoring..");
output->filler_state = FILLER_STOP;
continue;
}
ret = xmms_xform_this_seek (chain, output->filler_seek, XMMS_XFORM_SEEK_SET, &err);
if (ret == -1) {
XMMS_DBG ("Seeking failed: %s", xmms_error_message_get (&err));
} else {
XMMS_DBG ("Seek ok! %d", ret);
output->filler_skip = output->filler_seek - ret;
if (output->filler_skip < 0) {
XMMS_DBG ("Seeked %d samples too far! Updating position...",
-output->filler_skip);
output->filler_skip = 0;
output->filler_seek = ret;
}
xmms_ringbuf_clear (output->filler_buffer);
xmms_ringbuf_hotspot_set (output->filler_buffer, seek_done, NULL, output);
}
output->filler_state = FILLER_RUN;
}
if (!chain) {
xmms_medialib_entry_t entry;
xmms_output_song_changed_arg_t *arg;
xmms_medialib_session_t *session;
g_mutex_unlock (output->filler_mutex);
entry = xmms_playlist_current_entry (output->playlist);
if (!entry) {
XMMS_DBG ("No entry from playlist!");
output->filler_state = FILLER_STOP;
g_mutex_lock (output->filler_mutex);
continue;
}
chain = xmms_xform_chain_setup (entry, output->format_list, FALSE);
if (!chain) {
session = xmms_medialib_begin_write ();
if (xmms_medialib_entry_property_get_int (session, entry, XMMS_MEDIALIB_ENTRY_PROPERTY_STATUS) == XMMS_MEDIALIB_ENTRY_STATUS_NEW) {
xmms_medialib_end (session);
xmms_medialib_entry_remove (entry);
} else {
xmms_medialib_entry_status_set (session, entry, XMMS_MEDIALIB_ENTRY_STATUS_NOT_AVAILABLE);
xmms_medialib_entry_send_update (entry);
xmms_medialib_end (session);
}
if (!xmms_playlist_advance (output->playlist)) {
XMMS_DBG ("End of playlist");
output->filler_state = FILLER_STOP;
}
g_mutex_lock (output->filler_mutex);
continue;
}
arg = g_new0 (xmms_output_song_changed_arg_t, 1);
arg->output = output;
arg->chain = chain;
arg->flush = last_was_kill;
xmms_object_ref (chain);
last_was_kill = FALSE;
g_mutex_lock (output->filler_mutex);
xmms_ringbuf_hotspot_set (output->filler_buffer, song_changed, song_changed_arg_free, arg);
}
xmms_ringbuf_wait_free (output->filler_buffer, sizeof (buf), output->filler_mutex);
if (output->filler_state != FILLER_RUN) {
XMMS_DBG ("State changed while waiting...");
continue;
}
g_mutex_unlock (output->filler_mutex);
ret = xmms_xform_this_read (chain, buf, sizeof (buf), &err);
g_mutex_lock (output->filler_mutex);
if (ret > 0) {
gint skip = MIN (ret, output->toskip);
output->toskip -= skip;
if (ret > skip) {
xmms_ringbuf_write_wait (output->filler_buffer,
buf + skip,
ret - skip,
output->filler_mutex);
}
} else {
if (ret == -1) {
/* print error */
xmms_error_reset (&err);
}
xmms_object_unref (chain);
chain = NULL;
if (!xmms_playlist_advance (output->playlist)) {
XMMS_DBG ("End of playlist");
output->filler_state = FILLER_STOP;
}
}
}
g_mutex_unlock (output->filler_mutex);
return NULL;
}
static void
process_msg (xmms_ipc_client_t *client, xmms_ipc_msg_t *msg)
{
xmms_object_t *object;
xmms_object_cmd_desc_t *cmd = NULL;
xmms_object_cmd_arg_t arg;
xmms_ipc_msg_t *retmsg;
xmmsv_t *error, *arguments;
uint32_t objid, cmdid;
gint i;
g_return_if_fail (msg);
objid = xmms_ipc_msg_get_object (msg);
cmdid = xmms_ipc_msg_get_cmd (msg);
if (!xmms_ipc_msg_get_value (msg, &arguments)) {
xmms_log_error ("Cannot read command arguments. "
"Ignoring command.");
return;
}
if (objid == XMMS_IPC_OBJECT_SIGNAL) {
if (cmdid == XMMS_IPC_CMD_SIGNAL) {
xmms_ipc_register_signal (client, msg, arguments);
} else if (cmdid == XMMS_IPC_CMD_BROADCAST) {
xmms_ipc_register_broadcast (client, msg, arguments);
} else {
xmms_log_error ("Bad command id (%d) for signal object", cmdid);
}
goto out;
}
if (objid >= XMMS_IPC_OBJECT_END) {
xmms_log_error ("Bad object id (%d)", objid);
goto out;
}
g_mutex_lock (ipc_object_pool_lock);
object = ipc_object_pool->objects[objid];
g_mutex_unlock (ipc_object_pool_lock);
if (!object) {
xmms_log_error ("Object %d was not found!", objid);
goto out;
}
if (object->cmds)
cmd = g_tree_lookup (object->cmds, GUINT_TO_POINTER (cmdid));
if (!cmd) {
xmms_log_error ("No such cmd %d on object %d", cmdid, objid);
goto out;
}
xmms_object_cmd_arg_init (&arg);
for (i = 0; i < XMMS_OBJECT_CMD_MAX_ARGS; i++) {
if (!type_and_msg_to_arg (cmd->args[i], arguments, &arg, i)) {
xmms_log_error ("Error parsing args");
if (objid == XMMS_IPC_OBJECT_MAIN &&
cmdid == XMMS_IPC_CMD_HELLO) {
xmms_log_error ("Couldn't parse hello message. "
"Maybe the client or libxmmsclient "
"needs to be updated.");
}
retmsg = xmms_ipc_msg_new (objid, XMMS_IPC_CMD_ERROR);
error = xmmsv_new_error ("Corrupt msg");
xmms_ipc_msg_put_value (retmsg, error);
xmmsv_unref (error);
goto err;
}
}
xmms_object_cmd_call (object, cmdid, &arg);
if (xmms_error_isok (&arg.error)) {
retmsg = xmms_ipc_msg_new (objid, XMMS_IPC_CMD_REPLY);
xmms_ipc_handle_cmd_value (retmsg, arg.retval);
} else {
/* FIXME: or we could omit setting the command to _CMD_ERROR
* and let the client check whether the value it got is an
* error xmmsv_t. If so, don't forget to
* update the client-side of IPC too. */
retmsg = xmms_ipc_msg_new (objid, XMMS_IPC_CMD_ERROR);
error = xmmsv_new_error (xmms_error_message_get (&arg.error));
xmms_ipc_msg_put_value (retmsg, error);
xmmsv_unref (error);
/*
retmsg = xmms_ipc_msg_new (objid, XMMS_IPC_CMD_REPLY);
xmms_ipc_handle_cmd_value (retmsg, arg.retval);
*/
}
if (arg.retval)
xmmsv_unref (arg.retval);
err:
for (i = 0; i < XMMS_OBJECT_CMD_MAX_ARGS; i++) {
if (arg.values[i])
xmmsv_unref (arg.values[i]);
}
xmms_ipc_msg_set_cookie (retmsg, xmms_ipc_msg_get_cookie (msg));
g_mutex_lock (client->lock);
xmms_ipc_client_msg_write (client, retmsg);
g_mutex_unlock (client->lock);
out:
if (arguments) {
xmmsv_unref (arguments);
}
}
static void
process_msg (xmms_ipc_client_t *client, xmms_ipc_msg_t *msg)
{
xmms_object_t *object;
xmms_object_cmd_desc_t *cmd = NULL;
xmms_object_cmd_arg_t arg;
xmms_ipc_msg_t *retmsg;
uint32_t objid, cmdid;
gint i;
g_return_if_fail (msg);
objid = xmms_ipc_msg_get_object (msg);
cmdid = xmms_ipc_msg_get_cmd (msg);
if (objid == XMMS_IPC_OBJECT_SIGNAL &&
cmdid == XMMS_IPC_CMD_SIGNAL) {
gint32 signalid;
if (!xmms_ipc_msg_get_int32 (msg, &signalid)) {
xmms_log_error ("No signalid in this msg?!");
return;
}
if (signalid < 0 || signalid >= XMMS_IPC_SIGNAL_END) {
xmms_log_error ("Bad signal id (%d)", signalid);
return;
}
g_mutex_lock (client->lock);
client->pendingsignals[signalid] = xmms_ipc_msg_get_cookie (msg);
g_mutex_unlock (client->lock);
return;
} else if (objid == XMMS_IPC_OBJECT_SIGNAL &&
cmdid == XMMS_IPC_CMD_BROADCAST) {
gint32 broadcastid;
if (!xmms_ipc_msg_get_int32 (msg, &broadcastid)) {
xmms_log_error ("No broadcastid in this msg?!");
return;
}
if (broadcastid < 0 || broadcastid >= XMMS_IPC_SIGNAL_END) {
xmms_log_error ("Bad broadcast id (%d)", broadcastid);
return;
}
g_mutex_lock (client->lock);
client->broadcasts[broadcastid] =
g_list_append (client->broadcasts[broadcastid],
GUINT_TO_POINTER (xmms_ipc_msg_get_cookie (msg)));
g_mutex_unlock (client->lock);
return;
}
if (objid >= XMMS_IPC_OBJECT_END) {
xmms_log_error ("Bad object id (%d)", objid);
return;
}
g_mutex_lock (ipc_object_pool_lock);
object = ipc_object_pool->objects[objid];
g_mutex_unlock (ipc_object_pool_lock);
if (!object) {
xmms_log_error ("Object %d was not found!", objid);
return;
}
if (cmdid >= XMMS_IPC_CMD_END) {
xmms_log_error ("Bad command id (%d)", cmdid);
return;
}
if (object->cmds)
cmd = g_tree_lookup (object->cmds, GUINT_TO_POINTER (cmdid));
if (!cmd) {
xmms_log_error ("No such cmd %d on object %d", cmdid, objid);
return;
}
xmms_object_cmd_arg_init (&arg);
for (i = 0; i < XMMS_OBJECT_CMD_MAX_ARGS; i++) {
if (!type_and_msg_to_arg (cmd->args[i], msg, &arg, i)) {
xmms_log_error ("Error parsing args");
retmsg = xmms_ipc_msg_new (objid, XMMS_IPC_CMD_ERROR);
xmms_ipc_msg_put_string (retmsg, "Corrupt msg");
goto err;
}
}
xmms_object_cmd_call (object, cmdid, &arg);
if (xmms_error_isok (&arg.error)) {
retmsg = xmms_ipc_msg_new (objid, XMMS_IPC_CMD_REPLY);
xmms_ipc_handle_cmd_value (retmsg, arg.retval);
} else {
/* FIXME: or we could change the client code to transform
* CMD_ERROR to an error value_t. If so, don't forget to
* update the client-side of IPC too. */
retmsg = xmms_ipc_msg_new (objid, XMMS_IPC_CMD_ERROR);
xmms_ipc_msg_put_string (retmsg, xmms_error_message_get (&arg.error));
/*
retmsg = xmms_ipc_msg_new (objid, XMMS_IPC_CMD_REPLY);
xmms_ipc_handle_cmd_value (retmsg, arg.retval);
*/
}
if (arg.retval)
xmmsv_unref (arg.retval);
err:
for (i = 0; i < XMMS_OBJECT_CMD_MAX_ARGS; i++) {
xmmsv_unref (arg.values[i]);
}
xmms_ipc_msg_set_cookie (retmsg, xmms_ipc_msg_get_cookie (msg));
g_mutex_lock (client->lock);
xmms_ipc_client_msg_write (client, retmsg);
g_mutex_unlock (client->lock);
}
