/**
* Add a song to the browsing list.
*/
static void
daap_add_song_to_list (xmms_xform_t *xform, cc_item_record_t *song)
{
gchar *songurl;
songurl = g_strdup_printf ("%u.%s", song->dbid, song->song_format);
xmms_xform_browse_add_entry (xform, songurl, 0);
g_free (songurl);
if (song->iname) {
xmms_xform_browse_add_entry_property_str (xform, "title",
song->iname);
}
if (song->song_data_artist) {
xmms_xform_browse_add_entry_property_str (xform, "artist",
song->song_data_artist);
}
if (song->song_data_album) {
xmms_xform_browse_add_entry_property_str (xform, "album",
song->song_data_album);
}
xmms_xform_browse_add_entry_property_int (xform, "tracknr",
song->song_track_no);
}
static gboolean
xmms_daap_browse (xmms_xform_t *xform, const gchar *url, xmms_error_t *error)
{
gboolean ret = FALSE;
if (g_ascii_strcasecmp (url, "daap://") == 0) {
GSList *sl = daap_mdns_get_server_list ();
for (; sl; sl = g_slist_next (sl)) {
daap_mdns_server_t *mdns_serv;
gchar *str;
mdns_serv = sl->data;
str = g_strdup_printf ("%s:%d", mdns_serv->address,
mdns_serv->port);
xmms_xform_browse_add_entry (xform, str, XMMS_XFORM_BROWSE_FLAG_DIR);
g_free (str);
xmms_xform_browse_add_entry_property_str (xform, "servername",
mdns_serv->server_name);
xmms_xform_browse_add_entry_property_str (xform, "ip",
mdns_serv->address);
xmms_xform_browse_add_entry_property_str (xform, "name",
mdns_serv->mdns_hostname);
xmms_xform_browse_add_entry_property_int (xform, "port",
mdns_serv->port);
/* TODO implement the machinery to allow for this */
// val = xmmsv_new_int (mdns_serv->need_auth);
// xmms_xform_browse_add_entry_property (xform, "passworded", val);
// val = xmmsv_new_int (mdns_serv->version);
// xmms_xform_browse_add_entry_property (xform, "version", val);
}
ret = TRUE;
g_slist_free (sl);
} else {
gchar *host;
guint port;
if (get_data_from_url (url, &host, &port, NULL, error)) {
ret = daap_get_urls_from_server (xform, host, port, error);
g_free (host);
}
}
return ret;
}
static void
add_track (xmms_xform_t *xform, cue_track *tr)
{
GList *n;
gchar *file;
tr->tracks = g_list_reverse (tr->tracks);
n = tr->tracks;
file = xmms_build_playlist_url (xmms_xform_get_url (xform), tr->file);
while (n) {
gchar arg0[32], arg1[32];
gchar *arg[2] = { arg0, arg1 };
gint numargs = 1;
cue_track *t = n->data;
if (!t) {
continue;
}
g_snprintf (arg0, sizeof (arg0), "startms=%d",
t->index2 ? t->index2 : t->index);
if (n->next && n->next->data) {
cue_track *t2 = n->next->data;
g_snprintf (arg1, sizeof (arg1), "stopms=%d", t2->index);
numargs = 2;
}
xmms_xform_browse_add_symlink_args (xform, NULL, file, numargs, arg);
xmms_xform_browse_add_entry_property_int (xform, "intsort", t->index);
if (*t->title) {
xmms_xform_browse_add_entry_property_str (xform, "title", t->title);
}
if (*t->artist || *tr->artist) {
xmms_xform_browse_add_entry_property_str (xform, "artist",
(*t->artist)? t->artist : tr->artist);
}
if (*tr->album) {
xmms_xform_browse_add_entry_property_str (xform, "album", tr->album);
}
g_free (t);
n = g_list_delete_link (n, n);
}
g_free (file);
tr->file[0] = '\0';
tr->tracks = NULL;
}
void
xmms_xform_browse_add_symlink_args (xmms_xform_t *xform, const gchar *basename,
const gchar *url, gint nargs, gchar **args)
{
GString *s;
gchar *eurl;
gchar bname[32];
gint i;
if (!basename) {
g_snprintf (bname, sizeof (bname), "%d", xform->browse_index++);
basename = bname;
}
xmms_xform_browse_add_entry (xform, basename, 0);
eurl = xmms_medialib_url_encode (url);
s = g_string_new (eurl);
for (i = 0; i < nargs; i++) {
g_string_append_c (s, i == 0 ? '?' : '&');
g_string_append (s, args[i]);
}
xmms_xform_browse_add_entry_property_str (xform, "realpath", s->str);
g_free (eurl);
g_string_free (s, TRUE);
}
static gboolean
xmms_m3u_browse (xmms_xform_t *xform,
const gchar *url,
xmms_error_t *error)
{
gchar line[XMMS_XFORM_MAX_LINE_SIZE];
gchar *tmp;
gchar *title = NULL;
const gchar *d;
g_return_val_if_fail (xform, FALSE);
xmms_error_reset (error);
if (!xmms_xform_read_line (xform, line, error)) {
XMMS_DBG ("Error reading m3u-file");
return FALSE;
}
d = xmms_xform_get_url (xform);
do {
if (line[0] == '#') {
if (!title) {
title = get_extinf (line);
}
} else {
tmp = xmms_build_playlist_url (d, line);
xmms_xform_browse_add_symlink (xform, NULL, tmp);
if (title) {
xmms_xform_browse_add_entry_property_str (xform,
"title",
title);
g_free (title);
title = NULL;
}
g_free (tmp);
}
} while (xmms_xform_read_line (xform, line, error));
g_free (title);
return TRUE;
}
void
xmms_xform_browse_add_entry (xmms_xform_t *xform, const gchar *filename,
guint32 flags)
{
const gchar *url;
gchar *efile, *eurl, *t;
gint l, isdir;
g_return_if_fail (filename);
t = strchr (filename, '/');
g_return_if_fail (!t); /* filenames can't contain '/', can they? */
url = xmms_xform_get_url (xform);
g_return_if_fail (url);
xform->browse_dict = xmmsv_new_dict ();
eurl = xmms_medialib_url_encode (url);
efile = xmms_medialib_url_encode (filename);
/* can't use g_build_filename as we need to preserve
slashes stuff like file:/// */
l = strlen (url);
if (l && url[l - 1] == '/') {
t = g_strdup_printf ("%s%s", eurl, efile);
} else {
t = g_strdup_printf ("%s/%s", eurl, efile);
}
isdir = !!(flags & XMMS_XFORM_BROWSE_FLAG_DIR);
xmms_xform_browse_add_entry_property_str (xform, "path", t);
xmms_xform_browse_add_entry_property_int (xform, "isdir", isdir);
if (xform->browse_list == NULL) {
xform->browse_list = xmmsv_new_list ();
}
xmmsv_list_append (xform->browse_list, xform->browse_dict);
xmmsv_unref (xform->browse_dict);
g_free (t);
g_free (efile);
g_free (eurl);
}
static void
xmms_pls_add_entry (xmms_xform_t *xform,
const gchar *plspath,
xmms_pls_entry_t *e)
{
if (e->file) {
gchar *path;
path = xmms_build_playlist_url (plspath, e->file);
xmms_xform_browse_add_symlink (xform, NULL, path);
if (e->title)
xmms_xform_browse_add_entry_property_str (xform, "title", e->title);
g_free (path);
g_free (e->file);
e->file = NULL;
}
if (e->title) {
g_free (e->title);
e->title = NULL;
}
}
static gboolean
xmms_xspf_browse_add_entries (xmms_xform_t *xform, xmlDocPtr doc,
xmms_error_t *error)
{
int i;
xmlXPathContextPtr xpath;
xmlXPathObjectPtr obj;
const xmlChar *playlist_image = NULL;
xpath = xmlXPathNewContext (doc);
xmlXPathRegisterNs (xpath,
BAD_CAST "xspf",
BAD_CAST "http://xspf.org/ns/0/");
if (!xmms_xspf_check_valid_xspf (doc, xpath, error)) {
xmlXPathFreeContext (xpath);
return FALSE;
}
obj = xmlXPathEvalExpression (BAD_CAST "/xspf:playlist[@version<=1]/xspf:image/text()/..",
xpath);
if (!obj) {
xmms_error_set (error, XMMS_ERROR_INVAL,
"unable to evaluate xpath expression");
xmlXPathFreeContext (xpath);
return FALSE;
}
if (xmlXPathNodeSetGetLength (obj->nodesetval) == 1) {
playlist_image = xmlXPathNodeSetItem (obj->nodesetval, 0)->children->content;
}
xmlXPathFreeObject (obj);
obj = xmlXPathEvalExpression (BAD_CAST "/xspf:playlist[@version<=1]/xspf:trackList/xspf:track/xspf:location/text()/../..",
xpath);
if (!obj) {
xmms_error_set (error, XMMS_ERROR_INVAL,
"unable to evaluate xpath expression");
xmlXPathFreeContext (xpath);
return FALSE;
}
for (i = 0; i < xmlXPathNodeSetGetLength (obj->nodesetval); i++) {
xmms_xspf_track_t *track;
GList *attr;
track = xmms_xspf_parse_track_node (xform,
xmlXPathNodeSetItem (obj->nodesetval, i),
error);
if (!track) {
continue;
}
xmms_xform_browse_add_symlink (xform, NULL, track->location);
if (playlist_image) {
xmms_xform_browse_add_entry_property_str (xform, "image", (char *)playlist_image);
}
for (attr = track->attrs; attr; attr = g_list_next (attr)) {
xmms_xform_browse_add_entry_property (xform,
((xmms_xspf_track_attr_t *)attr->data)->key,
((xmms_xspf_track_attr_t *)attr->data)->value);
}
g_list_free (track->attrs);
g_free (track);
}
xmlXPathFreeObject (obj);
xmlXPathFreeContext (xpath);
return TRUE;
}
