static void
__int_xmms_cmd_set_property_int (xmms_object_t *object, xmms_object_cmd_arg_t *arg)
{
xmmsv_t *t;
if (xmmsv_list_get_size (arg->args) != 4) {
XMMS_DBG ("Wrong number of arguments to set_property_int (%d)", xmmsv_list_get_size (arg->args));
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Wrong number of arguments to set_property_int");
return;
}
gint32 argval0;
const char * argval1;
const char * argval2;
gint32 argval3;
if (!xmmsv_list_get (arg->args, 0, &t)) {
XMMS_DBG ("Missing arg 0 in set_property_int");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 0 in set_property_int");
return;
}
if (!xmmsv_get_int (t, &argval0)) {
XMMS_DBG ("Error parsing arg 0 in set_property_int");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 0 in set_property_int");
return;
}
if (!xmmsv_list_get (arg->args, 1, &t)) {
XMMS_DBG ("Missing arg 1 in set_property_int");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 1 in set_property_int");
return;
}
if (!xmmsv_get_string (t, &argval1)) {
XMMS_DBG ("Error parsing arg 1 in set_property_int");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 1 in set_property_int");
return;
}
if (!xmmsv_list_get (arg->args, 2, &t)) {
XMMS_DBG ("Missing arg 2 in set_property_int");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 2 in set_property_int");
return;
}
if (!xmmsv_get_string (t, &argval2)) {
XMMS_DBG ("Error parsing arg 2 in set_property_int");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 2 in set_property_int");
return;
}
if (!xmmsv_list_get (arg->args, 3, &t)) {
XMMS_DBG ("Missing arg 3 in set_property_int");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 3 in set_property_int");
return;
}
if (!xmmsv_get_int (t, &argval3)) {
XMMS_DBG ("Error parsing arg 3 in set_property_int");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 3 in set_property_int");
return;
}
xmms_medialib_client_set_property_int ((xmms_medialib_t *) object, argval0, argval1, argval2, argval3, &arg->error);
arg->retval = xmmsv_new_none ();
}
static void
xmms_ipc_register_broadcast (xmms_ipc_client_t *client,
xmms_ipc_msg_t *msg, xmmsv_t *arguments)
{
xmmsv_t *arg;
gint32 broadcastid;
int r;
if (!arguments || !xmmsv_list_get (arguments, 0, &arg)) {
xmms_log_error ("No broadcastid in this msg?!");
return;
}
r = xmmsv_get_int (arg, &broadcastid);
if (!r) {
xmms_log_error ("Cannot extract broadcast id from value");
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);
}
static void
xmms_ipc_register_signal (xmms_ipc_client_t *client,
xmms_ipc_msg_t *msg, xmmsv_t *arguments)
{
xmmsv_t *arg;
gint32 signalid;
int r;
if (!arguments || !xmmsv_list_get (arguments, 0, &arg)) {
xmms_log_error ("No signalid in this msg?!");
return;
}
r = xmmsv_get_int (arg, &signalid);
if (!r) {
xmms_log_error ("Cannot extract signal id from value");
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);
}
static void
__int_xmms_cmd_remove (xmms_object_t *object, xmms_object_cmd_arg_t *arg)
{
xmmsv_t *t;
if (xmmsv_list_get_size (arg->args) != 1) {
XMMS_DBG ("Wrong number of arguments to remove (%d)", xmmsv_list_get_size (arg->args));
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Wrong number of arguments to remove");
return;
}
const char * argval0;
if (!xmmsv_list_get (arg->args, 0, &t)) {
XMMS_DBG ("Missing arg 0 in remove");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 0 in remove");
return;
}
if (!xmmsv_get_string (t, &argval0)) {
XMMS_DBG ("Error parsing arg 0 in remove");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 0 in remove");
return;
}
xmms_bindata_client_remove ((xmms_bindata_t *) object, argval0, &arg->error);
arg->retval = xmmsv_new_none ();
}
static void
__int_xmms_cmd_add (xmms_object_t *object, xmms_object_cmd_arg_t *arg)
{
xmmsv_t *t;
if (xmmsv_list_get_size (arg->args) != 1) {
XMMS_DBG ("Wrong number of arguments to add (%d)", xmmsv_list_get_size (arg->args));
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Wrong number of arguments to add");
return;
}
GString * argval0;
if (!xmmsv_list_get (arg->args, 0, &t)) {
XMMS_DBG ("Missing arg 0 in add");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 0 in add");
return;
}
if (!xmms_bin_to_gstring (t, &argval0)) {
XMMS_DBG ("Error parsing arg 0 in add");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 0 in add");
return;
}
gchar * retval = xmms_bindata_client_add ((xmms_bindata_t *) object, argval0, &arg->error);
if (retval != NULL) {
arg->retval = xmms_convert_and_kill_string (retval);
}
}
static gboolean
type_and_msg_to_arg (xmmsv_type_t expected_type, xmmsv_t *argument_list,
xmms_object_cmd_arg_t *arg, gint i)
{
xmmsv_t *arg_value;
xmmsv_type_t actual_type;
if (argument_list && xmmsv_list_get (argument_list, i, &arg_value)) {
xmmsv_ref (arg_value);
} else {
arg_value = xmmsv_new_none ();
}
actual_type = xmmsv_get_type (arg_value);
if (actual_type != expected_type) {
XMMS_DBG ("Expected type %i, but got type %i",
expected_type, actual_type);
xmmsv_unref (arg_value);
return FALSE;
} else {
arg->values[i] = arg_value;
return TRUE;
}
}
static void
__int_xmms_cmd_rehash (xmms_object_t *object, xmms_object_cmd_arg_t *arg)
{
xmmsv_t *t;
if (xmmsv_list_get_size (arg->args) != 1) {
XMMS_DBG ("Wrong number of arguments to rehash (%d)", xmmsv_list_get_size (arg->args));
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Wrong number of arguments to rehash");
return;
}
gint32 argval0;
if (!xmmsv_list_get (arg->args, 0, &t)) {
XMMS_DBG ("Missing arg 0 in rehash");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 0 in rehash");
return;
}
if (!xmmsv_get_int (t, &argval0)) {
XMMS_DBG ("Error parsing arg 0 in rehash");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 0 in rehash");
return;
}
xmms_medialib_client_rehash ((xmms_medialib_t *) object, argval0, &arg->error);
arg->retval = xmmsv_new_none ();
}
CollPtr PartyShuffle::getOperand() const
{
xmmsv_t *operands, *operand;
// Find the operand
operands = xmmsv_coll_operands_get( coll_ );
if( !xmmsv_list_get( operands, 0, &operand ) ) {
throw missing_operand_error( "No operand in this operator!" );
}
return CollResult::createColl( operand );
}
static void
xmms_medialib_session_free_full (xmms_medialib_session_t *session)
{
xmmsv_t *val;
gint i;
if (session->vals != NULL) {
for (i = 0; xmmsv_list_get (session->vals, i, &val); i++)
xmmsv_unref (val);
}
xmms_medialib_session_free (session);
}
static void
__int_xmms_cmd_move_entry (xmms_object_t *object, xmms_object_cmd_arg_t *arg)
{
xmmsv_t *t;
if (xmmsv_list_get_size (arg->args) != 2) {
XMMS_DBG ("Wrong number of arguments to move_entry (%d)", xmmsv_list_get_size (arg->args));
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Wrong number of arguments to move_entry");
return;
}
gint32 argval0;
const char * argval1;
if (!xmmsv_list_get (arg->args, 0, &t)) {
XMMS_DBG ("Missing arg 0 in move_entry");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 0 in move_entry");
return;
}
if (!xmmsv_get_int (t, &argval0)) {
XMMS_DBG ("Error parsing arg 0 in move_entry");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 0 in move_entry");
return;
}
if (!xmmsv_list_get (arg->args, 1, &t)) {
XMMS_DBG ("Missing arg 1 in move_entry");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 1 in move_entry");
return;
}
if (!xmmsv_get_string (t, &argval1)) {
XMMS_DBG ("Error parsing arg 1 in move_entry");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 1 in move_entry");
return;
}
xmms_medialib_client_move_entry ((xmms_medialib_t *) object, argval0, argval1, &arg->error);
arg->retval = xmmsv_new_none ();
}
static void
query_append_intersect_operand (coll_query_t *query, xmms_coll_dag_t *dag,
xmmsv_coll_t *coll)
{
xmmsv_coll_t *op;
xmmsv_t *tmp;
if (xmmsv_list_get (xmmsv_coll_operands_get (coll), 0, &tmp)) {
xmmsv_get_coll (tmp, &op);
if (!operator_is_allmedia (op)) {
query_append_string (query, " AND ");
xmms_collection_append_to_query (dag, op, query);
}
}
}
static void
pl_print_config (xmmsv_coll_t *coll, const char *name)
{
xmmsv_coll_t *op;
xmmsv_coll_type_t type;
gchar *upcoming = NULL;
gchar *history = NULL;
gchar *input = NULL;
gchar *input_ns = NULL;
xmmsv_t *v;
type = xmmsv_coll_get_type (coll);
xmmsv_coll_attribute_get (coll, "upcoming", &upcoming);
xmmsv_coll_attribute_get (coll, "history", &history);
g_printf (_("name: %s\n"), name);
switch (type) {
case XMMS_COLLECTION_TYPE_IDLIST:
g_printf (_("type: list\n"));
break;
case XMMS_COLLECTION_TYPE_QUEUE:
g_printf (_("type: queue\n"));
g_printf (_("history: %s\n"), history);
break;
case XMMS_COLLECTION_TYPE_PARTYSHUFFLE:
if (xmmsv_list_get (xmmsv_coll_operands_get (coll), 0, &v) &&
xmmsv_get_coll (v, &op)) {
xmmsv_coll_attribute_get (op, "reference", &input);
xmmsv_coll_attribute_get (op, "namespace", &input_ns);
}
g_printf (_("type: pshuffle\n"));
g_printf (_("history: %s\n"), history);
g_printf (_("upcoming: %s\n"), upcoming);
g_printf (_("input: %s/%s\n"), input_ns, input);
break;
default:
g_printf (_("type: unknown!\n"));
break;
}
}
static void
xmms_playlist_update_partyshuffle (xmms_playlist_t *playlist,
const gchar *plname, xmmsv_coll_t *coll)
{
gint history, upcoming, currpos, size;
xmmsv_coll_t *src;
xmmsv_t *tmp;
XMMS_DBG ("PLAYLIST: Update partyshuffle.");
if (!xmms_collection_get_int_attr (coll, "history", &history)) {
history = 0;
}
if (!xmms_collection_get_int_attr (coll, "upcoming", &upcoming)) {
upcoming = XMMS_DEFAULT_PARTYSHUFFLE_UPCOMING;
}
currpos = xmms_playlist_coll_get_currpos (coll);
while (currpos > history) {
/* Removing entries is fast enough to be processed at once. */
xmms_playlist_remove_unlocked (playlist, plname, coll, 0, NULL);
currpos = xmms_playlist_coll_get_currpos (coll);
}
g_return_if_fail(xmmsv_list_get (xmmsv_coll_operands_get (coll), 0, &tmp));
g_return_if_fail(xmmsv_get_coll (tmp, &src));
/* Since getting random media can be slow on huge medialibs, we refill only
* one entry at a time. This let other threads a chance to get the lock on
* the playlist object as soon as possible. */
size = xmms_playlist_coll_get_size (coll);
if (size < currpos + 1 + upcoming) {
xmms_medialib_entry_t randentry;
randentry = xmms_collection_get_random_media (playlist->colldag, src);
if (randentry > 0) {
xmms_playlist_add_entry_unlocked (playlist, plname, coll, randentry, NULL);
}
}
}
static void
__int_xmms_cmd_get_id (xmms_object_t *object, xmms_object_cmd_arg_t *arg)
{
xmmsv_t *t;
if (xmmsv_list_get_size (arg->args) != 1) {
XMMS_DBG ("Wrong number of arguments to get_id (%d)", xmmsv_list_get_size (arg->args));
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Wrong number of arguments to get_id");
return;
}
const char * argval0;
if (!xmmsv_list_get (arg->args, 0, &t)) {
XMMS_DBG ("Missing arg 0 in get_id");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Missing arg 0 in get_id");
return;
}
if (!xmmsv_get_string (t, &argval0)) {
XMMS_DBG ("Error parsing arg 0 in get_id");
xmms_error_set (&arg->error, XMMS_ERROR_INVAL, "Error parsing arg 0 in get_id");
return;
}
arg->retval = xmmsv_new_int (xmms_medialib_client_get_id ((xmms_medialib_t *) object, argval0, &arg->error));
}
/** Sorts the playlist by properties.
*
* This will sort the list.
* @param playlist The playlist to sort.
* @param properties Tells xmms_playlist_sort which properties it
* should use when sorting.
* @param err An #xmms_error_t - needed since xmms_playlist_sort is an ipc
* method handler.
*/
static void
xmms_playlist_client_sort (xmms_playlist_t *playlist, const gchar *plname,
xmmsv_t *properties, xmms_error_t *err)
{
xmmsv_t *tmp, *idlist, *val, *spec, *metadata, *get;
xmmsv_coll_t *plcoll, *ordered;
gint currpos, pos;
xmms_medialib_entry_t currid;
g_return_if_fail (playlist);
g_return_if_fail (properties);
if (xmmsv_list_get_size (properties) < 1) {
xmms_error_set (err, XMMS_ERROR_NOENT,
"need at least one property to sort");
return;
}
g_mutex_lock (playlist->mutex);
plcoll = xmms_playlist_get_coll (playlist, plname, err);
if (plcoll == NULL) {
xmms_error_set (err, XMMS_ERROR_NOENT, "no such playlist!");
g_mutex_unlock (playlist->mutex);
return;
}
currpos = xmms_playlist_coll_get_currpos (plcoll);
xmmsv_coll_idlist_get_index (plcoll, currpos, &currid);
get = xmmsv_new_list ();
xmmsv_list_append_string (get, "id");
metadata = xmmsv_new_dict ();
xmmsv_dict_set_string (metadata, "type", "metadata");
xmmsv_dict_set_string (metadata, "aggregate", "first");
xmmsv_dict_set (metadata, "get", get);
xmmsv_unref (get);
spec = xmmsv_new_dict ();
xmmsv_dict_set_string (spec, "type", "cluster-list");
xmmsv_dict_set_string (spec, "cluster-by", "position");
xmmsv_dict_set (spec, "data", metadata);
xmmsv_unref (metadata);
ordered = xmmsv_coll_add_order_operators (plcoll, properties);
MEDIALIB_BEGIN (playlist->medialib);
tmp = xmms_medialib_query (session, ordered, spec, err);
MEDIALIB_COMMIT ();
xmmsv_coll_unref (ordered);
xmmsv_unref (spec);
if (tmp == NULL) {
g_mutex_unlock (playlist->mutex);
return;
}
idlist = xmmsv_coll_idlist_get (plcoll);
xmmsv_list_clear (idlist);
for (pos = 0; xmmsv_list_get (tmp, pos, &val); pos++) {
xmms_medialib_entry_t id;
xmmsv_get_int (val, &id);
xmmsv_list_append (idlist, val);
if (id == currid) {
xmms_collection_set_int_attr (plcoll, "position", pos);
currpos = pos;
}
}
xmmsv_unref (tmp);
XMMS_PLAYLIST_CHANGED_MSG (XMMS_PLAYLIST_CHANGED_SORT, 0, plname);
XMMS_PLAYLIST_CURRPOS_MSG (currpos, plname);
g_mutex_unlock (playlist->mutex);
}
