/**
* rb_source_update_play_statistics:
* @source: a #RBSource
* @db: the #RhythmDB instance
* @entry: the #RhythmDBEntry to update
*
* Updates play count and play time statistics for a database entry.
* Sources containing entries that do not normally reach EOS should
* call this for an entry when it is no longer being played.
*/
void
rb_source_update_play_statistics (RBSource *source,
RhythmDB *db,
RhythmDBEntry *entry)
{
time_t now;
gulong current_count;
GValue value = { 0, };
g_value_init (&value, G_TYPE_ULONG);
current_count = rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_PLAY_COUNT);
g_value_set_ulong (&value, current_count + 1);
/* Increment current play count */
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_PLAY_COUNT, &value);
g_value_unset (&value);
/* Reset the last played time */
time (&now);
g_value_init (&value, G_TYPE_ULONG);
g_value_set_ulong (&value, now);
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_LAST_PLAYED, &value);
g_value_unset (&value);
rhythmdb_commit (db);
}
static RhythmDBEntry *
create_entry (RhythmDB *db,
const char *location, const char *name, const char *album,
const char *artist, const char *genre)
{
RhythmDBEntry *entry;
GValue val = {0, };
entry = rhythmdb_entry_new (db, RHYTHMDB_ENTRY_TYPE_IGNORE, location);
g_assert (entry);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, genre);
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_GENRE, &val);
g_value_unset (&val);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, artist);
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_ARTIST, &val);
g_value_unset (&val);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, album);
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_ALBUM, &val);
g_value_unset (&val);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, name);
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_TITLE, &val);
g_value_unset (&val);
return entry;
}
static void
entry_set_string_prop (RhythmDB *db,
RhythmDBEntry *entry,
RhythmDBPropType propid,
gboolean default_to_empty,
const char *str)
{
GValue value = {0,};
if (!str) {
if (default_to_empty) {
str = "";
} else {
str = _("Unknown");
}
}
if (!g_utf8_validate (str, -1, NULL)) {
rb_debug ("Got invalid UTF-8 tag data");
str = _("<Invalid unicode>");
}
g_value_init (&value, G_TYPE_STRING);
g_value_set_string (&value, str);
rhythmdb_entry_set (RHYTHMDB (db), entry, propid, &value);
g_value_unset (&value);
}
static gboolean
add_entries (RBImportDialog *dialog)
{
int i;
GValue new_type = {0,};
g_value_init (&new_type, G_TYPE_OBJECT);
g_value_set_object (&new_type, RHYTHMDB_ENTRY_TYPE_SONG);
for (i = 0; i < 1000; i++) {
RhythmDBEntry *entry;
entry = dialog->priv->add_entry_list->data;
dialog->priv->add_entry_list = g_list_delete_link (dialog->priv->add_entry_list, dialog->priv->add_entry_list);
rhythmdb_entry_set (dialog->priv->db, entry, RHYTHMDB_PROP_TYPE, &new_type);
rhythmdb_entry_unref (entry);
if (dialog->priv->add_entry_list == NULL)
break;
}
rhythmdb_commit (dialog->priv->db);
if (dialog->priv->add_entry_list == NULL) {
dialog->priv->add_entries_id = 0;
dialog->priv->added_entries_id = g_idle_add ((GSourceFunc) add_entries_done, dialog);
return FALSE;
} else {
return TRUE;
}
}
END_TEST
START_TEST (test_rhythmdb_mirroring)
{
GValue val = {0,};
RhythmDBEntry *entry;
const char *str;
entry = rhythmdb_entry_new (db, RHYTHMDB_ENTRY_TYPE_IGNORE, "file:///foo.mp3");
fail_unless (entry != NULL, "failed to create entry");
/* check the last-played date is mirrored */
g_value_init (&val, G_TYPE_ULONG);
g_value_set_ulong (&val, 1354285);
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_LAST_PLAYED, &val);
g_value_unset (&val);
rhythmdb_commit (db);
str = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LAST_PLAYED_STR);
fail_unless (str && (strlen (str) > 0), "date not converted to string");
/* check folded and sort-key varients */
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, "FOO");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_TITLE, &val);
g_value_unset (&val);
rhythmdb_commit (db);
str = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_TITLE_SORT_KEY);
fail_unless (str && (strlen (str) > 0), "sort-key not generated");
str = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_TITLE_FOLDED);
fail_unless (str && (strcmp (str, "foo") == 0), "folded variant not generated");
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, "BAR");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_TITLE, &val);
g_value_unset (&val);
rhythmdb_commit (db);
str = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_TITLE_SORT_KEY);
fail_unless (str && (strlen (str) > 0), "sort-key not generated");
str = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_TITLE_FOLDED);
fail_unless (str && (strcmp (str, "bar") == 0), "folded variant not generated");
}
END_TEST
START_TEST (test_rhythmdb_modify_after_delete)
{
RhythmDBEntry *entry;
GValue val = {0,};
entry = rhythmdb_entry_new (db, RHYTHMDB_ENTRY_TYPE_IGNORE, "file:///whee.ogg");
fail_unless (entry != NULL, "failed to create entry");
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, "Anything");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_GENRE, &val);
g_value_unset (&val);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, "Nothing");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_ARTIST, &val);
g_value_unset (&val);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, "Something");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_ALBUM, &val);
g_value_unset (&val);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, "Thing");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_TITLE, &val);
g_value_unset (&val);
rhythmdb_commit (db);
rhythmdb_entry_ref (entry);
rhythmdb_entry_delete (db, entry);
rhythmdb_commit (db);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, "Something Else");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_ALBUM, &val);
g_value_unset (&val);
rhythmdb_commit (db);
rhythmdb_entry_unref (entry);
}
void
set_entry_hidden (RhythmDB *db, RhythmDBEntry *entry, gboolean hidden)
{
GValue v = {0,};
g_value_init (&v, G_TYPE_BOOLEAN);
g_value_set_boolean (&v, hidden);
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_HIDDEN, &v);
g_value_unset (&v);
}
void
set_entry_ulong (RhythmDB *db, RhythmDBEntry *entry, RhythmDBPropType prop, gulong value)
{
GValue v = {0,};
g_value_init (&v, G_TYPE_ULONG);
g_value_set_ulong (&v, value);
rhythmdb_entry_set (db, entry, prop, &v);
g_value_unset (&v);
}
void
set_entry_string (RhythmDB *db, RhythmDBEntry *entry, RhythmDBPropType prop, const char *value)
{
GValue v = {0,};
g_value_init (&v, G_TYPE_STRING);
g_value_set_string (&v, value);
rhythmdb_entry_set (db, entry, prop, &v);
g_value_unset (&v);
}
static void
set_string_prop_from_key (RhythmDB *db, RhythmDBEntry *entry, RhythmDBPropType prop, GrlData *data, GrlKeyID key)
{
GValue v = {0,};
if (grl_data_has_key (data, key) == FALSE)
return;
g_value_init (&v, G_TYPE_STRING);
g_value_set_string (&v, grl_data_get_string (data, key));
rhythmdb_entry_set (db, entry, prop, &v);
g_value_unset (&v);
}
static void
entry_set_string_prop (RhythmDB *db,
RhythmDBEntry *entry,
RhythmDBPropType propid,
const char *str)
{
GValue value = {0,};
if (!str)
str = _("Unknown");
g_value_init (&value, G_TYPE_STRING);
g_value_set_static_string (&value, str);
rhythmdb_entry_set (RHYTHMDB (db), entry, propid, &value);
g_value_unset (&value);
}
static void
update_tracks (RBAudioCdSource *source, RhythmDBPropType property, GValue *value)
{
RBAudioCdSourcePrivate *priv = AUDIOCD_SOURCE_GET_PRIVATE (source);
RhythmDB *db;
GList *i;
db = get_db_for_source (source);
for (i = priv->tracks; i != NULL; i = i->next) {
rhythmdb_entry_set (db, i->data, property, value);
}
rhythmdb_commit (db);
g_object_unref (db);
}
static void
entry_set_string_prop (RhythmDB *db,
RhythmDBEntry *entry,
RhythmDBPropType propid,
const char *str)
{
GValue value = {0,};
if (str == NULL || (g_utf8_validate (str, -1, NULL) == FALSE)) {
str = _("Unknown");
}
g_value_init (&value, G_TYPE_STRING);
g_value_set_static_string (&value, str);
rhythmdb_entry_set (RHYTHMDB (db), entry, propid, &value);
g_value_unset (&value);
}
static RhythmDBEntry *
create_entry_for_media (RhythmDB *db, RhythmDBEntryType *entry_type, GrlData *data, GrlData *container)
{
RhythmDBEntry *entry;
RBGriloEntryData *entry_data;
entry = rhythmdb_entry_lookup_by_location (db, grl_media_get_url (GRL_MEDIA (data)));
if (entry != NULL) {
return entry;
}
rb_debug ("creating entry for %s / %s", grl_media_get_url (GRL_MEDIA (data)), grl_media_get_id (GRL_MEDIA (data)));
entry = rhythmdb_entry_new (db, entry_type, grl_media_get_url (GRL_MEDIA (data))); /* just use the url? */
if (entry == NULL) {
/* crap. */
return NULL;
}
set_string_prop_from_key (db, entry, RHYTHMDB_PROP_TITLE, data, GRL_METADATA_KEY_TITLE);
set_string_prop_from_key (db, entry, RHYTHMDB_PROP_ALBUM, data, GRL_METADATA_KEY_ALBUM);
set_string_prop_from_key (db, entry, RHYTHMDB_PROP_ARTIST, data, GRL_METADATA_KEY_ARTIST);
set_string_prop_from_key (db, entry, RHYTHMDB_PROP_GENRE, data, GRL_METADATA_KEY_GENRE);
set_string_prop_from_key (db, entry, RHYTHMDB_PROP_TITLE, data, GRL_METADATA_KEY_TITLE);
if (grl_data_has_key (data, GRL_METADATA_KEY_PUBLICATION_DATE)) {
/* something - grilo has this as a string? */
}
if (grl_data_has_key (data, GRL_METADATA_KEY_BITRATE)) {
GValue v = {0,};
g_value_init (&v, G_TYPE_ULONG);
g_value_set_ulong (&v, grl_data_get_int (data, GRL_METADATA_KEY_BITRATE));
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_BITRATE, &v);
g_value_unset (&v);
}
if (grl_data_has_key (data, GRL_METADATA_KEY_DURATION)) {
/* this is probably in seconds */
GValue v = {0,};
g_value_init (&v, G_TYPE_ULONG);
g_value_set_ulong (&v, grl_data_get_int (data, GRL_METADATA_KEY_DURATION));
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_DURATION, &v);
g_value_unset (&v);
}
if (grl_data_has_key (data, GRL_METADATA_KEY_MIME)) {
const char *media_type;
media_type = rb_gst_mime_type_to_media_type (grl_data_get_string (data, GRL_METADATA_KEY_MIME));
if (media_type) {
GValue v = {0,};
g_value_init (&v, G_TYPE_STRING);
g_value_set_string (&v, media_type);
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_MEDIA_TYPE, &v);
g_value_unset (&v);
}
}
if (grl_data_has_key (data, GRL_METADATA_KEY_TRACK_NUMBER)) {
GValue v = {0,};
g_value_init (&v, G_TYPE_ULONG);
g_value_set_ulong (&v, grl_data_get_int (data, GRL_METADATA_KEY_TRACK_NUMBER));
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_TRACK_NUMBER, &v);
g_value_unset (&v);
}
/* rating and play count? */
entry_data = RHYTHMDB_ENTRY_GET_TYPE_DATA (entry, RBGriloEntryData);
entry_data->grilo_data = g_object_ref (data);
if (container != NULL) {
entry_data->grilo_container = g_object_ref (container);
}
/* might want to consider batching this */
rhythmdb_commit (db);
return entry;
}
static RhythmDBEntry *
add_mtp_track_to_db (RBMtpSource *source,
RhythmDB *db,
LIBMTP_track_t *track)
{
RhythmDBEntry *entry = NULL;
RhythmDBEntryType *entry_type;
RBMtpSourcePrivate *priv = MTP_SOURCE_GET_PRIVATE (source);
char *name = NULL;
/* ignore everything except audio (allow audio/video types too, since they're probably pretty common) */
if (!(LIBMTP_FILETYPE_IS_AUDIO (track->filetype) || LIBMTP_FILETYPE_IS_AUDIOVIDEO (track->filetype))) {
rb_debug ("ignoring non-audio item %d (filetype %s)",
track->item_id,
LIBMTP_Get_Filetype_Description (track->filetype));
return NULL;
}
/* Set URI */
g_object_get (G_OBJECT (source), "entry-type", &entry_type, NULL);
name = g_strdup_printf ("xrbmtp://%i/%s", track->item_id, track->filename);
entry = rhythmdb_entry_new (RHYTHMDB (db), entry_type, name);
g_free (name);
g_object_unref (entry_type);
if (entry == NULL) {
rb_debug ("cannot create entry %i", track->item_id);
g_object_unref (G_OBJECT (db));
return NULL;
}
/* Set track number */
if (track->tracknumber != 0) {
GValue value = {0, };
g_value_init (&value, G_TYPE_ULONG);
g_value_set_ulong (&value, track->tracknumber);
rhythmdb_entry_set (RHYTHMDB (db), entry,
RHYTHMDB_PROP_TRACK_NUMBER,
&value);
g_value_unset (&value);
}
/* Set length */
if (track->duration != 0) {
GValue value = {0, };
g_value_init (&value, G_TYPE_ULONG);
g_value_set_ulong (&value, track->duration/1000);
rhythmdb_entry_set (RHYTHMDB (db), entry,
RHYTHMDB_PROP_DURATION,
&value);
g_value_unset (&value);
}
/* Set file size */
if (track->filesize != 0) {
GValue value = {0, };
g_value_init (&value, G_TYPE_UINT64);
g_value_set_uint64 (&value, track->filesize);
rhythmdb_entry_set (RHYTHMDB (db), entry,
RHYTHMDB_PROP_FILE_SIZE,
&value);
g_value_unset (&value);
}
/* Set playcount */
if (track->usecount != 0) {
GValue value = {0, };
g_value_init (&value, G_TYPE_ULONG);
g_value_set_ulong (&value, track->usecount);
rhythmdb_entry_set (RHYTHMDB (db), entry,
RHYTHMDB_PROP_PLAY_COUNT,
&value);
g_value_unset (&value);
}
/* Set rating */
if (track->rating != 0) {
GValue value = {0, };
g_value_init (&value, G_TYPE_DOUBLE);
g_value_set_double (&value, track->rating/20);
rhythmdb_entry_set (RHYTHMDB (db), entry,
RHYTHMDB_PROP_RATING,
&value);
g_value_unset (&value);
}
/* Set release date */
if (track->date != NULL && track->date[0] != '\0') {
GTimeVal tv;
if (g_time_val_from_iso8601 (track->date, &tv)) {
GDate d;
GValue value = {0, };
g_value_init (&value, G_TYPE_ULONG);
g_date_set_time_val (&d, &tv);
g_value_set_ulong (&value, g_date_get_julian (&d));
rhythmdb_entry_set (RHYTHMDB (db), entry, RHYTHMDB_PROP_DATE, &value);
g_value_unset (&value);
}
}
/* Set title */
entry_set_string_prop (RHYTHMDB (db), entry, RHYTHMDB_PROP_TITLE, track->title);
/* Set album, artist and genre from MTP */
entry_set_string_prop (RHYTHMDB (db), entry, RHYTHMDB_PROP_ARTIST, track->artist);
entry_set_string_prop (RHYTHMDB (db), entry, RHYTHMDB_PROP_ALBUM, track->album);
entry_set_string_prop (RHYTHMDB (db), entry, RHYTHMDB_PROP_GENRE, track->genre);
g_hash_table_insert (priv->entry_map, entry, track);
rhythmdb_commit (RHYTHMDB (db));
return entry;
}
static RhythmDBEntry *
rb_audiocd_create_track_entry (RBAudioCdSource *source,
RhythmDB *db,
guint track_number)
{
RhythmDBEntry *entry;
RBAudioCdSourcePrivate *priv = AUDIOCD_SOURCE_GET_PRIVATE (source);
char *audio_path;
guint64 duration;
GValue value = {0, };
gchar *str;
RhythmDBEntryType entry_type;
RBAudioCDEntryData *extra_data;
audio_path = g_strdup_printf ("cdda://%d#%s", track_number, priv->device_path);
g_object_get (G_OBJECT (source), "entry-type", &entry_type, NULL);
rb_debug ("Audio CD - create entry for track %d from %s", track_number, audio_path);
entry = rhythmdb_entry_new (db, entry_type, audio_path);
g_boxed_free (RHYTHMDB_TYPE_ENTRY_TYPE, entry_type);
if (entry == NULL) {
g_free (audio_path);
return NULL;
}
/* generate track # */
g_value_init (&value, G_TYPE_ULONG);
g_value_set_ulong (&value, track_number);
rhythmdb_entry_set (db, entry,
RHYTHMDB_PROP_TRACK_NUMBER,
&value);
g_value_unset (&value);
/* generate track name */
g_value_init (&value, G_TYPE_STRING);
str = g_strdup_printf (_("Track %u"), track_number);
g_value_take_string (&value, str);
rhythmdb_entry_set (db, entry,
RHYTHMDB_PROP_TITLE,
&value);
g_value_unset (&value);
/* determine the duration
* FIXME: http://bugzilla.gnome.org/show_bug.cgi?id=551011 */
if (gst_tag_list_get_uint64 (GST_CDDA_BASE_SRC(priv->cdda)->tracks[track_number - 1].tags, GST_TAG_DURATION, &duration)) {
g_value_init (&value, G_TYPE_ULONG);
g_value_set_ulong (&value, (gulong)(duration / GST_SECOND));
rhythmdb_entry_set (db, entry,
RHYTHMDB_PROP_DURATION,
&value);
g_value_unset (&value);
} else {
g_warning ("Failed to query cd track duration");
}
entry_set_string_prop (db, entry, RHYTHMDB_PROP_ARTIST, FALSE, NULL);
entry_set_string_prop (db, entry, RHYTHMDB_PROP_ALBUM, FALSE, NULL);
entry_set_string_prop (db, entry, RHYTHMDB_PROP_GENRE, FALSE, NULL);
entry_set_string_prop (db, entry, RHYTHMDB_PROP_MIMETYPE, TRUE, "audio/x-raw-int");
extra_data = RHYTHMDB_ENTRY_GET_TYPE_DATA (entry, RBAudioCDEntryData);
extra_data->extract = TRUE;
rhythmdb_commit (db);
g_free (audio_path);
return entry;
}
static void
metadata_cb (SjMetadataGetter *metadata,
GList *albums,
GError *error,
RBAudioCdSource *source)
{
RBAudioCdSourcePrivate *priv = AUDIOCD_SOURCE_GET_PRIVATE (source);
GList *cd_track = priv->tracks;
RhythmDB *db;
GValue true_value = {0,};
AlbumDetails *album;
g_assert (metadata == priv->metadata);
if (error != NULL) {
rb_debug ("Failed to load cd metadata: %s", error->message);
/* TODO display error to user? */
g_object_unref (metadata);
priv->metadata = NULL;
return;
}
if (albums == NULL) {
rb_debug ("Musicbrainz didn't return any CD metadata, but didn't give an error");
g_object_unref (metadata);
priv->metadata = NULL;
return;
}
if (cd_track == NULL) {
/* empty cd? */
rb_debug ("no tracks on the CD?");
g_object_unref (metadata);
priv->metadata = NULL;
return;
}
db = get_db_for_source (source);
g_value_init (&true_value, G_TYPE_BOOLEAN);
g_value_set_boolean (&true_value, TRUE);
g_free (priv->submit_url);
priv->submit_url = NULL;
/* if we have multiple results, ask the user to pick one */
if (g_list_length (albums) > 1) {
album = multiple_album_dialog (albums, source);
if (album == NULL)
album = (AlbumDetails *)albums->data;
} else
album = (AlbumDetails *)albums->data;
#if GTK_CHECK_VERSION(2,17,6)
if (album->metadata_source != SOURCE_MUSICBRAINZ) {
priv->submit_url = sj_metadata_getter_get_submit_url (metadata);
if (priv->submit_url != NULL)
gtk_widget_show (priv->info_bar);
}
#endif
if (album->metadata_source == SOURCE_FALLBACK) {
rb_debug ("ignoring CD metadata from fallback source");
g_object_unref (metadata);
priv->metadata = NULL;
g_object_unref (db);
return;
}
if (album->artist != NULL) {
gtk_entry_set_text (GTK_ENTRY (priv->artist_entry), album->artist);
}
if (album->artist_sortname != NULL) {
gtk_entry_set_text (GTK_ENTRY (priv->artist_sort_entry), album->artist_sortname);
}
if (album->title != NULL) {
gtk_entry_set_text (GTK_ENTRY (priv->album_entry), album->title);
}
if (album->release_date != NULL) {
char *year;
year = g_strdup_printf ("%d", g_date_get_year (album->release_date));
gtk_entry_set_text (GTK_ENTRY (priv->year_entry), year);
g_free (year);
}
if (album->disc_number != 0) {
char *num;
num = g_strdup_printf ("%d", album->disc_number);
gtk_entry_set_text (GTK_ENTRY (priv->disc_number_entry), num);
g_free (num);
}
if (album->genre != NULL) {
gtk_entry_set_text (GTK_ENTRY (priv->genre_entry), album->genre);
}
g_object_set (G_OBJECT (source), "name", album->title, NULL);
rb_debug ("musicbrainz_albumid: %s", album->album_id);
rb_debug ("musicbrainz_albumartistid: %s", album->artist_id);
rb_debug ("album artist: %s", album->artist);
rb_debug ("disc number: %d", album->disc_number);
rb_debug ("genre: %s", album->genre);
while (album->tracks && cd_track) {
TrackDetails *track = (TrackDetails*)album->tracks->data;
RhythmDBEntry *entry = cd_track->data;
GValue value = {0, };
rb_debug ("storing metadata for %s - %s - %s", track->artist, album->title, track->title);
rb_debug ("musicbrainz_trackid: %s", track->track_id);
rb_debug ("musicbrainz_artistid: %s", track->artist_id);
rb_debug ("artist sortname: %s", track->artist_sortname);
/* record track info in entry*/
entry_set_string_prop (db, entry, RHYTHMDB_PROP_TITLE, FALSE, track->title);
entry_set_string_prop (db, entry, RHYTHMDB_PROP_ARTIST, FALSE, track->artist);
entry_set_string_prop (db, entry, RHYTHMDB_PROP_ALBUM, FALSE, album->title);
entry_set_string_prop (db, entry, RHYTHMDB_PROP_GENRE, FALSE, album->genre);
entry_set_string_prop (db, entry, RHYTHMDB_PROP_MUSICBRAINZ_TRACKID, TRUE, track->track_id);
entry_set_string_prop (db, entry, RHYTHMDB_PROP_MUSICBRAINZ_ARTISTID, TRUE, track->artist_id);
entry_set_string_prop (db, entry, RHYTHMDB_PROP_MUSICBRAINZ_ALBUMID, TRUE, album->album_id);
entry_set_string_prop (db, entry, RHYTHMDB_PROP_MUSICBRAINZ_ALBUMARTISTID, TRUE, album->artist_id);
entry_set_string_prop (db, entry, RHYTHMDB_PROP_ARTIST_SORTNAME, TRUE, track->artist_sortname);
g_value_init (&value, G_TYPE_ULONG);
g_value_set_ulong (&value, track->duration);
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_DURATION, &value);
g_value_unset (&value);
if (album->disc_number != 0) {
g_value_init (&value, G_TYPE_ULONG);
g_value_set_ulong (&value, album->disc_number);
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_DISC_NUMBER, &value);
g_value_unset (&value);
}
/*album->release_date (could potentially have multiple values)*/
/* in current sj-structures.h, however, it does not */
if (album->release_date) {
GType type = rhythmdb_get_property_type (db, RHYTHMDB_PROP_DATE);
g_value_init (&value, type);
g_value_set_ulong (&value, g_date_get_julian (album->release_date));
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_DATE, &value);
g_value_unset (&value);
}
rhythmdb_commit (db);
album->tracks = g_list_next (album->tracks);
cd_track = g_list_next (cd_track);
}
while (cd_track) {
/* Musicbrainz doesn't report data tracks on multisession CDs.
* These aren't interesting to us anyway, so they should be hidden.
*/
RhythmDBEntry *entry = cd_track->data;
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_HIDDEN, &true_value);
rhythmdb_commit (db);
cd_track = g_list_next (cd_track);
}
/* And free the albums list, as it belongs to us, not
* the metadata getter */
g_list_foreach (albums, (GFunc)album_details_free, NULL);
g_list_free (albums);
g_object_unref (metadata);
priv->metadata = NULL;
g_object_unref (db);
}
static void
info_available_cb (RBPlayer *backend,
const char *uri,
RBMetaDataField field,
GValue *value,
RBIRadioSource *source)
{
RhythmDBEntry *entry;
RhythmDBPropType entry_field = 0;
gboolean set_field = FALSE;
char *str = NULL;
/* sanity check */
if (!rb_player_opened (backend)) {
rb_debug ("Got info_available but not playing");
return;
}
GDK_THREADS_ENTER ();
entry = rb_shell_player_get_playing_entry (source->priv->player);
if (check_entry_type (source, entry) == FALSE)
goto out_unlock;
/* validate the value */
switch (field) {
case RB_METADATA_FIELD_TITLE:
case RB_METADATA_FIELD_ARTIST:
case RB_METADATA_FIELD_GENRE:
case RB_METADATA_FIELD_COMMENT:
str = g_value_dup_string (value);
if (!g_utf8_validate (str, -1, NULL)) {
g_warning ("Invalid UTF-8 from internet radio: %s", str);
g_free (str);
goto out_unlock;
}
break;
default:
break;
}
switch (field) {
/* streaming song information */
case RB_METADATA_FIELD_TITLE:
{
rb_streaming_source_set_streaming_title (RB_STREAMING_SOURCE (source), str);
break;
}
case RB_METADATA_FIELD_ARTIST:
{
rb_streaming_source_set_streaming_artist (RB_STREAMING_SOURCE (source), str);
break;
}
/* station information */
case RB_METADATA_FIELD_GENRE:
{
const char *existing;
/* check if the db entry already has a genre; if so, don't change it */
existing = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_GENRE);
if ((existing == NULL) ||
(strcmp (existing, "") == 0) ||
(strcmp (existing, _("Unknown")) == 0)) {
entry_field = RHYTHMDB_PROP_GENRE;
rb_debug ("setting genre of iradio station to %s", str);
set_field = TRUE;
} else {
rb_debug ("iradio station already has genre: %s; ignoring %s", existing, str);
}
break;
}
case RB_METADATA_FIELD_COMMENT:
{
const char *existing;
const char *location;
/* check if the db entry already has a title; if so, don't change it.
* consider title==URI to be the same as no title, since that's what
* happens for stations imported by DnD or commandline args.
* if the station title really is the same as the URI, then surely
* the station title in the stream metadata will say that too..
*/
existing = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_TITLE);
location = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION);
if ((existing == NULL) ||
(strcmp (existing, "") == 0) ||
(strcmp (existing, location) == 0)) {
entry_field = RHYTHMDB_PROP_TITLE;
rb_debug ("setting title of iradio station to %s", str);
set_field = TRUE;
} else {
rb_debug ("iradio station already has title: %s; ignoring %s", existing, str);
}
break;
}
case RB_METADATA_FIELD_BITRATE:
if (!rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_BITRATE)) {
gulong bitrate;
/* GStreamer sends us bitrate in bps, but we need it in kbps*/
bitrate = g_value_get_ulong (value);
g_value_set_ulong (value, bitrate/1000);
rb_debug ("setting bitrate of iradio station to %lu",
g_value_get_ulong (value));
entry_field = RHYTHMDB_PROP_BITRATE;
set_field = TRUE;
}
break;
default:
break;
}
if (set_field && entry_field != 0) {
rhythmdb_entry_set (source->priv->db, entry, entry_field, value);
rhythmdb_commit (source->priv->db);
}
g_free (str);
out_unlock:
GDK_THREADS_LEAVE ();
}
END_TEST
/* this tests that chained query models, where the base shows hidden entries
* forwards visibility changes correctly. This is basically what static playlists do */
START_TEST (test_hidden_chain_filter)
{
RhythmDBQueryModel *base_model;
RhythmDBQueryModel *filter_model;
RhythmDBQuery *query;
RhythmDBEntry *entry;
GtkTreeIter iter;
GValue val = {0,};
start_test_case ();
/* setup */
base_model = rhythmdb_query_model_new_empty (db);
g_object_set (base_model, "show-hidden", TRUE, NULL);
filter_model = rhythmdb_query_model_new_empty (db);
g_object_set (filter_model, "base-model", base_model, NULL);
query = g_ptr_array_new ();
g_object_set (filter_model, "query", query, NULL);
rhythmdb_query_free (query);
entry = rhythmdb_entry_new (db, RHYTHMDB_ENTRY_TYPE_IGNORE, "file:///whee.ogg");
rhythmdb_commit (db);
g_value_init (&val, G_TYPE_BOOLEAN);
/* add entry to base, should be in both */
rhythmdb_query_model_add_entry (base_model, entry, -1);
fail_unless (rhythmdb_query_model_entry_to_iter (base_model, entry, &iter));
fail_unless (rhythmdb_query_model_entry_to_iter (filter_model, entry, &iter));
end_step ();
/* hide entry, should be in base and not filtered */
g_value_set_boolean (&val, TRUE);
set_waiting_signal (G_OBJECT (db), "entry-changed");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_HIDDEN, &val);
rhythmdb_commit (db);
wait_for_signal ();
fail_unless (rhythmdb_query_model_entry_to_iter (base_model, entry, &iter));
fail_if (rhythmdb_query_model_entry_to_iter (filter_model, entry, &iter));
end_step ();
/* show entry again, should be in both */
g_value_set_boolean (&val, FALSE);
set_waiting_signal (G_OBJECT (db), "entry-changed");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_HIDDEN, &val);
rhythmdb_commit (db);
wait_for_signal ();
fail_unless (rhythmdb_query_model_entry_to_iter (base_model, entry, &iter));
fail_unless (rhythmdb_query_model_entry_to_iter (filter_model, entry, &iter));
end_step ();
/* tidy up */
rhythmdb_entry_delete (db, entry);
g_object_unref (base_model);
g_object_unref (filter_model);
g_value_unset (&val);
end_test_case ();
}
void
rb_iradio_source_add_station (RBIRadioSource *source,
const char *uri,
const char *title,
const char *genre)
{
RhythmDBEntry *entry;
GValue val = { 0, };
char *real_uri = NULL;
char *fixed_title;
char *fixed_genre = NULL;
RhythmDBEntryType *entry_type;
real_uri = guess_uri_scheme (uri);
if (real_uri)
uri = real_uri;
entry = rhythmdb_entry_lookup_by_location (source->priv->db, uri);
if (entry) {
rb_debug ("uri %s already in db", uri);
g_free (real_uri);
return;
}
g_object_get (source, "entry-type", &entry_type, NULL);
entry = rhythmdb_entry_new (source->priv->db, entry_type, uri);
g_object_unref (entry_type);
if (entry == NULL) {
g_free (real_uri);
return;
}
g_value_init (&val, G_TYPE_STRING);
if (title) {
fixed_title = rb_make_valid_utf8 (title, '?');
} else {
fixed_title = g_uri_unescape_string (uri, NULL);
}
g_value_take_string (&val, fixed_title);
rhythmdb_entry_set (source->priv->db, entry, RHYTHMDB_PROP_TITLE, &val);
g_value_reset (&val);
if ((!genre) || (strcmp (genre, "") == 0)) {
genre = _("Unknown");
} else {
fixed_genre = rb_make_valid_utf8 (genre, '?');
genre = fixed_genre;
}
g_value_set_string (&val, genre);
rhythmdb_entry_set (source->priv->db, entry, RHYTHMDB_PROP_GENRE, &val);
g_value_unset (&val);
g_free (fixed_genre);
g_value_init (&val, G_TYPE_DOUBLE);
g_value_set_double (&val, 0.0);
rhythmdb_entry_set (source->priv->db, entry, RHYTHMDB_PROP_RATING, &val);
g_value_unset (&val);
rhythmdb_commit (source->priv->db);
g_free (real_uri);
}
