void
set_volume (cli_infos_t *infos, gchar *channel, gint volume)
{
xmmsc_result_t *res;
xmmsv_t *val;
GList *it, *channels = NULL;
if (!channel) {
/* get all channels */
res = xmmsc_playback_volume_get (infos->sync);
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
xmmsv_dict_foreach (val, dict_keys, &channels);
xmmsc_result_unref (res);
} else {
channels = g_list_prepend (channels, g_strdup (channel));
}
/* set volumes for channels in list */
for (it = g_list_first (channels); it != NULL; it = g_list_next (it)) {
res = xmmsc_playback_volume_set (infos->sync, it->data, volume);
xmmsc_result_wait (res);
xmmsc_result_unref (res);
/* free channel string */
g_free (it->data);
}
g_list_free (channels);
cli_infos_loop_resume (infos);
}
static gboolean
ol_player_xmms2_go_rel (int rel)
{
ol_log_func ();
ol_debugf (" rel:%d\n", rel);
if (!ol_player_xmms2_ensure_connection ())
return FALSE;
xmmsc_result_t *result = xmmsc_playlist_set_next_rel (connection, rel);
xmmsc_result_wait (result);
xmmsv_t *return_value = xmmsc_result_get_value (result);
if (xmmsv_is_error (return_value))
{
ol_debug ("Error on setting playlist next");
return FALSE;
}
xmmsc_result_unref (result);
result = xmmsc_playback_tickle (connection);
xmmsc_result_wait (result);
if (xmmsc_result_iserror (result))
{
ol_debug ("Error on tickle playback");
return FALSE;
}
xmmsc_result_unref (result);
return TRUE;
}
void
coll_save (cli_infos_t *infos, xmmsv_coll_t *coll,
xmmsc_coll_namespace_t ns, gchar *name, gboolean force)
{
xmmsc_result_t *res;
xmmsv_t *val;
gboolean save = TRUE;
if (!force) {
xmmsv_coll_t *exists;
res = xmmsc_coll_get (infos->sync, name, ns);
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
if (xmmsv_get_coll (val, &exists)) {
g_printf (_("Error: A collection already exists "
"with the target name!\n"));
save = FALSE;
}
xmmsc_result_unref (res);
}
if (save) {
res = xmmsc_coll_save (infos->sync, coll, name, ns);
xmmsc_result_wait (res);
done (res, infos);
} else {
cli_infos_loop_resume (infos);
}
}
void
cli_cache_refresh (cli_infos_t *infos)
{
xmmsc_result_t *res;
res = xmmsc_playlist_current_pos (infos->conn, XMMS_ACTIVE_PLAYLIST);
xmmsc_result_wait (res);
refresh_currpos (xmmsc_result_get_value (res), infos->cache);
xmmsc_result_unref (res);
res = xmmsc_playback_current_id (infos->conn);
xmmsc_result_wait (res);
refresh_currid (xmmsc_result_get_value (res), infos->cache);
xmmsc_result_unref (res);
res = xmmsc_playback_status (infos->conn);
xmmsc_result_wait (res);
refresh_playback_status (xmmsc_result_get_value (res), infos->cache);
xmmsc_result_unref (res);
res = xmmsc_playlist_list_entries (infos->conn, XMMS_ACTIVE_PLAYLIST);
xmmsc_result_wait (res);
refresh_active_playlist (xmmsc_result_get_value (res), infos->cache);
xmmsc_result_unref (res);
res = xmmsc_playlist_current_active (infos->conn);
xmmsc_result_wait (res);
refresh_active_playlist_name (xmmsc_result_get_value (res), infos->cache);
xmmsc_result_unref (res);
}
void plugin_config_setup (xmmsc_connection_t *con)
{
xmmsc_result_t* res;
xmmsv_t *val;
const gchar *err, *name;
/* call only once */
g_assert(plugins == NULL );
/* get translation of plugins/configs */
plugin_config_init_translation();
/* get list of available plugins */
res = xmmsc_main_list_plugins (con, XMMS_PLUGIN_TYPE_OUTPUT);
/* we havn't entered async xmmsc_mainloop, so it's ok todo sync ops */
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
if (!xmmsv_get_error (val, &err)) {
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (val, &it);
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it))
{
xmmsv_t *elem;
Plugin *plugin;
xmmsv_list_iter_entry (it, &elem);
xmmsv_dict_entry_get_string (elem, "shortname", &name);
/* not blacklisted */
if ( g_strrstr( PLUGIN_BLACKLIST, name ) != NULL )
continue;
plugin = g_slice_new( Plugin );
plugin->name = g_strdup(name);
plugin->config = NULL;
plugins = g_list_append(plugins, plugin);
}
} else {
g_error ( "Server error: %s", err);
}
xmmsc_result_unref (res);
/* get configuration options */
res = xmmsc_config_list_values (con );
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
xmmsv_dict_foreach( val, plugin_config_setup_parameter, NULL);
}
void
cmd_playlists_list (xmmsc_connection_t *conn, gint argc, gchar **argv)
{
const gchar *active_name;
xmmsc_result_t *res, *active_res;
xmmsv_t *val, *active_val;
xmmsv_list_iter_t *it;
active_res = xmmsc_playlist_current_active (conn);
xmmsc_result_wait (active_res);
active_val = xmmsc_result_get_value (active_res);
if (xmmsv_is_error (active_val) ||
!xmmsv_get_string (active_val, &active_name)) {
active_name = NULL;
}
res = xmmsc_playlist_list (conn);
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
if (xmmsv_is_error (val)) {
print_error ("%s", xmmsv_get_error_old (val));
}
xmmsv_get_list_iter (val, &it);
while (xmmsv_list_iter_valid (it)) {
xmmsv_t *valstr;
const gchar *name;
xmmsv_list_iter_entry (it, &valstr);
if (!xmmsv_get_string (valstr, &name)) {
print_error ("Broken resultset");
}
/* Hide all lists that start with _ */
if (name[0] != '_') {
if (active_name != NULL && strcmp (active_name, name) == 0) {
print_info ("->%s", name);
} else {
print_info (" %s", name);
}
}
xmmsv_list_iter_next (it);
}
xmmsc_result_unref (res);
xmmsc_result_unref (active_res);
}
static void
pos_print_info_cb (gint pos, void *userdata)
{
xmmsc_result_t *infores;
pl_pos_udata_t *pack = (pl_pos_udata_t *) userdata;
guint id;
/* Skip if outside of playlist */
if (pos >= pack->infos->cache->active_playlist->len) {
return;
}
id = g_array_index (pack->infos->cache->active_playlist, guint, pos);
infores = xmmsc_medialib_get_info (pack->infos->sync, id);
xmmsc_result_wait (infores);
/* Do not prepend newline before the first entry */
if (pack->inc > 0) {
g_printf ("\n");
} else {
pack->inc++;
}
id_print_info (infores, id, NULL);
}
void
cmd_addid (xmmsc_connection_t *conn, gint argc, gchar **argv)
{
gint i;
gchar *playlist = NULL;
xmmsc_result_t *res;
if (argc < 3) {
print_error ("Need a medialib id to add");
}
for (i = 2; argv[i]; i++) {
guint id = strtoul (argv[i], NULL, 10);
if (id) {
res = xmmsc_playlist_add_id (conn, playlist, id);
xmmsc_result_wait (res);
if (xmmsc_result_iserror (res)) {
print_error ("Couldn't add %d to playlist: %s", id,
xmmsc_result_get_error (res));
}
xmmsc_result_unref (res);
print_info ("Added medialib id %d to playlist", id);
} else if (i == 2) {
/* First argument is the playlist name */
playlist = argv[i];
}
}
}
void
cmd_sort (xmmsc_connection_t *conn, gint argc, gchar **argv)
{
gchar *playlist;
xmmsv_t *sortby;
xmmsc_result_t *res;
if (argc < 3) {
print_error ("Sort needs a property to sort on");
} else if (argc == 3) {
playlist = NULL;
sortby = xmmsv_make_stringlist (&argv[2], argc - 2);
} else {
playlist = argv[2];
sortby = xmmsv_make_stringlist (&argv[3], argc - 3);
}
res = xmmsc_playlist_sort (conn, playlist, sortby);
xmmsc_result_wait (res);
if (xmmsc_result_iserror (res)) {
print_error ("%s", xmmsc_result_get_error (res));
}
xmmsc_result_unref (res);
xmmsv_unref (sortby);
}
static gboolean
ol_player_xmms2_get_music_length (int *len)
{
/* ol_log_func (); */
ol_assert_ret (len != NULL, FALSE);
if (!ol_player_xmms2_ensure_connection ())
return FALSE;
*len = 0;
int32_t id = ol_player_xmms2_get_currend_id ();
if (id > 0)
{
xmmsc_result_t *result = xmmsc_medialib_get_info (connection, id);
xmmsc_result_wait (result);
xmmsv_t *return_value = xmmsc_result_get_value (result);
if (xmmsv_is_error (return_value))
{
ol_error ("Get music info from XMMS2 failed.");
}
else
{
xmmsv_t *dict = xmmsv_propdict_to_dict (return_value, NULL);
*len = ol_player_xmms2_get_dict_int (return_value, "duration");
xmmsv_unref (dict);
}
xmmsc_result_unref (result);
}
return TRUE;
}
static int32_t
ol_player_xmms2_get_currend_id ()
{
/* ol_log_func (); */
if (!ol_player_xmms2_ensure_connection ())
return 0;
int32_t ret = 0;
xmmsc_result_t *result = xmmsc_playback_current_id (connection);
xmmsc_result_wait (result);
xmmsv_t *return_value = xmmsc_result_get_value (result);
if (xmmsv_is_error (return_value))
{
ol_error ("Error on getting current id");
ret = 0;
}
else
{
if (!xmmsv_get_int (return_value, &ret))
{
ol_error ("Get id from result failed");
ret = 0;
}
}
xmmsc_result_unref (result);
return ret;
}
void
cmd_insertid (xmmsc_connection_t *conn, gint argc, gchar **argv)
{
gchar *playlist = NULL;
guint pos, mlib_id;
char *endptr;
xmmsc_result_t *res;
if (argc < 4) {
print_error ("Need a position and a medialib id");
}
pos = strtol (argv[2], &endptr, 10);
if (*endptr == '\0') {
mlib_id = strtol (argv[3], NULL, 10); /* No playlist name */
} else {
playlist = argv[2]; /* extract playlist name */
pos = strtol (argv[3], NULL, 10);
mlib_id = strtol (argv[4], NULL, 10);
}
res = xmmsc_playlist_insert_id (conn, playlist, pos, mlib_id);
xmmsc_result_wait (res);
if (xmmsc_result_iserror (res)) {
print_error ("Unable to insert %u at position %u: %s", mlib_id,
pos, xmmsc_result_get_error (res));
}
print_info ("Inserted %u at position %u", mlib_id, pos);
xmmsc_result_unref (res);
}
static void
playlist_setup_pshuffle (xmmsc_connection_t *conn, xmmsv_coll_t *coll, gchar *ref)
{
xmmsc_result_t *psres;
xmmsv_coll_t *refcoll;
gchar *s_name, *s_namespace;
if (!coll_read_collname (ref, &s_name, &s_namespace)) {
print_error ("invalid source collection name");
}
/* Quick shortcut to use Universe for "All Media" */
if (strcmp (s_name, "All Media") == 0) {
refcoll = xmmsv_coll_universe ();
} else {
psres = xmmsc_coll_get (conn, s_name, s_namespace);
xmmsc_result_wait (psres);
if (xmmsc_result_iserror (psres)) {
print_error ("%s", xmmsc_result_get_error (psres));
}
refcoll = xmmsv_coll_new (XMMS_COLLECTION_TYPE_REFERENCE);
xmmsv_coll_attribute_set (refcoll, "reference", s_name);
xmmsv_coll_attribute_set (refcoll, "namespace", s_namespace);
}
/* Set operand */
xmmsv_coll_add_operand (coll, refcoll);
xmmsv_coll_unref (refcoll);
g_free (s_name);
g_free (s_namespace);
}
static void
pos_move_cb (gint curr, void *userdata)
{
xmmsc_result_t *movres;
pl_pos_udata_t *pack = (pl_pos_udata_t *) userdata;
/* Entries are moved in descending order, pack->inc is used as
* offset both for forward and backward moves, and reset
* inbetween. */
if (curr < pack->pos) {
/* moving forward */
if (pack->inc >= 0) {
pack->inc = -1; /* start inc at -1, decrement */
}
movres = xmmsc_playlist_move_entry (pack->infos->sync, pack->playlist,
curr, pack->pos + pack->inc);
pack->inc--;
} else {
/* moving backward */
movres = xmmsc_playlist_move_entry (pack->infos->sync, pack->playlist,
curr + pack->inc, pack->pos);
pack->inc++;
}
xmmsc_result_wait (movres);
xmmsc_result_unref (movres);
}
void
cmd_move (xmmsc_connection_t *conn, gint argc, gchar **argv)
{
xmmsc_result_t *res;
guint cur_pos, new_pos, arg_start;
gchar *playlist;
if (argc < 4) {
print_error ("You'll need to specifiy current and new position");
}
if (argc == 4) {
playlist = NULL;
arg_start = 2;
} else {
playlist = argv[2];
arg_start = 3;
}
cur_pos = strtol (argv[arg_start], NULL, 10);
new_pos = strtol (argv[arg_start + 1], NULL, 10);
res = xmmsc_playlist_move_entry (conn, playlist, cur_pos, new_pos);
xmmsc_result_wait (res);
if (xmmsc_result_iserror (res)) {
print_error ("Unable to move playlist entry: %s",
xmmsc_result_get_error (res));
}
xmmsc_result_unref (res);
print_info ("Moved %u to %u", cur_pos, new_pos);
}
void
coll_rename (cli_infos_t *infos, gchar *oldname, gchar *newname,
xmmsc_coll_namespace_t ns, gboolean force)
{
xmmsc_result_t *res;
if (force) {
res = xmmsc_coll_remove (infos->sync, newname, ns);
xmmsc_result_wait (res);
/* FIXME(g): check something? */
xmmsc_result_unref (res);
}
res = xmmsc_coll_rename (infos->sync, oldname, newname, ns);
xmmsc_result_wait (res);
done (res, infos);
}
void
cmd_addpls (xmmsc_connection_t *conn, gint argc, gchar **argv)
{
gchar *playlist;
xmmsc_result_t *res, *res2;
xmmsv_t *val;
xmmsv_coll_t *coll;
gchar *url;
if (argc < 3) {
print_error ("Supply path to playlist file");
}
if (argc == 3) {
playlist = NULL;
url = format_url (argv[2], G_FILE_TEST_IS_REGULAR);
} else {
playlist = argv[2];
url = format_url (argv[3], G_FILE_TEST_IS_REGULAR);
}
res = xmmsc_coll_idlist_from_playlist_file (conn, url);
g_free (url);
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
if (xmmsv_is_error (val)) {
print_error ("%s", xmmsv_get_error_old (val));
}
if (!xmmsv_get_coll (val, &coll)) {
print_error ("Couldn't get collection from result!");
}
res2 = xmmsc_playlist_add_idlist (conn, playlist, coll);
xmmsc_result_wait (res2);
if (xmmsc_result_iserror (res2)) {
print_error ("%s", xmmsc_result_get_error (res2));
}
print_info ("Playlist with %d entries added", xmmsv_coll_idlist_get_size (coll));
xmmsc_result_unref (res);
xmmsc_result_unref (res2);
}
void
playback_pause (cli_infos_t *infos)
{
xmmsc_result_t *res;
res = xmmsc_playback_pause (infos->sync);
xmmsc_result_wait (res);
done (res, infos);
}
void
set_next_rel (cli_infos_t *infos, gint offset)
{
xmmsc_result_t *res;
res = xmmsc_playlist_set_next_rel (infos->sync, offset);
xmmsc_result_wait (res);
tickle (res, infos);
}
static void
pos_remove_cb (gint pos, void *userdata)
{
xmmsc_result_t *res;
pl_pos_udata_t *pack = (pl_pos_udata_t *) userdata;
res = xmmsc_playlist_remove_entry (pack->infos->sync, pack->playlist, pos);
xmmsc_result_wait (res);
xmmsc_result_unref (res);
}
/*
* call-seq:
* res.wait -> self
*
* Waits for _res_ to be handled.
*/
static VALUE
c_wait (VALUE self)
{
RbResult *res = NULL;
Data_Get_Struct (self, RbResult, res);
xmmsc_result_wait (res->real);
return self;
}
void
remove_cached_list (xmmsc_result_t *matching, cli_infos_t *infos)
{
/* FIXME: w00t at code copy-paste, please modularize */
xmmsc_result_t *rmres;
guint plid, id;
gint plsize;
GArray *playlist;
gint i;
const gchar *err;
xmmsv_t *val;
val = xmmsc_result_get_value (matching);
plsize = infos->cache->active_playlist->len;
playlist = infos->cache->active_playlist;
if (xmmsv_get_error (val, &err) || !xmmsv_is_list (val)) {
g_printf (_("Error retrieving the media matching the pattern!\n"));
} else {
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (val, &it);
/* Loop on the playlist (backward, easier to remove) */
for (i = plsize - 1; i >= 0; i--) {
plid = g_array_index (playlist, guint, i);
/* Loop on the matched media */
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_t *entry;
xmmsv_list_iter_entry (it, &entry);
/* If both match, remove! */
if (xmmsv_get_uint (entry, &id) && plid == id) {
rmres = xmmsc_playlist_remove_entry (infos->sync, NULL, i);
xmmsc_result_wait (rmres);
xmmsc_result_unref (rmres);
break;
}
}
}
}
cli_infos_loop_resume (infos);
xmmsc_result_unref (matching);
}
static void
id_coldisp_print_info (cli_infos_t *infos, column_display_t *coldisp, guint id)
{
xmmsc_result_t *infores;
xmmsv_t *info;
infores = xmmsc_medialib_get_info (infos->sync, id);
xmmsc_result_wait (infores);
info = xmmsv_propdict_to_dict (xmmsc_result_get_value (infores), NULL);
column_display_print (coldisp, info);
xmmsc_result_unref (infores);
xmmsv_unref (info);
}
void
print_config (cli_infos_t *infos, xmmsc_result_t *res, gchar *confname)
{
const gchar *confval;
xmmsv_t *val;
if (confname == NULL) {
res = xmmsc_configval_list (infos->sync);
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
xmmsv_dict_foreach (val, print_config_entry, NULL);
} else {
res = xmmsc_configval_get (infos->sync, confname);
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
xmmsv_get_string (val, &confval);
print_config_entry (confname, val, NULL);
}
cli_infos_loop_resume (infos);
xmmsc_result_unref (res);
}
void
configure_playlist (xmmsc_result_t *res, cli_infos_t *infos, gchar *playlist,
gint history, gint upcoming, xmmsv_coll_type_t type,
gchar *input)
{
xmmsc_result_t *saveres;
xmmsv_coll_t *coll;
xmmsv_coll_t *newcoll;
xmmsv_t *val;
gboolean copied = FALSE;
val = xmmsc_result_get_value (res);
if (xmmsv_get_coll (val, &coll)) {
if (type >= 0 && xmmsv_coll_get_type (coll) != type) {
newcoll = coll_copy_retype (coll, type);
coll = newcoll;
copied = TRUE;
}
if (history >= 0) {
coll_int_attribute_set (coll, "history", history);
}
if (upcoming >= 0) {
coll_int_attribute_set (coll, "upcoming", upcoming);
}
if (input) {
/* Replace previous operand. */
newcoll = coll_make_reference (input, XMMS_COLLECTION_NS_COLLECTIONS);
xmmsv_list_clear (xmmsv_coll_operands_get (coll));
xmmsv_coll_add_operand (coll, newcoll);
xmmsv_coll_unref (newcoll);
}
saveres = xmmsc_coll_save (infos->sync, coll, playlist,
XMMS_COLLECTION_NS_PLAYLISTS);
xmmsc_result_wait (saveres);
done (saveres, infos);
} else {
g_printf (_("Cannot find the playlist to configure!\n"));
cli_infos_loop_resume (infos);
}
if (copied) {
xmmsv_coll_unref (coll);
}
xmmsc_result_unref (res);
}
void
position_jump (cli_infos_t *infos, playlist_positions_t *positions)
{
xmmsc_result_t *jumpres;
int pos;
if (playlist_positions_get_single (positions, &pos)) {
jumpres = xmmsc_playlist_set_next (infos->sync, pos);
xmmsc_result_wait (jumpres);
tickle (jumpres, infos);
} else {
g_printf (_("Cannot jump to several positions!\n"));
}
cli_infos_loop_resume (infos);
}
char *
emusic_album_cover_path(const char *picture_front)
{
xmmsc_result_t *res;
xmmsv_t *return_value;
res = xmmsc_bindata_retrieve( em->conn, picture_front );
xmmsc_result_wait (res);
return_value = xmmsc_result_get_value (res);
char *tmp_buf = _on_cover_retrieve(return_value, picture_front);
//xmmsv_unref (return_value);
xmmsc_result_unref (res);
return tmp_buf;
}
void
cmd_playlist_load (xmmsc_connection_t *conn, gint argc, gchar **argv)
{
xmmsc_result_t *res;
if (argc < 4) {
print_error ("Supply a playlist name");
}
res = xmmsc_playlist_load (conn, argv[3]);
xmmsc_result_wait (res);
if (xmmsc_result_iserror (res)) {
print_error ("%s", xmmsc_result_get_error (res));
}
xmmsc_result_unref (res);
}
void
cmd_rinsert (xmmsc_connection_t *conn, gint argc, gchar **argv)
{
gchar *playlist;
gchar *endptr;
xmmsc_result_t *res;
guint pos;
gint i, fileargn;
if (argc < 4) {
print_error ("Missing argument(s)");
}
pos = strtol (argv[2], &endptr, 10);
if (*endptr == '\0') {
playlist = NULL; /* No playlist name */
fileargn = 3;
} else {
playlist = argv[2]; /* extract playlist name */
pos = strtol (argv[3], NULL, 10);
fileargn = 4;
}
for (i = fileargn; i < argc; i++) {
gchar *rfile;
rfile = format_url (argv[i], G_FILE_TEST_IS_DIR);
if (!rfile) {
print_info ("Ignoring invalid path '%s'", argv[i]);
continue;
}
res = xmmsc_playlist_rinsert (conn, playlist, pos, rfile);
g_free (rfile);
xmmsc_result_wait (res);
if (xmmsc_result_iserror (res)) {
print_info ("Cannot insert path '%s' at position %u: %s",
argv[i], pos, xmmsc_result_get_error (res));
}
xmmsc_result_unref (res);
}
}
/* Apply operation to an idlist */
void
apply_ids (cli_infos_t *infos, xmmsc_result_t *res, idlist_command_t cmd)
{
const gchar *err;
xmmsc_result_t *cmdres;
xmmsv_t *val;
val = xmmsc_result_get_value (res);
if (!xmmsv_get_error (val, &err)) {
xmmsv_list_iter_t *it;
xmmsv_get_list_iter (val, &it);
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
xmmsv_t *entry;
guint id;
xmmsv_list_iter_entry (it, &entry);
if (xmmsv_get_uint (entry, &id)) {
switch (cmd) {
case IDLIST_CMD_REHASH:
cmdres = xmmsc_medialib_rehash (infos->sync, id);
break;
case IDLIST_CMD_REMOVE:
cmdres = xmmsc_medialib_remove_entry (infos->sync, id);
break;
default:
break;
}
xmmsc_result_wait (cmdres);
xmmsc_result_unref (cmdres);
}
}
} else {
g_printf (_("Server error: %s\n"), err);
}
cli_infos_loop_resume (infos);
xmmsc_result_unref (res);
}