static gint
update_active_playlist (xmmsv_t *val, void *udata)
{
cli_infos_t *infos = (cli_infos_t *) udata;
cli_cache_t *cache = infos->cache;
xmmsc_result_t *refres;
gint pos, newpos, type;
gint id;
const gchar *name;
xmmsv_dict_entry_get_int (val, "type", &type);
xmmsv_dict_entry_get_int (val, "position", &pos);
xmmsv_dict_entry_get_int (val, "id", &id);
xmmsv_dict_entry_get_string (val, "name", &name);
/* Active playlist not changed, nevermind */
if (strcmp (name, cache->active_playlist_name) != 0) {
return TRUE;
}
/* Apply changes to the cached playlist */
switch (type) {
case XMMS_PLAYLIST_CHANGED_ADD:
g_array_append_val (cache->active_playlist, id);
break;
case XMMS_PLAYLIST_CHANGED_INSERT:
g_array_insert_val (cache->active_playlist, pos, id);
break;
case XMMS_PLAYLIST_CHANGED_MOVE:
xmmsv_dict_entry_get_int (val, "newposition", &newpos);
g_array_remove_index (cache->active_playlist, pos);
g_array_insert_val (cache->active_playlist, newpos, id);
break;
case XMMS_PLAYLIST_CHANGED_REMOVE:
g_array_remove_index (cache->active_playlist, pos);
break;
case XMMS_PLAYLIST_CHANGED_SHUFFLE:
case XMMS_PLAYLIST_CHANGED_SORT:
case XMMS_PLAYLIST_CHANGED_CLEAR:
/* Oops, reload the whole playlist */
refres = xmmsc_playlist_list_entries (infos->conn, XMMS_ACTIVE_PLAYLIST);
xmmsc_result_notifier_set (refres, &refresh_active_playlist, infos->cache);
xmmsc_result_unref (refres);
freshness_requested (&cache->freshness_active_playlist);
break;
}
return TRUE;
}
static void
currently_playing_update_info (currently_playing_t *entry, xmmsv_t *value)
{
const gchar *noinfo_fields[] = { "playback_status", "playtime", "position"};
const gchar *time_fields[] = { "duration"};
xmmsv_t *info;
gint i;
info = xmmsv_propdict_to_dict (value, NULL);
enrich_mediainfo (info);
/* copy over fields that are not from metadata */
for (i = 0; i < G_N_ELEMENTS (noinfo_fields); i++) {
xmmsv_t *copy;
if (xmmsv_dict_get (entry->data, noinfo_fields[i], ©)) {
xmmsv_dict_set (info, noinfo_fields[i], copy);
}
}
/* pretty format time fields */
for (i = 0; i < G_N_ELEMENTS (time_fields); i++) {
gint32 tim;
if (xmmsv_dict_entry_get_int (info, time_fields[i], &tim)) {
gchar *p = format_time (tim, FALSE);
xmmsv_dict_set_string (info, time_fields[i], p);
g_free (p);
}
}
xmmsv_unref (entry->data);
entry->data = info;
}
/* Extract the int value out of a xmmsv_t object. */
static gint
value_get_dict_int (xmmsv_t *val, const gchar *key)
{
gint i;
xmmsv_dict_entry_get_int (val, key, &i);
return i;
}
/**
* Retrieve an integer attribute from the given collection.
*
* @param coll The collection to retrieve the attribute from.
* @param key The name of the attribute.
* @param value The value of the attribute if found (owned by the collection).
* @return 1 if the attribute was found, 0 otherwise
*/
int
xmmsv_coll_attribute_get_int32 (xmmsv_t *coll, const char *key, int32_t *val)
{
int64_t raw_val;
x_return_val_if_fail (xmmsv_is_type (coll, XMMSV_TYPE_COLL), 0);
if (xmmsv_dict_entry_get_int (coll->value.coll->attributes, key, &raw_val)) {
*val = INT64_TO_INT32 (raw_val);
return true;
}
return false;
}
static gint
refresh_currpos (xmmsv_t *val, void *udata)
{
cli_cache_t *cache = (cli_cache_t *) udata;
if (!xmmsv_is_error (val)) {
xmmsv_dict_entry_get_int (val, "position", &cache->currpos);
} else {
/* Current pos not set */
cache->currpos = -1;
}
freshness_received (&cache->freshness_currpos);
return TRUE;
}
/**
* Recursively scan a directory for media files.
*
* @return a reverse sorted list of encoded urls
*/
static gboolean
process_dir (xmms_medialib_t *medialib, xmmsv_t *entries,
const gchar *directory, xmms_error_t *error)
{
xmmsv_list_iter_t *it;
xmmsv_t *list, *val;
list = xmms_xform_browse (directory, error);
if (!list) {
return FALSE;
}
xmmsv_get_list_iter (list, &it);
while (xmmsv_list_iter_entry (it, &val)) {
const gchar *str;
gint isdir;
xmmsv_dict_entry_get_string (val, "path", &str);
xmmsv_dict_entry_get_int (val, "isdir", &isdir);
if (isdir == 1) {
process_dir (medialib, entries, str, error);
} else {
xmms_medialib_session_t *session;
xmms_medialib_entry_t entry;
do {
session = xmms_medialib_session_begin (medialib);
entry = xmms_medialib_entry_new_encoded (session, str, error);
} while (!xmms_medialib_session_commit (session));
if (entry) {
xmmsv_coll_idlist_append (entries, entry);
}
}
xmmsv_list_iter_remove (it);
}
xmmsv_unref (list);
return TRUE;
}
static void
print_server_stats (xmmsc_result_t *res)
{
gint uptime;
const gchar *version, *err;
xmmsv_t *val;
val = xmmsc_result_get_value (res);
if (!xmmsv_get_error (val, &err)) {
xmmsv_dict_entry_get_string (val, "version", &version);
xmmsv_dict_entry_get_int (val, "uptime", &uptime);
g_printf ("uptime = %d\n"
"version = %s\n", uptime, version);
} else {
g_printf ("Server error: %s\n", err);
}
}
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 int
handle_mediainfo (xmmsv_t *v, void *userdata)
{
static const gchar *props[] = {"chain", NULL};
static const gchar *pref[] = {"server", NULL};
GString *str;
const gchar *tstr;
gint tint, i;
xmmsv_t *dict;
str = g_string_new ("");
/* convert propdict to dict */
dict = xmmsv_propdict_to_dict (v, pref);
for (i = 0; props[i]; i++) {
switch (xmmsv_dict_entry_get_type (dict, props[i])) {
case XMMSV_TYPE_STRING:
if (xmmsv_dict_entry_get_string (dict, props[i], &tstr)) {
g_string_append_printf (str, "%s=%s\n", props[i], tstr);
}
break;
case XMMSV_TYPE_INT32:
if (xmmsv_dict_entry_get_int (dict, props[i], &tint)) {
g_string_append_printf (str, "%s=%d\n", props[i], tint);
}
break;
default:
/* noop */
break;
}
}
send_msg ("New media", str);
g_string_free (str, TRUE);
return TRUE; /* keep broadcast alive */
}
static gint
update_active_playlist_name (xmmsv_t *val, void *udata)
{
cli_cache_t *cache = (cli_cache_t *) udata;
gint type;
const gchar *name, *newname;
xmmsv_dict_entry_get_int (val, "type", &type);
xmmsv_dict_entry_get_string (val, "name", &name);
/* Active playlist have not been renamed */
if (strcmp (name, cache->active_playlist_name) != 0) {
return TRUE;
}
if (type == XMMS_COLLECTION_CHANGED_RENAME) {
g_free (cache->active_playlist_name);
xmmsv_dict_entry_get_string (val, "newname", &newname);
cache->active_playlist_name = g_strdup (newname);
}
return TRUE;
}
/**
* Unit test predicate
*/
static void
run_unit_test (xmms_medialib_t *mlib, const gchar *name, xmmsv_t *content,
xmmsv_coll_t *coll, xmmsv_t *specification, xmmsv_t *expected,
gint format, const gchar *datasetname)
{
gboolean matches, ordered = FALSE;
xmmsv_t *ret, *value;
xmms_error_t err;
xmms_medialib_t *medialib;
xmms_medialib_session_t *session;
g_debug ("Running test: %s", name);
xmms_ipc_init ();
xmms_config_init ("memory://");
xmms_config_property_register ("medialib.path", "memory://", NULL, NULL);
medialib = xmms_medialib_init ();
populate_medialib (medialib, content);
session = xmms_medialib_session_begin (medialib);
ret = xmms_medialib_query (session, coll, specification, &err);
xmms_medialib_session_commit (session);
xmmsv_dict_get (expected, "result", &value);
xmmsv_dict_entry_get_int (expected, "ordered", &ordered);
if (ordered) {
matches = xmmsv_compare (ret, value);
} else {
matches = xmmsv_compare_unordered (ret, value);
}
if (matches) {
if (format == FORMAT_CSV) {
g_print ("\"%s\", 1\n", name);
} else {
g_print ("............................................................ Success!");
g_print ("\r%s \n", name);
}
} else {
if (format == FORMAT_CSV) {
g_print ("\"%s\", 0\n", name);
} else {
g_print ("............................................................ Failure!");
g_print ("\r%s \n", name);
}
g_printerr ("The result: ");
xmmsv_dump (ret);
g_printerr ("Does not equal: ");
xmmsv_dump (value);
}
xmmsv_unref (ret);
xmms_object_unref (medialib);
xmms_config_shutdown ();
xmms_ipc_shutdown ();
}
/**
* Unit test predicate
*/
static gboolean
run_unit_test (xmms_medialib_t *mlib, const gchar *name, xmmsv_t *content,
xmmsv_t *coll, xmmsv_t *specification, xmmsv_t *expected,
gint format, const gchar *datasetname)
{
gboolean matches, ordered = FALSE;
xmmsv_t *ret, *value;
xmms_medialib_t *medialib;
xmms_coll_dag_t *dag;
gint status;
g_debug ("Running test: %s", name);
xmms_ipc_init ();
xmms_config_init ("memory://");
xmms_config_property_register ("medialib.path", "memory://", NULL, NULL);
medialib = xmms_medialib_init ();
dag = xmms_collection_init (medialib);
populate_medialib (medialib, content);
memory_status_calibrate (name);
ret = XMMS_IPC_CALL (dag, XMMS_IPC_CMD_QUERY,
xmmsv_ref (coll),
xmmsv_ref (specification));
status = memory_status_verify (name);
xmmsv_dict_get (expected, "result", &value);
xmmsv_dict_entry_get_int (expected, "ordered", &ordered);
if (!xmmsv_is_type (ret, XMMSV_TYPE_ERROR)) {
if (ordered) {
matches = xmmsv_compare (ret, value);
} else {
matches = xmmsv_compare_unordered (ret, value);
}
} else {
matches = FALSE;
}
if (matches && status == MEMORY_OK) {
if (format == FORMAT_CSV) {
g_print ("\"%s\", 1\n", name);
} else {
g_print ("............................................................ Success!");
g_print ("\r%s \n", name);
}
} else {
if (format == FORMAT_CSV) {
g_print ("\"%s\", 0\n", name);
} else {
g_print ("............................................................ Failure!");
if (status & MEMORY_LEAK) {
g_print (" Memory Leaks!");
}
if (status & MEMORY_ERROR) {
g_print (" Memory errors!");
}
g_print ("\r%s \n", name);
}
if (!matches) {
g_printerr ("The result:\n");
xmmsv_dump (ret);
g_printerr ("Does not equal:\n");
xmmsv_dump (value);
}
}
xmmsv_unref (ret);
xmms_object_unref (medialib);
xmms_object_unref (dag);
xmms_config_shutdown ();
xmms_ipc_shutdown ();
return matches && status == MEMORY_OK;
}
/**
* Retrieve an integer attribute from the given collection.
*
* @param coll The collection to retrieve the attribute from.
* @param key The name of the attribute.
* @param value The value of the attribute if found (owned by the collection).
* @return 1 if the attribute was found, 0 otherwise
*/
int
xmmsv_coll_attribute_get_int64 (xmmsv_t *coll, const char *key, int64_t *value)
{
x_return_val_if_fail (xmmsv_is_type (coll, XMMSV_TYPE_COLL), 0);
return xmmsv_dict_entry_get_int (coll->value.coll->attributes, key, value);
}
void
cmd_list (xmmsc_connection_t *conn, gint argc, gchar **argv)
{
gchar *playlist = NULL;
xmmsc_result_t *res;
xmmsv_t *val;
xmmsv_list_iter_t *it;
gulong total_playtime = 0;
gint p = 0;
guint pos = 0;
if (argc > 2) {
playlist = argv[2];
}
res = xmmsc_playlist_current_pos (conn, playlist);
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
if (!xmmsv_is_error (val)) {
if (!xmmsv_dict_entry_get_int (val, "position", &p)) {
print_error ("Broken resultset");
}
xmmsc_result_unref (res);
}
res = xmmsc_playlist_list_entries (conn, playlist);
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)) {
xmmsc_result_t *info_res;
xmmsv_t *val_id, *propdict, *info_val;
gchar line[80];
gint playtime = 0;
guint ui;
xmmsv_list_iter_entry (it, &val_id);
if (!xmmsv_get_uint (val_id, &ui)) {
print_error ("Broken resultset");
}
info_res = xmmsc_medialib_get_info (conn, ui);
xmmsc_result_wait (info_res);
propdict = xmmsc_result_get_value (info_res);
info_val = xmmsv_propdict_to_dict (propdict, NULL);
if (xmmsv_is_error (info_val)) {
print_error ("%s", xmmsv_get_error_old (info_val));
}
if (xmmsv_dict_entry_get_int (info_val, "duration", &playtime)) {
total_playtime += playtime;
}
if (val_has_key (info_val, "channel")) {
if (val_has_key (info_val, "title")) {
xmmsc_entry_format (line, sizeof (line),
"[stream] ${title}", info_val);
} else {
xmmsc_entry_format (line, sizeof (line),
"${channel}", info_val);
}
} else if (!val_has_key (info_val, "title")) {
const gchar *url;
gchar dur[10];
xmmsc_entry_format (dur, sizeof (dur),
"(${minutes}:${seconds})", info_val);
if (xmmsv_dict_entry_get_string (info_val, "url", &url)) {
gchar *filename = g_path_get_basename (url);
if (filename) {
g_snprintf (line, sizeof (line), "%s %s", filename, dur);
g_free (filename);
} else {
g_snprintf (line, sizeof (line), "%s %s", url, dur);
}
}
} else {
xmmsc_entry_format (line, sizeof (line), listformat, info_val);
}
if (p == pos) {
print_info ("->[%d/%d] %s", pos, ui, line);
} else {
print_info (" [%d/%d] %s", pos, ui, line);
}
pos++;
xmmsc_result_unref (info_res);
xmmsv_unref (info_val);
xmmsv_list_iter_next (it);
}
xmmsc_result_unref (res);
/* rounding */
total_playtime += 500;
print_info ("\nTotal playtime: %d:%02d:%02d", total_playtime / 3600000,
(total_playtime / 60000) % 60, (total_playtime / 1000) % 60);
}
