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);
}
static gint
xmms_playlist_client_set_next_rel (xmms_playlist_t *playlist, gint32 pos,
xmms_error_t *err)
{
gint currpos, newpos, size;
xmms_medialib_entry_t mid = 0;
xmmsv_coll_t *plcoll;
g_return_val_if_fail (playlist, FALSE);
g_mutex_lock (playlist->mutex);
plcoll = xmms_playlist_get_coll (playlist, XMMS_ACTIVE_PLAYLIST, err);
if (plcoll != NULL) {
currpos = xmms_playlist_coll_get_currpos (plcoll);
if (playlist->repeat_all) {
newpos = pos + currpos;
size = (gint) xmmsv_coll_idlist_get_size (plcoll);
if (size > 0) {
newpos %= size;
if (newpos < 0) {
newpos += size;
}
}
mid = xmms_playlist_set_current_position_do (playlist, newpos, err);
} else {
if (currpos + pos >= 0) {
mid = xmms_playlist_set_current_position_do (playlist,
currpos + pos,
err);
} else {
xmms_error_set (err, XMMS_ERROR_INVAL,
"Can't set pos outside the current playlist!");
}
}
}
g_mutex_unlock (playlist->mutex);
return mid;
}
static xmmsv_coll_t *
coll_copy_retype (xmmsv_coll_t *coll, xmmsv_coll_type_t type)
{
xmmsv_coll_t *copy;
gint idlistsize;
gint i;
guint id;
copy = xmmsv_coll_new (type);
idlistsize = xmmsv_coll_idlist_get_size (coll);
for (i = 0; i < idlistsize; i++) {
xmmsv_coll_idlist_get_index (coll, i, &id);
xmmsv_coll_idlist_append (copy, id);
}
xmmsv_coll_attribute_foreach (coll, coll_copy_attributes, copy);
return copy;
}
/** Get the size of the given playlist (compute and update it if absent). */
static gint
xmms_playlist_coll_get_size (xmmsv_coll_t *plcoll)
{
return xmmsv_coll_idlist_get_size (plcoll);
}
unsigned int Idlist::size() const
{
return xmmsv_coll_idlist_get_size( coll_ );
}
static void
playlist_coll_idlist_get_size (xmmsv_t *coll, gint *length)
{
*length = xmmsv_coll_idlist_get_size (coll);
}
static bool
_internal_put_on_bb_collection (xmmsv_t *bb, xmmsv_coll_t *coll)
{
xmmsv_list_iter_t *it;
xmmsv_t *v, *attrs;
int n;
uint32_t ret;
int32_t entry;
xmmsv_coll_t *op;
if (!bb || !coll) {
return false;
}
/* push type */
if (!xmmsv_bitbuffer_put_bits (bb, 32, xmmsv_coll_get_type (coll)))
return false;
/* attribute counter and values */
attrs = xmmsv_coll_attributes_get (coll);
n = 0;
xmmsv_dict_foreach (attrs, _internal_put_on_bb_count_coll_attr, &n);
if (!xmmsv_bitbuffer_put_bits (bb, 32, n))
return false;
/* needs error checking! */
xmmsv_dict_foreach (attrs, _internal_put_on_bb_append_coll_attr, bb);
attrs = NULL; /* no unref needed. */
/* idlist counter and content */
xmmsv_bitbuffer_put_bits (bb, 32, xmmsv_coll_idlist_get_size (coll));
xmmsv_get_list_iter (xmmsv_coll_idlist_get (coll), &it);
for (xmmsv_list_iter_first (it);
xmmsv_list_iter_valid (it);
xmmsv_list_iter_next (it)) {
if (!xmmsv_list_iter_entry_int (it, &entry)) {
x_api_error ("Non integer in idlist", 0);
}
xmmsv_bitbuffer_put_bits (bb, 32, entry);
}
xmmsv_list_iter_explicit_destroy (it);
/* operands counter and objects */
n = 0;
if (xmmsv_coll_get_type (coll) != XMMS_COLLECTION_TYPE_REFERENCE) {
n = xmmsv_list_get_size (xmmsv_coll_operands_get (coll));
}
ret = xmmsv_bitbuffer_pos (bb);
xmmsv_bitbuffer_put_bits (bb, 32, n);
if (n > 0) {
xmmsv_get_list_iter (xmmsv_coll_operands_get (coll), &it);
while (xmmsv_list_iter_entry (it, &v)) {
if (!xmmsv_get_coll (v, &op)) {
x_api_error ("Non collection operand", 0);
}
_internal_put_on_bb_int32 (bb, XMMSV_TYPE_COLL);
ret = _internal_put_on_bb_collection (bb, op);
xmmsv_list_iter_next (it);
}
}
return ret;
}
void
cmd_playlist_type (xmmsc_connection_t *conn, gint argc, gchar **argv)
{
gchar *name;
xmmsv_coll_type_t prevtype, newtype;
xmmsc_result_t *res;
xmmsv_t *val;
xmmsv_coll_t *coll;
/* Read playlist name */
if (argc < 4) {
print_error ("usage: type_playlist [playlistname] [type] [options]");
}
name = argv[3];
/* Retrieve the playlist operator */
res = xmmsc_coll_get (conn, name, XMMS_COLLECTION_NS_PLAYLISTS);
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_coll (val, &coll);
prevtype = xmmsv_coll_get_type (coll);
/* No type argument, simply display the current type */
if (argc < 5) {
print_info (get_playlist_type_string (prevtype));
/* Type argument, set the new type */
} else {
gint typelen;
gint idlistsize;
xmmsc_result_t *saveres;
xmmsv_coll_t *newcoll;
gint i;
typelen = strlen (argv[4]);
if (g_ascii_strncasecmp (argv[4], "list", typelen) == 0) {
newtype = XMMS_COLLECTION_TYPE_IDLIST;
} else if (g_ascii_strncasecmp (argv[4], "queue", typelen) == 0) {
newtype = XMMS_COLLECTION_TYPE_QUEUE;
} else if (g_ascii_strncasecmp (argv[4], "pshuffle", typelen) == 0) {
newtype = XMMS_COLLECTION_TYPE_PARTYSHUFFLE;
/* Setup operand for party shuffle (set operand) ! */
if (argc < 6) {
print_error ("Give the source collection for the party shuffle");
}
} else {
print_error ("Invalid playlist type (valid types: list, queue, pshuffle)");
}
/* Copy collection idlist, attributes and operand (if needed) */
newcoll = xmmsv_coll_new (newtype);
idlistsize = xmmsv_coll_idlist_get_size (coll);
for (i = 0; i < idlistsize; i++) {
guint id;
xmmsv_coll_idlist_get_index (coll, i, &id);
xmmsv_coll_idlist_append (newcoll, id);
}
xmmsv_coll_attribute_foreach (coll, coll_copy_attributes, newcoll);
if (newtype == XMMS_COLLECTION_TYPE_PARTYSHUFFLE) {
playlist_setup_pshuffle (conn, newcoll, argv[5]);
}
/* Overwrite with new collection */
saveres = xmmsc_coll_save (conn, newcoll, name, XMMS_COLLECTION_NS_PLAYLISTS);
xmmsc_result_wait (saveres);
if (xmmsc_result_iserror (saveres)) {
print_error ("Couldn't save %s : %s",
name, xmmsc_result_get_error (saveres));
}
xmmsv_coll_unref (newcoll);
xmmsc_result_unref (saveres);
}
xmmsc_result_unref (res);
}
