hythmbox-2.98/rhythmdb/rhythmdb.c

Location Tool Test ID Function Issue
rhythmdb.c:770:9 clang-analyzer Access to field 'message' results in a dereference of a null pointer (loaded from variable 'access_error')
rhythmdb.c:770:9 clang-analyzer Access to field 'message' results in a dereference of a null pointer (loaded from variable 'access_error')
rhythmdb.c:3705:2 clang-analyzer Access to field 'impl_entry_delete' results in a dereference of a null pointer (loaded from variable 'klass')
rhythmdb.c:3705:2 clang-analyzer Access to field 'impl_entry_delete' results in a dereference of a null pointer (loaded from variable 'klass')
   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
   2  *
   3  *  Copyright (C) 2003,2004 Colin Walters <walters@gnome.org>
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  The Rhythmbox authors hereby grant permission for non-GPL compatible
  11  *  GStreamer plugins to be used and distributed together with GStreamer
  12  *  and Rhythmbox. This permission is above and beyond the permissions granted
  13  *  by the GPL license by which Rhythmbox is covered. If you modify this code
  14  *  you may extend this exception to your version of the code, but you are not
  15  *  obligated to do so. If you do not wish to do so, delete this exception
  16  *  statement from your version.
  17  *
  18  *  This program is distributed in the hope that it will be useful,
  19  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  *  GNU General Public License for more details.
  22  *
  23  *  You should have received a copy of the GNU General Public License
  24  *  along with this program; if not, write to the Free Software
  25  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA.
  26  *
  27  */
  28 
  29 /**
  30  * SECTION:rhythmdb
  31  * @short_description: Rhythmbox database functions
  32  *
  33  * RhythmDB is an in-memory database containing #RhythmDBEntry items.  It
  34  * runs queries represented as #GPtrArray<!-- -->s containing query criteria,
  35  * feeding the results into #RhythmDBQueryResults implementations such as
  36  * #RhythmDBQueryModel.  From there, entries are grouped by particular property
  37  * values to form #RhythmDBPropertyModel<!-- -->s.
  38  *
  39  * #RhythmDBEntry contains a fixed set of properties, defined by #RhythmDBPropType,
  40  */
  41 
  42 #include "config.h"
  43 
  44 #define	G_IMPLEMENT_INLINES 1
  45 #define	__RHYTHMDB_C__
  46 #include "rhythmdb.h"
  47 #undef G_IMPLEMENT_INLINES
  48 
  49 #include <string.h>
  50 #include <libxml/tree.h>
  51 #include <glib.h>
  52 #include <glib-object.h>
  53 #include <glib/gi18n.h>
  54 #include <gio/gio.h>
  55 #include <gobject/gvaluecollector.h>
  56 #include <gdk/gdk.h>
  57 
  58 
  59 #include "rb-marshal.h"
  60 #include "rb-file-helpers.h"
  61 #include "rb-debug.h"
  62 #include "rb-util.h"
  63 #include "rb-cut-and-paste-code.h"
  64 #include "rhythmdb-private.h"
  65 #include "rhythmdb-property-model.h"
  66 #include "rb-dialog.h"
  67 #include "rb-string-value-map.h"
  68 #include "rb-async-queue-watch.h"
  69 #include "rb-podcast-entry-types.h"
  70 #include "rb-gst-media-types.h"
  71 
  72 #define PROP_ENTRY(p,t,n) { RHYTHMDB_PROP_ ## p, "RHYTHMDB_PROP_" #p "", t, n }
  73 
  74 typedef struct _RhythmDBPropertyDef {
  75 	RhythmDBPropType prop_id;
  76 	const char *prop_name;
  77 	GType prop_type;
  78 	const char *elt_name;
  79 } RhythmDBPropertyDef;
  80 
  81 static const RhythmDBPropertyDef rhythmdb_properties[] = {
  82 	PROP_ENTRY(TYPE, G_TYPE_OBJECT, "type"),
  83 	PROP_ENTRY(ENTRY_ID, G_TYPE_ULONG, "entry-id"),
  84 	PROP_ENTRY(TITLE, G_TYPE_STRING, "title"),
  85 	PROP_ENTRY(GENRE, G_TYPE_STRING, "genre"),
  86 	PROP_ENTRY(ARTIST, G_TYPE_STRING, "artist"),
  87 	PROP_ENTRY(ALBUM, G_TYPE_STRING, "album"),
  88 	PROP_ENTRY(TRACK_NUMBER, G_TYPE_ULONG, "track-number"),
  89 	PROP_ENTRY(DISC_NUMBER, G_TYPE_ULONG, "disc-number"),
  90 	PROP_ENTRY(DURATION, G_TYPE_ULONG, "duration"),
  91 	PROP_ENTRY(FILE_SIZE, G_TYPE_UINT64, "file-size"),
  92 	PROP_ENTRY(LOCATION, G_TYPE_STRING, "location"),
  93 	PROP_ENTRY(MOUNTPOINT, G_TYPE_STRING, "mountpoint"),
  94 	PROP_ENTRY(MTIME, G_TYPE_ULONG, "mtime"),
  95 	PROP_ENTRY(FIRST_SEEN, G_TYPE_ULONG, "first-seen"),
  96 	PROP_ENTRY(LAST_SEEN, G_TYPE_ULONG, "last-seen"),
  97 	PROP_ENTRY(RATING, G_TYPE_DOUBLE, "rating"),
  98 	PROP_ENTRY(PLAY_COUNT, G_TYPE_ULONG, "play-count"),
  99 	PROP_ENTRY(LAST_PLAYED, G_TYPE_ULONG, "last-played"),
 100 	PROP_ENTRY(BITRATE, G_TYPE_ULONG, "bitrate"),
 101 	PROP_ENTRY(DATE, G_TYPE_ULONG, "date"),
 102 	PROP_ENTRY(TRACK_GAIN, G_TYPE_DOUBLE, "replaygain-track-gain"),
 103 	PROP_ENTRY(TRACK_PEAK, G_TYPE_DOUBLE, "replaygain-track-peak"),
 104 	PROP_ENTRY(ALBUM_GAIN, G_TYPE_DOUBLE, "replaygain-album-gain"),
 105 	PROP_ENTRY(ALBUM_PEAK, G_TYPE_DOUBLE, "replaygain-album-peak"),
 106 	PROP_ENTRY(MEDIA_TYPE, G_TYPE_STRING, "media-type"),
 107 	PROP_ENTRY(TITLE_SORT_KEY, G_TYPE_STRING, "title-sort-key"),
 108 	PROP_ENTRY(GENRE_SORT_KEY, G_TYPE_STRING, "genre-sort-key"),
 109 	PROP_ENTRY(ARTIST_SORT_KEY, G_TYPE_STRING, "artist-sort-key"),
 110 	PROP_ENTRY(ALBUM_SORT_KEY, G_TYPE_STRING, "album-sort-key"),
 111 	PROP_ENTRY(TITLE_FOLDED, G_TYPE_STRING, "title-folded"),
 112 	PROP_ENTRY(GENRE_FOLDED, G_TYPE_STRING, "genre-folded"),
 113 	PROP_ENTRY(ARTIST_FOLDED, G_TYPE_STRING, "artist-folded"),
 114 	PROP_ENTRY(ALBUM_FOLDED, G_TYPE_STRING, "album-folded"),
 115 	PROP_ENTRY(LAST_PLAYED_STR, G_TYPE_STRING, "last-played-str"),
 116 	PROP_ENTRY(HIDDEN, G_TYPE_BOOLEAN, "hidden"),
 117 	PROP_ENTRY(PLAYBACK_ERROR, G_TYPE_STRING, "playback-error"),
 118 	PROP_ENTRY(FIRST_SEEN_STR, G_TYPE_STRING, "first-seen-str"),
 119 	PROP_ENTRY(LAST_SEEN_STR, G_TYPE_STRING, "last-seen-str"),
 120 
 121 	PROP_ENTRY(SEARCH_MATCH, G_TYPE_STRING, "search-match"),
 122 	PROP_ENTRY(YEAR, G_TYPE_ULONG, "year"),
 123 	PROP_ENTRY(KEYWORD, G_TYPE_STRING, "keyword"),
 124 
 125 	PROP_ENTRY(STATUS, G_TYPE_ULONG, "status"),
 126 	PROP_ENTRY(DESCRIPTION, G_TYPE_STRING, "description"),
 127 	PROP_ENTRY(SUBTITLE, G_TYPE_STRING, "subtitle"),
 128 	PROP_ENTRY(SUMMARY, G_TYPE_STRING, "summary"),
 129 	PROP_ENTRY(LANG, G_TYPE_STRING, "lang"),
 130 	PROP_ENTRY(COPYRIGHT, G_TYPE_STRING, "copyright"),
 131 	PROP_ENTRY(IMAGE, G_TYPE_STRING, "image"),
 132 	PROP_ENTRY(POST_TIME, G_TYPE_ULONG, "post-time"),
 133 
 134 	PROP_ENTRY(MUSICBRAINZ_TRACKID, G_TYPE_STRING, "mb-trackid"),
 135 	PROP_ENTRY(MUSICBRAINZ_ARTISTID, G_TYPE_STRING, "mb-artistid"),
 136 	PROP_ENTRY(MUSICBRAINZ_ALBUMID, G_TYPE_STRING, "mb-albumid"),
 137 	PROP_ENTRY(MUSICBRAINZ_ALBUMARTISTID, G_TYPE_STRING, "mb-albumartistid"),
 138 	PROP_ENTRY(ARTIST_SORTNAME, G_TYPE_STRING, "mb-artistsortname"),
 139 	PROP_ENTRY(ALBUM_SORTNAME, G_TYPE_STRING, "album-sortname"),
 140 
 141 	PROP_ENTRY(ARTIST_SORTNAME_SORT_KEY, G_TYPE_STRING, "artist-sortname-sort-key"),
 142 	PROP_ENTRY(ARTIST_SORTNAME_FOLDED, G_TYPE_STRING, "artist-sortname-folded"),
 143 	PROP_ENTRY(ALBUM_SORTNAME_SORT_KEY, G_TYPE_STRING, "album-sortname-sort-key"),
 144 	PROP_ENTRY(ALBUM_SORTNAME_FOLDED, G_TYPE_STRING, "album-sortname-folded"),
 145 
 146 	PROP_ENTRY(COMMENT, G_TYPE_STRING, "comment"),
 147 
 148 	PROP_ENTRY(ALBUM_ARTIST, G_TYPE_STRING, "album-artist"),
 149 	PROP_ENTRY(ALBUM_ARTIST_SORT_KEY, G_TYPE_STRING, "album-artist-sort-key"),
 150 	PROP_ENTRY(ALBUM_ARTIST_FOLDED, G_TYPE_STRING, "album-artist-folded"),
 151 	PROP_ENTRY(ALBUM_ARTIST_SORTNAME, G_TYPE_STRING, "album-artist-sortname"),
 152 	PROP_ENTRY(ALBUM_ARTIST_SORTNAME_SORT_KEY, G_TYPE_STRING, "album-artist-sortname-sort-key"),
 153 	PROP_ENTRY(ALBUM_ARTIST_SORTNAME_FOLDED, G_TYPE_STRING, "album-artist-sortname-folded"),
 154 
 155 	PROP_ENTRY(BPM, G_TYPE_DOUBLE, "beats-per-minute"),
 156 
 157 	{ 0, 0, 0, 0 }
 158 };
 159 
 160 #define RB_PARSE_NICK_START (xmlChar *) "["
 161 #define RB_PARSE_NICK_END (xmlChar *) "]"
 162 
 163 
 164 #define RHYTHMDB_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), RHYTHMDB_TYPE, RhythmDBPrivate))
 165 G_DEFINE_ABSTRACT_TYPE(RhythmDB, rhythmdb, G_TYPE_OBJECT)
 166 
 167 /* file attributes requested in RHYTHMDB_ACTION_STAT and RHYTHMDB_ACTION_LOAD */
 168 #define RHYTHMDB_FILE_INFO_ATTRIBUTES			\
 169 	G_FILE_ATTRIBUTE_STANDARD_SIZE ","		\
 170 	G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME ","	\
 171 	G_FILE_ATTRIBUTE_STANDARD_TYPE ","		\
 172 	G_FILE_ATTRIBUTE_TIME_MODIFIED
 173 
 174 /* file attributes requested in RHYTHMDB_ACTION_ENUM_DIR */
 175 #define RHYTHMDB_FILE_CHILD_INFO_ATTRIBUTES		\
 176 	RHYTHMDB_FILE_INFO_ATTRIBUTES ","		\
 177 	G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN ","		\
 178 	G_FILE_ATTRIBUTE_STANDARD_NAME
 179 
 180 /*
 181  * Filters for MIME/media types to ignore.
 182  * The only complication here is that there are some application/ types that
 183  * are used for audio/video files.  Otherwise, we'd ignore everything except
 184  * audio/ and video/.
 185  */
 186 struct media_type_filter {
 187 	const char *prefix;
 188 	gboolean ignore;
 189 } media_type_filters[] = {
 190 	{ "image/", TRUE },
 191 	{ "text/", TRUE },
 192 	{ "application/ogg", FALSE },
 193 	{ "application/x-id3", FALSE },
 194 	{ "application/x-apetag", FALSE },
 195 	{ "application/x-3gp", FALSE },
 196 	{ "application/x-annodex", FALSE },
 197 	{ "application/", TRUE },
 198 };
 199 
 200 /*
 201  * File size below which we will simply ignore files that can't be identified.
 202  * This is mostly here so we ignore the various text files that are packaged
 203  * with many netlabel releases and other downloads.
 204  */
 205 #define REALLY_SMALL_FILE_SIZE	(4096)
 206 
 207 
 208 typedef struct
 209 {
 210 	RhythmDB *db;
 211 	GPtrArray *query;
 212 	guint propid;
 213 	RhythmDBQueryResults *results;
 214 	gboolean cancel;
 215 } RhythmDBQueryThreadData;
 216 
 217 typedef struct
 218 {
 219 	RhythmDB *db;
 220 	RhythmDBEntryType *type;
 221 	RhythmDBEntryType *ignore_type;
 222 	RhythmDBEntryType *error_type;
 223 } RhythmDBAddThreadData;
 224 
 225 typedef struct
 226 {
 227 	enum {
 228 		RHYTHMDB_ACTION_STAT,
 229 		RHYTHMDB_ACTION_LOAD,
 230 		RHYTHMDB_ACTION_ENUM_DIR,
 231 		RHYTHMDB_ACTION_SYNC,
 232 		RHYTHMDB_ACTION_QUIT,
 233 	} type;
 234 	RBRefString *uri;
 235 	union {
 236 		struct {
 237 			RhythmDBEntryType *entry_type;
 238 			RhythmDBEntryType *ignore_type;
 239 			RhythmDBEntryType *error_type;
 240 		} types;
 241 		GSList *changes;
 242 	} data;
 243 } RhythmDBAction;
 244 
 245 static void rhythmdb_dispose (GObject *object);
 246 static void rhythmdb_finalize (GObject *object);
 247 static void rhythmdb_set_property (GObject *object,
 248 					guint prop_id,
 249 					const GValue *value,
 250 					GParamSpec *pspec);
 251 static void rhythmdb_get_property (GObject *object,
 252 					guint prop_id,
 253 					GValue *value,
 254 					GParamSpec *pspec);
 255 static void rhythmdb_thread_create (RhythmDB *db,
 256 				    GThreadPool *pool,
 257 				    GThreadFunc func,
 258 				    gpointer data);
 259 static void rhythmdb_read_enter (RhythmDB *db);
 260 static void rhythmdb_read_leave (RhythmDB *db);
 261 static void rhythmdb_process_one_event (RhythmDBEvent *event, RhythmDB *db);
 262 static gpointer action_thread_main (RhythmDB *db);
 263 static gpointer query_thread_main (RhythmDBQueryThreadData *data);
 264 static void rhythmdb_entry_set_mount_point (RhythmDB *db,
 265  					    RhythmDBEntry *entry,
 266  					    const gchar *realuri);
 267 
 268 static gboolean rhythmdb_idle_save (RhythmDB *db);
 269 static void db_settings_changed_cb (GSettings *settings, const char *key, RhythmDB *db);
 270 static void rhythmdb_sync_library_location (RhythmDB *db);
 271 static void rhythmdb_entry_sync_mirrored (RhythmDBEntry *entry,
 272 					  guint propid);
 273 static gboolean rhythmdb_entry_extra_metadata_accumulator (GSignalInvocationHint *ihint,
 274 							   GValue *return_accu,
 275 							   const GValue *handler_return,
 276 							   gpointer data);
 277 
 278 static void rhythmdb_event_free (RhythmDB *db, RhythmDBEvent *event);
 279 static void rhythmdb_add_to_stat_list (RhythmDB *db,
 280 				       const char *uri,
 281 				       RhythmDBEntry *entry,
 282 				       RhythmDBEntryType *type,
 283 				       RhythmDBEntryType *ignore_type,
 284 				       RhythmDBEntryType *error_type);
 285 static void free_entry_changes (GSList *entry_changes);
 286 
 287 static void perform_next_mount (RhythmDB *db);
 288 
 289 enum
 290 {
 291 	PROP_0,
 292 	PROP_NAME,
 293 	PROP_DRY_RUN,
 294 	PROP_NO_UPDATE,
 295 };
 296 
 297 enum
 298 {
 299 	ENTRY_ADDED,
 300 	ENTRY_CHANGED,
 301 	ENTRY_DELETED,
 302 	ENTRY_KEYWORD_ADDED,
 303 	ENTRY_KEYWORD_REMOVED,
 304 	ENTRY_EXTRA_METADATA_REQUEST,
 305 	ENTRY_EXTRA_METADATA_NOTIFY,
 306 	ENTRY_EXTRA_METADATA_GATHER,
 307 	LOAD_COMPLETE,
 308 	SAVE_COMPLETE,
 309 	SAVE_ERROR,
 310 	READ_ONLY,
 311 	CREATE_MOUNT_OP,
 312 	LAST_SIGNAL
 313 };
 314 
 315 static guint rhythmdb_signals[LAST_SIGNAL] = { 0 };
 316 
 317 static void
 318 rhythmdb_class_init (RhythmDBClass *klass)
 319 {
 320 	GObjectClass *object_class = G_OBJECT_CLASS (klass);
 321 
 322 	object_class->dispose = rhythmdb_dispose;
 323 	object_class->finalize = rhythmdb_finalize;
 324 
 325 	object_class->set_property = rhythmdb_set_property;
 326 	object_class->get_property = rhythmdb_get_property;
 327 
 328 	/**
 329 	 * RhythmDB:name:
 330 	 *
 331 	 * Database name.  Not sure whta this is used for.
 332 	 */
 333 	g_object_class_install_property (object_class,
 334 					 PROP_NAME,
 335 					 g_param_spec_string ("name",
 336 							      "name",
 337 							      "name",
 338 							      NULL,
 339 							      G_PARAM_READWRITE));
 340 	/**
 341 	 * RhythmDB:dry-run:
 342 	 *
 343 	 * If %TRUE, no metadata changes will be written back to media fies.
 344 	 */
 345 	g_object_class_install_property (object_class,
 346 					 PROP_DRY_RUN,
 347 					 g_param_spec_boolean ("dry-run",
 348 							       "dry run",
 349 							       "Whether or not changes should be saved",
 350 							       FALSE,
 351 							       G_PARAM_READWRITE));
 352 	/**
 353 	 * RhythmDB:no-update:
 354 	 *
 355 	 * If %TRUE, the database will not be updated.
 356 	 */
 357 	g_object_class_install_property (object_class,
 358 					 PROP_NO_UPDATE,
 359 					 g_param_spec_boolean ("no-update",
 360 							       "no update",
 361 							       "Whether or not to update the database",
 362 							       FALSE,
 363 							       G_PARAM_READWRITE));
 364 	/**
 365 	 * RhythmDB::entry-added:
 366 	 * @db: the #RhythmDB
 367 	 * @entry: the newly added #RhythmDBEntry
 368 	 *
 369 	 * Emitted when a new entry is added to the database.
 370 	 */
 371 	rhythmdb_signals[ENTRY_ADDED] =
 372 		g_signal_new ("entry_added",
 373 			      RHYTHMDB_TYPE,
 374 			      G_SIGNAL_RUN_LAST,
 375 			      G_STRUCT_OFFSET (RhythmDBClass, entry_added),
 376 			      NULL, NULL,
 377 			      g_cclosure_marshal_VOID__BOXED,
 378 			      G_TYPE_NONE,
 379 			      1, RHYTHMDB_TYPE_ENTRY);
 380 
 381 	/**
 382 	 * RhythmDB::entry-deleted:
 383 	 * @db: the #RhythmDB
 384 	 * @entry: the deleted #RhythmDBEntry
 385 	 *
 386 	 * Emitted when an entry is deleted from the database.
 387 	 */
 388 	rhythmdb_signals[ENTRY_DELETED] =
 389 		g_signal_new ("entry_deleted",
 390 			      RHYTHMDB_TYPE,
 391 			      G_SIGNAL_RUN_LAST,
 392 			      G_STRUCT_OFFSET (RhythmDBClass, entry_deleted),
 393 			      NULL, NULL,
 394 			      g_cclosure_marshal_VOID__BOXED,
 395 			      G_TYPE_NONE,
 396 			      1, RHYTHMDB_TYPE_ENTRY);
 397 
 398 	/**
 399 	 * RhythmDB::entry-changed:
 400 	 * @db: the #RhythmDB
 401 	 * @entry: the changed #RhythmDBEntry
 402 	 * @changes: a #GArray of #RhythmDBEntryChange structures describing the changes
 403 	 *
 404 	 * Emitted when a database entry is modified.  The @changes list
 405 	 * contains a structure for each entry property that has been modified.
 406 	 */
 407 	rhythmdb_signals[ENTRY_CHANGED] =
 408 		g_signal_new ("entry_changed",
 409 			      RHYTHMDB_TYPE,
 410 			      G_SIGNAL_RUN_LAST,
 411 			      G_STRUCT_OFFSET (RhythmDBClass, entry_changed),
 412 			      NULL, NULL,
 413 			      rb_marshal_VOID__BOXED_BOXED,
 414 			      G_TYPE_NONE, 2,
 415 			      RHYTHMDB_TYPE_ENTRY, G_TYPE_ARRAY);
 416 
 417 	/**
 418 	 * RhythmDB::entry-keyword-added:
 419 	 * @db: the #RhythmDB
 420 	 * @entry: the #RhythmDBEntry to which a keyword has been added
 421 	 * @keyword: the keyword that was added
 422 	 *
 423 	 * Emitted when a keyword is added to an entry.
 424 	 */
 425 	rhythmdb_signals[ENTRY_KEYWORD_ADDED] =
 426 		g_signal_new ("entry_keyword_added",
 427 			      RHYTHMDB_TYPE,
 428 			      G_SIGNAL_RUN_LAST,
 429 			      G_STRUCT_OFFSET (RhythmDBClass, entry_added),
 430 			      NULL, NULL,
 431 			      rb_marshal_VOID__BOXED_BOXED,
 432 			      G_TYPE_NONE,
 433 			      2, RHYTHMDB_TYPE_ENTRY, RB_TYPE_REFSTRING);
 434 
 435 	/**
 436 	 * RhythmDB::entry-keyword-removed:
 437 	 * @db: the #RhythmDB
 438 	 * @entry: the #RhythmDBEntry from which a keyword has been removed
 439 	 * @keyword: the keyword that was removed
 440 	 *
 441 	 * Emitted when a keyword is removed from an entry.
 442 	 */
 443 	rhythmdb_signals[ENTRY_KEYWORD_REMOVED] =
 444 		g_signal_new ("entry_keyword_removed",
 445 			      RHYTHMDB_TYPE,
 446 			      G_SIGNAL_RUN_LAST,
 447 			      G_STRUCT_OFFSET (RhythmDBClass, entry_deleted),
 448 			      NULL, NULL,
 449 			      rb_marshal_VOID__BOXED_BOXED,
 450 			      G_TYPE_NONE,
 451 			      2, RHYTHMDB_TYPE_ENTRY, RB_TYPE_REFSTRING);
 452 
 453 	/**
 454 	 * RhythmDB::entry-extra-metadata-request:
 455 	 * @db: the #RhythmDB
 456 	 * @entry: the #RhythmDBEntry for which extra metadata is being requested
 457 	 *
 458 	 * This signal is emitted to allow extra (transient) metadata to be supplied
 459 	 * for the given entry.  The detail of the signal invocation describes the
 460 	 * specific metadata value being requested.  If the object handling the signal
 461 	 * can provide the requested item, but it isn't immediately available, it can
 462 	 * initiate an attempt to retrieve it.  If successful, it would call
 463 	 * @rhythmdb_emit_entry_extra_metadata_notify when the metadata is available.
 464 	 *
 465 	 * Return value: the extra metadata value
 466 	 */
 467 	rhythmdb_signals[ENTRY_EXTRA_METADATA_REQUEST] =
 468 		g_signal_new ("entry_extra_metadata_request",
 469 			      G_OBJECT_CLASS_TYPE (object_class),
 470 			      G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
 471 			      G_STRUCT_OFFSET (RhythmDBClass, entry_extra_metadata_request),
 472 			      rhythmdb_entry_extra_metadata_accumulator, NULL,
 473 			      rb_marshal_BOXED__BOXED,
 474 			      G_TYPE_VALUE, 1,
 475 			      RHYTHMDB_TYPE_ENTRY);
 476 
 477 	/**
 478 	 * RhythmDB::entry-extra-metadata-notify:
 479 	 * @db: the #RhythmDB
 480 	 * @entry: the #RhythmDBEntry for which extra metadata has been supplied
 481 	 * @field: the extra metadata field being supplied
 482 	 * @metadata: the extra metadata value
 483 	 *
 484 	 * This signal is emitted when an extra metadata value is provided for a specific
 485 	 * entry independantly of an extra metadata request.
 486 	 */
 487 	rhythmdb_signals[ENTRY_EXTRA_METADATA_NOTIFY] =
 488 		g_signal_new ("entry_extra_metadata_notify",
 489 			      G_OBJECT_CLASS_TYPE (object_class),
 490 			      G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
 491 			      G_STRUCT_OFFSET (RhythmDBClass, entry_extra_metadata_notify),
 492 			      NULL, NULL,
 493 			      rb_marshal_VOID__BOXED_STRING_BOXED,
 494 			      G_TYPE_NONE, 3,
 495 			      RHYTHMDB_TYPE_ENTRY, G_TYPE_STRING, G_TYPE_VALUE);
 496 
 497 	/**
 498 	 * RhythmDB::entry-extra-metadata-gather:
 499 	 * @db: the #RhythmDB
 500 	 * @entry: the #RhythmDBEntry for which to gather metadata
 501 	 * @data: a #RBStringValueMap to hold the gathered metadata
 502 	 *
 503 	 * Emitted to gather all available extra metadata for a database entry.
 504 	 * Handlers for this signal should insert any metadata they can provide
 505 	 * into the string-value map.  Only immediately available metadata
 506 	 * items should be returned.  If one or more metadata items is not
 507 	 * immediately available, the handler should not initiate an attempt to
 508 	 * retrieve them.
 509 	 */
 510 	rhythmdb_signals[ENTRY_EXTRA_METADATA_GATHER] =
 511 		g_signal_new ("entry_extra_metadata_gather",
 512 			      G_OBJECT_CLASS_TYPE (object_class),
 513 			      G_SIGNAL_RUN_LAST,
 514 			      G_STRUCT_OFFSET (RhythmDBClass, entry_extra_metadata_gather),
 515 			      NULL, NULL,
 516 			      rb_marshal_VOID__BOXED_OBJECT,
 517 			      G_TYPE_NONE, 2,
 518 			      RHYTHMDB_TYPE_ENTRY, RB_TYPE_STRING_VALUE_MAP);
 519 
 520 	/**
 521 	 * RhythmDB::load-complete:
 522 	 * @db: the #RhythmDB
 523 	 *
 524 	 * Emitted when the database is fully loaded.
 525 	 */
 526 	rhythmdb_signals[LOAD_COMPLETE] =
 527 		g_signal_new ("load_complete",
 528 			      RHYTHMDB_TYPE,
 529 			      G_SIGNAL_RUN_LAST,
 530 			      G_STRUCT_OFFSET (RhythmDBClass, load_complete),
 531 			      NULL, NULL,
 532 			      g_cclosure_marshal_VOID__VOID,
 533 			      G_TYPE_NONE,
 534 			      0);
 535 
 536 	/**
 537 	 * RhythmDB::save-complete:
 538 	 * @db: the #RhythmDB
 539 	 *
 540 	 * Emitted when the database has been saved.
 541 	 */
 542 	rhythmdb_signals[SAVE_COMPLETE] =
 543 		g_signal_new ("save_complete",
 544 			      RHYTHMDB_TYPE,
 545 			      G_SIGNAL_RUN_LAST,
 546 			      G_STRUCT_OFFSET (RhythmDBClass, save_complete),
 547 			      NULL, NULL,
 548 			      g_cclosure_marshal_VOID__VOID,
 549 			      G_TYPE_NONE,
 550 			      0);
 551 
 552 	/**
 553 	 * RhythmDB::save-error:
 554 	 * @db: the #RhythmDB
 555 	 * @uri: URI of the database file
 556 	 * @error: the error that occurred
 557 	 *
 558 	 * Emitted when an error occurs while saving the database.
 559 	 */
 560 	rhythmdb_signals[SAVE_ERROR] =
 561 		g_signal_new ("save-error",
 562 			      G_OBJECT_CLASS_TYPE (object_class),
 563 			      G_SIGNAL_RUN_LAST,
 564 			      G_STRUCT_OFFSET (RhythmDBClass, save_error),
 565 			      NULL, NULL,
 566 			      rb_marshal_VOID__STRING_POINTER,
 567 			      G_TYPE_NONE,
 568 			      2,
 569 			      G_TYPE_STRING,
 570 			      G_TYPE_POINTER);
 571 
 572 	/**
 573 	 * RhythmDB::read-only:
 574 	 * @db: the #RhythmDB
 575 	 * @readonly: %TRUE if the database is read-only
 576 	 *
 577 	 * Emitted when the database becomes temporarily read-only, or becomes
 578 	 * writeable after being read-only.
 579 	 */
 580 	rhythmdb_signals[READ_ONLY] =
 581 		g_signal_new ("read-only",
 582 			      G_OBJECT_CLASS_TYPE (object_class),
 583 			      G_SIGNAL_RUN_LAST,
 584 			      G_STRUCT_OFFSET (RhythmDBClass, read_only),
 585 			      NULL, NULL,
 586 			      g_cclosure_marshal_VOID__BOOLEAN,
 587 			      G_TYPE_NONE,
 588 			      1,
 589 			      G_TYPE_BOOLEAN);
 590 
 591 	/**
 592 	 * RhythmDB::create-mount-op:
 593 	 * @db: the #RhythmDB
 594 	 *
 595 	 * Emitted to request creation of a #GMountOperation to use to mount a volume.
 596 	 *
 597 	 * Returns: (transfer full): a #GMountOperation (usually actually a #GtkMountOperation)
 598 	 */
 599 	rhythmdb_signals[CREATE_MOUNT_OP] =
 600 		g_signal_new ("create-mount-op",
 601 			      G_OBJECT_CLASS_TYPE (object_class),
 602 			      G_SIGNAL_RUN_LAST,
 603 			      0,		/* no need for an internal handler */
 604 			      rb_signal_accumulator_object_handled, NULL,
 605 			      rb_marshal_OBJECT__VOID,
 606 			      G_TYPE_MOUNT_OPERATION,
 607 			      0);
 608 
 609 	g_type_class_add_private (klass, sizeof (RhythmDBPrivate));
 610 }
 611 
 612 static void
 613 rhythmdb_push_event (RhythmDB *db, RhythmDBEvent *event)
 614 {
 615 	g_async_queue_push (db->priv->event_queue, event);
 616 	g_main_context_wakeup (g_main_context_default ());
 617 }
 618 
 619 static gboolean
 620 metadata_field_from_prop (RhythmDBPropType prop,
 621 			  RBMetaDataField *field)
 622 {
 623 	switch (prop) {
 624 	case RHYTHMDB_PROP_TITLE:
 625 		*field = RB_METADATA_FIELD_TITLE;
 626 		return TRUE;
 627 	case RHYTHMDB_PROP_ARTIST:
 628 		*field = RB_METADATA_FIELD_ARTIST;
 629 		return TRUE;
 630 	case RHYTHMDB_PROP_ALBUM:
 631 		*field = RB_METADATA_FIELD_ALBUM;
 632 		return TRUE;
 633 	case RHYTHMDB_PROP_GENRE:
 634 		*field = RB_METADATA_FIELD_GENRE;
 635 		return TRUE;
 636 	case RHYTHMDB_PROP_COMMENT:
 637 		*field = RB_METADATA_FIELD_COMMENT;
 638 		return TRUE;
 639 	case RHYTHMDB_PROP_TRACK_NUMBER:
 640 		*field = RB_METADATA_FIELD_TRACK_NUMBER;
 641 		return TRUE;
 642 	case RHYTHMDB_PROP_DISC_NUMBER:
 643 		*field = RB_METADATA_FIELD_DISC_NUMBER;
 644 		return TRUE;
 645 	case RHYTHMDB_PROP_DATE:
 646 		*field = RB_METADATA_FIELD_DATE;
 647 		return TRUE;
 648 	case RHYTHMDB_PROP_BPM:
 649 		*field = RB_METADATA_FIELD_BPM;
 650 		return TRUE;
 651 	case RHYTHMDB_PROP_MUSICBRAINZ_TRACKID:
 652 		*field = RB_METADATA_FIELD_MUSICBRAINZ_TRACKID;
 653 		return TRUE;
 654 	case RHYTHMDB_PROP_MUSICBRAINZ_ARTISTID:
 655 		*field = RB_METADATA_FIELD_MUSICBRAINZ_ARTISTID;
 656 		return TRUE;
 657 	case RHYTHMDB_PROP_MUSICBRAINZ_ALBUMID:
 658 		*field = RB_METADATA_FIELD_MUSICBRAINZ_ALBUMID;
 659 		return TRUE;
 660 	case RHYTHMDB_PROP_MUSICBRAINZ_ALBUMARTISTID:
 661 		*field = RB_METADATA_FIELD_MUSICBRAINZ_ALBUMARTISTID;
 662 		return TRUE;
 663 	case RHYTHMDB_PROP_ARTIST_SORTNAME:
 664 		*field = RB_METADATA_FIELD_ARTIST_SORTNAME;
 665 		return TRUE;
 666 	case RHYTHMDB_PROP_ALBUM_SORTNAME:
 667 		*field = RB_METADATA_FIELD_ALBUM_SORTNAME;
 668 		return TRUE;
 669 	case RHYTHMDB_PROP_ALBUM_ARTIST:
 670 		*field = RB_METADATA_FIELD_ALBUM_ARTIST;
 671 		return TRUE;
 672 	case RHYTHMDB_PROP_ALBUM_ARTIST_SORTNAME:
 673 		*field = RB_METADATA_FIELD_ALBUM_ARTIST_SORTNAME;
 674 		return TRUE;
 675 	default:
 676 		return FALSE;
 677 	}
 678 }
 679 
 680 static void
 681 rhythmdb_init (RhythmDB *db)
 682 {
 683 	guint i;
 684 	GEnumClass *prop_class;
 685 
 686 	db->priv = RHYTHMDB_GET_PRIVATE (db);
 687 
 688 	db->priv->settings = g_settings_new ("org.gnome.rhythmbox.rhythmdb");
 689 	g_signal_connect_object (db->priv->settings, "changed", G_CALLBACK (db_settings_changed_cb), db, 0);
 690 
 691 	db->priv->action_queue = g_async_queue_new ();
 692 	db->priv->event_queue = g_async_queue_new ();
 693 	db->priv->delayed_write_queue = g_async_queue_new ();
 694 	db->priv->event_queue_watch_id = rb_async_queue_watch_new (db->priv->event_queue,
 695 								   G_PRIORITY_LOW,		/* really? */
 696 								   (RBAsyncQueueWatchFunc) rhythmdb_process_one_event,
 697 								   db,
 698 								   NULL,
 699 								   NULL);
 700 
 701 	db->priv->restored_queue = g_async_queue_new ();
 702 
 703 	db->priv->query_thread_pool = g_thread_pool_new ((GFunc)query_thread_main,
 704 							 NULL,
 705 							 -1, FALSE, NULL);
 706 
 707 	db->priv->metadata = rb_metadata_new ();
 708 
 709 	prop_class = g_type_class_ref (RHYTHMDB_TYPE_PROP_TYPE);
 710 
 711 	g_assert (prop_class->n_values == RHYTHMDB_NUM_PROPERTIES);
 712 
 713 	g_type_class_unref (prop_class);
 714 
 715 	db->priv->propname_map = g_hash_table_new (g_str_hash, g_str_equal);
 716 
 717 	for (i = 0; i < RHYTHMDB_NUM_PROPERTIES; i++) {
 718 		const xmlChar *name = rhythmdb_nice_elt_name_from_propid (db, i);
 719 		g_hash_table_insert (db->priv->propname_map, (gpointer) name, GINT_TO_POINTER (i));
 720 	}
 721 
 722 	db->priv->entry_type_map = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
 723 
 724 	rhythmdb_register_song_entry_types (db);
 725 	rb_podcast_register_entry_types (db);
 726 
 727 	db->priv->changed_entries = g_hash_table_new_full (NULL,
 728 							   NULL,
 729 							   (GDestroyNotify) rhythmdb_entry_unref,
 730 							   NULL);
 731 	db->priv->added_entries = g_hash_table_new_full (NULL,
 732 							 NULL,
 733 							 (GDestroyNotify) rhythmdb_entry_unref,
 734 							 NULL);
 735 	db->priv->deleted_entries = g_hash_table_new_full (NULL,
 736 							   NULL,
 737 							   (GDestroyNotify) rhythmdb_entry_unref,
 738 							   NULL);
 739 
 740 	db->priv->can_save = TRUE;
 741 	db->priv->exiting = g_cancellable_new ();
 742 	db->priv->saving = FALSE;
 743 	db->priv->dirty = FALSE;
 744 
 745 	db->priv->empty_string = rb_refstring_new ("");
 746 	db->priv->octet_stream_str = rb_refstring_new ("application/octet-stream");
 747 
 748 	db->priv->next_entry_id = 1;
 749 
 750 	rhythmdb_init_monitoring (db);
 751 
 752 	rhythmdb_dbus_register (db);
 753 }
 754 
 755 static GError *
 756 make_access_failed_error (const char *uri, GError *access_error)
 757 {
 758 	char *unescaped;
 759 	char *utf8ised;
 760 	GError *error;
 761 
 762 	/* make sure the URI we put in the error message is valid utf8 */
 763 	unescaped = g_uri_unescape_string (uri, NULL);
 764 	utf8ised = rb_make_valid_utf8 (unescaped, '?');
 765 
 766 	error = g_error_new (RHYTHMDB_ERROR,
 767 			     RHYTHMDB_ERROR_ACCESS_FAILED,
 768 			     _("Couldn't access %s: %s"),
 769 			     utf8ised,
 770 			     access_error->message);
Access to field 'message' results in a dereference of a null pointer (loaded from variable 'access_error')
(emitted by clang-analyzer)

TODO: a detailed trace is available in the data model (not yet rendered in this report)

Access to field 'message' results in a dereference of a null pointer (loaded from variable 'access_error')
(emitted by clang-analyzer)

TODO: a detailed trace is available in the data model (not yet rendered in this report)

771 rb_debug ("got error on %s: %s", uri, error->message); 772 g_free (unescaped); 773 g_free (utf8ised); 774 return error; 775 } 776 777 static gboolean 778 rhythmdb_ignore_media_type (const char *media_type) 779 { 780 int i; 781 782 for (i = 0; i < G_N_ELEMENTS (media_type_filters); i++) { 783 if (g_str_has_prefix (media_type, media_type_filters[i].prefix)) { 784 return media_type_filters[i].ignore; 785 } 786 } 787 return FALSE; 788 } 789 790 typedef struct { 791 RhythmDB *db; 792 GList *stat_list; 793 } RhythmDBStatThreadData; 794 795 static gpointer 796 stat_thread_main (RhythmDBStatThreadData *data) 797 { 798 GList *i; 799 GError *error = NULL; 800 RhythmDBEvent *result; 801 802 data->db->priv->stat_thread_count = g_list_length (data->stat_list); 803 data->db->priv->stat_thread_done = 0; 804 805 rb_debug ("entering stat thread: %d to process", data->db->priv->stat_thread_count); 806 for (i = data->stat_list; i != NULL; i = i->next) { 807 RhythmDBEvent *event = (RhythmDBEvent *)i->data; 808 GFile *file; 809 810 /* if we've been cancelled, just free the event. this will 811 * clean up the list and then we'll exit the thread. 812 */ 813 if (g_cancellable_is_cancelled (data->db->priv->exiting)) { 814 rhythmdb_event_free (data->db, event); 815 continue; 816 } 817 818 if (data->db->priv->stat_thread_done > 0 && 819 data->db->priv->stat_thread_done % 1000 == 0) { 820 rb_debug ("%d file info queries done", 821 data->db->priv->stat_thread_done); 822 } 823 824 file = g_file_new_for_uri (rb_refstring_get (event->uri)); 825 event->real_uri = rb_refstring_ref (event->uri); /* what? */ 826 event->file_info = g_file_query_info (file, 827 G_FILE_ATTRIBUTE_TIME_MODIFIED, /* anything else? */ 828 G_FILE_QUERY_INFO_NONE, 829 data->db->priv->exiting, 830 &error); 831 if (error != NULL) { 832 event->error = make_access_failed_error (rb_refstring_get (event->uri), error); 833 g_clear_error (&error); 834 835 if (event->file_info != NULL) { 836 g_object_unref (event->file_info); 837 event->file_info = NULL; 838 } 839 } 840 841 g_async_queue_push (data->db->priv->event_queue, event); 842 g_object_unref (file); 843 g_atomic_int_inc (&data->db->priv->stat_thread_done); 844 } 845 846 g_list_free (data->stat_list); 847 848 data->db->priv->stat_thread_running = FALSE; 849 850 rb_debug ("exiting stat thread"); 851 result = g_slice_new0 (RhythmDBEvent); 852 result->db = data->db; /* need to unref? */ 853 result->type = RHYTHMDB_EVENT_THREAD_EXITED; 854 rhythmdb_push_event (data->db, result); 855 856 g_free (data); 857 return NULL; 858 } 859 860 static void 861 perform_next_mount_cb (GObject *file, GAsyncResult *res, RhythmDB *db) 862 { 863 GError *error = NULL; 864 865 g_file_mount_enclosing_volume_finish (G_FILE (file), res, &error); 866 if (error != NULL) { 867 char *uri; 868 869 uri = g_file_get_uri (G_FILE (file)); 870 rb_debug ("Unable to mount %s: %s", uri, error->message); 871 g_free (uri); 872 g_clear_error (&error); 873 } 874 g_object_unref (file); 875 876 perform_next_mount (db); 877 } 878 879 static void 880 perform_next_mount (RhythmDB *db) 881 { 882 GList *l; 883 char *mountpoint; 884 GMountOperation *mount_op = NULL; 885 886 if (db->priv->mount_list == NULL) { 887 rb_debug ("finished mounting"); 888 return; 889 } 890 891 l = db->priv->mount_list; 892 db->priv->mount_list = db->priv->mount_list->next; 893 mountpoint = l->data; 894 g_list_free1 (l); 895 896 rb_debug ("mounting %s", (char *)mountpoint); 897 g_signal_emit (G_OBJECT (db), rhythmdb_signals[CREATE_MOUNT_OP], 0, &mount_op); 898 g_file_mount_enclosing_volume (g_file_new_for_uri (mountpoint), 899 G_MOUNT_MOUNT_NONE, 900 mount_op, 901 db->priv->exiting, 902 (GAsyncReadyCallback) perform_next_mount_cb, 903 db); 904 } 905 906 /** 907 * rhythmdb_start_action_thread: 908 * @db: the #RhythmDB 909 * 910 * Starts the #RhythmDB processing thread. Needs to be called during startup. 911 */ 912 void 913 rhythmdb_start_action_thread (RhythmDB *db) 914 { 915 g_mutex_lock (&db->priv->stat_mutex); 916 db->priv->action_thread_running = TRUE; 917 rhythmdb_thread_create (db, NULL, (GThreadFunc) action_thread_main, db); 918 919 if (db->priv->stat_list != NULL) { 920 RhythmDBStatThreadData *data; 921 data = g_new0 (RhythmDBStatThreadData, 1); 922 data->db = g_object_ref (db); 923 data->stat_list = db->priv->stat_list; 924 db->priv->stat_list = NULL; 925 926 db->priv->stat_thread_running = TRUE; 927 rhythmdb_thread_create (db, NULL, (GThreadFunc) stat_thread_main, data); 928 } 929 930 perform_next_mount (db); 931 932 g_mutex_unlock (&db->priv->stat_mutex); 933 } 934 935 static void 936 rhythmdb_action_free (RhythmDB *db, 937 RhythmDBAction *action) 938 { 939 rb_refstring_unref (action->uri); 940 if (action->type == RHYTHMDB_ACTION_SYNC) { 941 free_entry_changes (action->data.changes); 942 } 943 g_slice_free (RhythmDBAction, action); 944 } 945 946 static void 947 rhythmdb_event_free (RhythmDB *db, 948 RhythmDBEvent *result) 949 { 950 switch (result->type) { 951 case RHYTHMDB_EVENT_THREAD_EXITED: 952 g_object_unref (db); 953 g_assert (g_atomic_int_dec_and_test (&db->priv->outstanding_threads) >= 0); 954 g_async_queue_unref (db->priv->action_queue); 955 g_async_queue_unref (db->priv->event_queue); 956 break; 957 case RHYTHMDB_EVENT_STAT: 958 case RHYTHMDB_EVENT_METADATA_LOAD: 959 case RHYTHMDB_EVENT_DB_LOAD: 960 case RHYTHMDB_EVENT_DB_SAVED: 961 case RHYTHMDB_EVENT_QUERY_COMPLETE: 962 break; 963 case RHYTHMDB_EVENT_ENTRY_SET: 964 g_value_unset (&result->change.new); 965 break; 966 } 967 if (result->error) 968 g_error_free (result->error); 969 rb_refstring_unref (result->uri); 970 rb_refstring_unref (result->real_uri); 971 if (result->file_info) 972 g_object_unref (result->file_info); 973 if (result->metadata) 974 g_object_unref (result->metadata); 975 if (result->results) 976 g_object_unref (result->results); 977 if (result->entry != NULL) { 978 rhythmdb_entry_unref (result->entry); 979 } 980 g_slice_free (RhythmDBEvent, result); 981 } 982 983 static void 984 _shutdown_foreach_swapped (RhythmDBEvent *event, RhythmDB *db) 985 { 986 rhythmdb_event_free (db, event); 987 } 988 989 /** 990 * rhythmdb_shutdown: 991 * @db: the #RhythmDB 992 * 993 * Ceases all #RhythmDB operations, including stopping all directory monitoring, and 994 * removing all actions and events currently queued. 995 */ 996 void 997 rhythmdb_shutdown (RhythmDB *db) 998 { 999 RhythmDBEvent *result; 1000 RhythmDBAction *action; 1001 1002 g_return_if_fail (RHYTHMDB_IS (db)); 1003 1004 g_cancellable_cancel (db->priv->exiting); 1005 1006 /* force the action thread to wake up and exit */ 1007 action = g_slice_new0 (RhythmDBAction); 1008 action->type = RHYTHMDB_ACTION_QUIT; 1009 g_async_queue_push (db->priv->action_queue, action); 1010 1011 /* abort all async io operations */ 1012 g_mutex_lock (&db->priv->stat_mutex); 1013 g_list_foreach (db->priv->outstanding_stats, (GFunc)_shutdown_foreach_swapped, db); 1014 g_list_free (db->priv->outstanding_stats); 1015 db->priv->outstanding_stats = NULL; 1016 g_mutex_unlock (&db->priv->stat_mutex); 1017 1018 rb_debug ("%d outstanding threads", g_atomic_int_get (&db->priv->outstanding_threads)); 1019 while (g_atomic_int_get (&db->priv->outstanding_threads) > 0) { 1020 result = g_async_queue_pop (db->priv->event_queue); 1021 rhythmdb_event_free (db, result); 1022 } 1023 1024 /* FIXME */ 1025 while ((result = g_async_queue_try_pop (db->priv->event_queue)) != NULL) 1026 rhythmdb_event_free (db, result); 1027 while ((result = g_async_queue_try_pop (db->priv->delayed_write_queue)) != NULL) 1028 rhythmdb_event_free (db, result); 1029 1030 while ((action = g_async_queue_try_pop (db->priv->action_queue)) != NULL) { 1031 rhythmdb_action_free (db, action); 1032 } 1033 } 1034 1035 static void 1036 rhythmdb_dispose (GObject *object) 1037 { 1038 RhythmDB *db; 1039 1040 g_return_if_fail (object != NULL); 1041 g_return_if_fail (RHYTHMDB_IS (object)); 1042 1043 rb_debug ("disposing rhythmdb"); 1044 db = RHYTHMDB (object); 1045 1046 g_return_if_fail (db->priv != NULL); 1047 1048 rhythmdb_dispose_monitoring (db); 1049 rhythmdb_dbus_unregister (db); 1050 1051 if (db->priv->event_queue_watch_id != 0) { 1052 g_source_remove (db->priv->event_queue_watch_id); 1053 db->priv->event_queue_watch_id = 0; 1054 } 1055 1056 if (db->priv->save_timeout_id != 0) { 1057 g_source_remove (db->priv->save_timeout_id); 1058 db->priv->save_timeout_id = 0; 1059 } 1060 1061 if (db->priv->emit_entry_signals_id != 0) { 1062 g_source_remove (db->priv->emit_entry_signals_id); 1063 db->priv->emit_entry_signals_id = 0; 1064 1065 g_list_foreach (db->priv->added_entries_to_emit, (GFunc)rhythmdb_entry_unref, NULL); 1066 g_list_foreach (db->priv->deleted_entries_to_emit, (GFunc)rhythmdb_entry_unref, NULL); 1067 if (db->priv->changed_entries_to_emit != NULL) { 1068 g_hash_table_destroy (db->priv->changed_entries_to_emit); 1069 } 1070 } 1071 1072 if (db->priv->metadata != NULL) { 1073 g_object_unref (db->priv->metadata); 1074 db->priv->metadata = NULL; 1075 } 1076 1077 if (db->priv->exiting != NULL) { 1078 g_object_unref (db->priv->exiting); 1079 db->priv->exiting = NULL; 1080 } 1081 1082 if (db->priv->settings != NULL) { 1083 g_object_unref (db->priv->settings); 1084 db->priv->settings = NULL; 1085 } 1086 1087 G_OBJECT_CLASS (rhythmdb_parent_class)->dispose (object); 1088 } 1089 1090 static void 1091 rhythmdb_finalize (GObject *object) 1092 { 1093 RhythmDB *db; 1094 1095 g_return_if_fail (object != NULL); 1096 g_return_if_fail (RHYTHMDB_IS (object)); 1097 1098 rb_debug ("finalizing rhythmdb"); 1099 db = RHYTHMDB (object); 1100 1101 g_return_if_fail (db->priv != NULL); 1102 1103 rhythmdb_finalize_monitoring (db); 1104 g_strfreev (db->priv->library_locations); 1105 db->priv->library_locations = NULL; 1106 1107 g_thread_pool_free (db->priv->query_thread_pool, FALSE, TRUE); 1108 g_async_queue_unref (db->priv->action_queue); 1109 g_async_queue_unref (db->priv->event_queue); 1110 g_async_queue_unref (db->priv->restored_queue); 1111 g_async_queue_unref (db->priv->delayed_write_queue); 1112 1113 g_list_free (db->priv->stat_list); 1114 1115 g_hash_table_destroy (db->priv->propname_map); 1116 1117 g_hash_table_destroy (db->priv->added_entries); 1118 g_hash_table_destroy (db->priv->deleted_entries); 1119 g_hash_table_destroy (db->priv->changed_entries); 1120 1121 rb_refstring_unref (db->priv->empty_string); 1122 rb_refstring_unref (db->priv->octet_stream_str); 1123 1124 g_hash_table_destroy (db->priv->entry_type_map); 1125 1126 g_free (db->priv->name); 1127 1128 G_OBJECT_CLASS (rhythmdb_parent_class)->finalize (object); 1129 } 1130 1131 static void 1132 rhythmdb_set_property (GObject *object, 1133 guint prop_id, 1134 const GValue *value, 1135 GParamSpec *pspec) 1136 { 1137 RhythmDB *db = RHYTHMDB (object); 1138 1139 switch (prop_id) { 1140 case PROP_NAME: 1141 g_free (db->priv->name); 1142 db->priv->name = g_value_dup_string (value); 1143 break; 1144 case PROP_DRY_RUN: 1145 db->priv->dry_run = g_value_get_boolean (value); 1146 break; 1147 case PROP_NO_UPDATE: 1148 db->priv->no_update = g_value_get_boolean (value); 1149 break; 1150 default: 1151 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); 1152 break; 1153 } 1154 } 1155 1156 static void 1157 rhythmdb_get_property (GObject *object, 1158 guint prop_id, 1159 GValue *value, 1160 GParamSpec *pspec) 1161 { 1162 RhythmDB *source = RHYTHMDB (object); 1163 1164 switch (prop_id) { 1165 case PROP_NAME: 1166 g_value_set_string (value, source->priv->name); 1167 break; 1168 case PROP_DRY_RUN: 1169 g_value_set_boolean (value, source->priv->dry_run); 1170 break; 1171 case PROP_NO_UPDATE: 1172 g_value_set_boolean (value, source->priv->no_update); 1173 break; 1174 default: 1175 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); 1176 break; 1177 } 1178 } 1179 1180 static void 1181 rhythmdb_thread_create (RhythmDB *db, 1182 GThreadPool *pool, 1183 GThreadFunc func, 1184 gpointer data) 1185 { 1186 g_object_ref (db); 1187 g_atomic_int_inc (&db->priv->outstanding_threads); 1188 g_async_queue_ref (db->priv->action_queue); 1189 g_async_queue_ref (db->priv->event_queue); 1190 1191 if (pool) 1192 g_thread_pool_push (pool, data, NULL); 1193 else 1194 g_thread_new ("rhythmdb-thread", (GThreadFunc) func, data); 1195 } 1196 1197 static gboolean 1198 rhythmdb_get_readonly (RhythmDB *db) 1199 { 1200 return (g_atomic_int_get (&db->priv->read_counter) > 0); 1201 } 1202 1203 static void 1204 rhythmdb_read_enter (RhythmDB *db) 1205 { 1206 gint count; 1207 g_return_if_fail (g_atomic_int_get (&db->priv->read_counter) >= 0); 1208 g_assert (rb_is_main_thread ()); 1209 1210 count = g_atomic_int_add (&db->priv->read_counter, 1); 1211 rb_debug ("counter: %d", count+1); 1212 if (count == 0) 1213 g_signal_emit (G_OBJECT (db), rhythmdb_signals[READ_ONLY], 1214 0, TRUE); 1215 } 1216 1217 static void 1218 rhythmdb_read_leave (RhythmDB *db) 1219 { 1220 gint count; 1221 g_return_if_fail (rhythmdb_get_readonly (db)); 1222 g_assert (rb_is_main_thread ()); 1223 1224 count = g_atomic_int_add (&db->priv->read_counter, -1); 1225 rb_debug ("counter: %d", count-1); 1226 if (count == 1) { 1227 1228 g_signal_emit (G_OBJECT (db), rhythmdb_signals[READ_ONLY], 1229 0, FALSE); 1230 1231 /* move any delayed writes back to the main event queue */ 1232 if (g_async_queue_length (db->priv->delayed_write_queue) > 0) { 1233 RhythmDBEvent *event; 1234 while ((event = g_async_queue_try_pop (db->priv->delayed_write_queue)) != NULL) 1235 g_async_queue_push (db->priv->event_queue, event); 1236 1237 g_main_context_wakeup (g_main_context_default ()); 1238 } 1239 1240 } 1241 } 1242 1243 static void 1244 rhythmdb_entry_change_free (RhythmDBEntryChange *change) 1245 { 1246 g_value_unset (&change->old); 1247 g_value_unset (&change->new); 1248 g_slice_free (RhythmDBEntryChange, change); 1249 } 1250 1251 static RhythmDBEntryChange * 1252 rhythmdb_entry_change_copy (RhythmDBEntryChange *change) 1253 { 1254 RhythmDBEntryChange *c = g_slice_new0 (RhythmDBEntryChange); 1255 1256 c->prop = change->prop; 1257 g_value_init (&c->old, G_VALUE_TYPE (&change->old)); 1258 g_value_init (&c->new, G_VALUE_TYPE (&change->new)); 1259 g_value_copy (&change->old, &c->old); 1260 g_value_copy (&change->new, &c->new); 1261 return c; 1262 } 1263 1264 static void 1265 free_entry_changes (GSList *entry_changes) 1266 { 1267 GSList *t; 1268 for (t = entry_changes; t; t = t->next) { 1269 RhythmDBEntryChange *change = t->data; 1270 rhythmdb_entry_change_free (change); 1271 } 1272 g_slist_free (entry_changes); 1273 } 1274 1275 static GSList * 1276 copy_entry_changes (GSList *entry_changes) 1277 { 1278 GSList *r = NULL; 1279 GSList *t; 1280 for (t = entry_changes; t; t = t->next) { 1281 RhythmDBEntryChange *change = t->data; 1282 r = g_slist_prepend (r, rhythmdb_entry_change_copy (change)); 1283 } 1284 1285 return g_slist_reverse (r); 1286 } 1287 1288 static gboolean 1289 rhythmdb_emit_entry_signals_idle (RhythmDB *db) 1290 { 1291 GList *added_entries; 1292 GList *deleted_entries; 1293 GHashTable *changed_entries; 1294 GList *l; 1295 GHashTableIter iter; 1296 RhythmDBEntry *entry; 1297 GSList *entry_changes; 1298 1299 /* get lists of entries to emit, reset source id value */ 1300 g_mutex_lock (&db->priv->change_mutex); 1301 1302 added_entries = db->priv->added_entries_to_emit; 1303 db->priv->added_entries_to_emit = NULL; 1304 1305 deleted_entries = db->priv->deleted_entries_to_emit; 1306 db->priv->deleted_entries_to_emit = NULL; 1307 1308 changed_entries = db->priv->changed_entries_to_emit; 1309 db->priv->changed_entries_to_emit = NULL; 1310 1311 db->priv->emit_entry_signals_id = 0; 1312 1313 g_mutex_unlock (&db->priv->change_mutex); 1314 1315 GDK_THREADS_ENTER (); 1316 1317 /* emit changed entries */ 1318 if (changed_entries != NULL) { 1319 g_hash_table_iter_init (&iter, changed_entries); 1320 while (g_hash_table_iter_next (&iter, (gpointer *)&entry, (gpointer *)&entry_changes)) { 1321 GArray *emit_changes; 1322 GSList *c; 1323 1324 emit_changes = g_array_sized_new (FALSE, TRUE, sizeof (GValue), g_slist_length (entry_changes)); 1325 g_array_set_clear_func (emit_changes, (GDestroyNotify) g_value_unset); 1326 for (c = entry_changes; c != NULL; c = c->next) { 1327 GValue v = {0,}; 1328 g_value_init (&v, RHYTHMDB_TYPE_ENTRY_CHANGE); 1329 g_value_take_boxed (&v, c->data); 1330 g_array_append_val (emit_changes, v); 1331 } 1332 g_signal_emit (G_OBJECT (db), rhythmdb_signals[ENTRY_CHANGED], 0, entry, emit_changes); 1333 g_array_unref (emit_changes); 1334 g_hash_table_iter_remove (&iter); 1335 } 1336 } 1337 1338 /* emit added entries */ 1339 for (l = added_entries; l; l = g_list_next (l)) { 1340 entry = (RhythmDBEntry *)l->data; 1341 g_signal_emit (G_OBJECT (db), rhythmdb_signals[ENTRY_ADDED], 0, entry); 1342 rhythmdb_entry_unref (entry); 1343 } 1344 1345 /* emit deleted entries */ 1346 for (l = deleted_entries; l; l = g_list_next (l)) { 1347 entry = (RhythmDBEntry *)l->data; 1348 g_signal_emit (G_OBJECT (db), rhythmdb_signals[ENTRY_DELETED], 0, entry); 1349 rhythmdb_entry_unref (entry); 1350 } 1351 1352 GDK_THREADS_LEAVE (); 1353 1354 if (changed_entries != NULL) { 1355 g_hash_table_destroy (changed_entries); 1356 } 1357 g_list_free (added_entries); 1358 g_list_free (deleted_entries); 1359 return FALSE; 1360 } 1361 1362 static gboolean 1363 process_added_entries_cb (RhythmDBEntry *entry, 1364 GThread *thread, 1365 RhythmDB *db) 1366 { 1367 if (thread != g_thread_self ()) 1368 return FALSE; 1369 1370 if (entry->type == RHYTHMDB_ENTRY_TYPE_SONG) { 1371 const gchar *uri; 1372 1373 uri = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION); 1374 if (uri == NULL) 1375 return TRUE; 1376 1377 /* 1378 * hmm, do we really need to take the stat mutex to check if the action thread is running? 1379 * maybe it should be atomicised? 1380 */ 1381 /* 1382 * current plan: 1383 * - only stat things with mountpoint == NULL here 1384 * - collect other mountpoints 1385 * just before starting action/stat threads: 1386 * - find remote mountpoints that aren't mounted, try to mount them 1387 * - for local mountpoints that are mounted, add to stat list 1388 * - for everything else, hide entries on those mountpoints 1389 */ 1390 g_mutex_lock (&db->priv->stat_mutex); 1391 if (db->priv->action_thread_running == FALSE) { 1392 const char *mountpoint; 1393 1394 mountpoint = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_MOUNTPOINT); 1395 if (mountpoint == NULL) { 1396 /* entry is on a core filesystem, always check it */ 1397 rhythmdb_add_to_stat_list (db, uri, entry, 1398 RHYTHMDB_ENTRY_TYPE_SONG, 1399 RHYTHMDB_ENTRY_TYPE_IGNORE, 1400 RHYTHMDB_ENTRY_TYPE_IMPORT_ERROR); 1401 } else if (rb_string_list_contains (db->priv->active_mounts, mountpoint)) { 1402 /* mountpoint is mounted - check the file if it's local */ 1403 if (rb_uri_is_local (mountpoint)) { 1404 rhythmdb_add_to_stat_list (db, 1405 rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION), 1406 entry, 1407 NULL, 1408 RHYTHMDB_ENTRY_TYPE_IGNORE, 1409 RHYTHMDB_ENTRY_TYPE_IMPORT_ERROR); 1410 } else { 1411 rhythmdb_entry_update_availability (entry, RHYTHMDB_ENTRY_AVAIL_MOUNTED); 1412 } 1413 } else { 1414 /* mountpoint is not mounted */ 1415 rhythmdb_entry_update_availability (entry, RHYTHMDB_ENTRY_AVAIL_UNMOUNTED); 1416 1417 if (rb_string_list_contains (db->priv->mount_list, mountpoint) == FALSE) { 1418 db->priv->mount_list = g_list_prepend (db->priv->mount_list, g_strdup (mountpoint)); 1419 } 1420 } 1421 } 1422 g_mutex_unlock (&db->priv->stat_mutex); 1423 } 1424 1425 g_assert ((entry->flags & RHYTHMDB_ENTRY_INSERTED) == 0); 1426 entry->flags |= RHYTHMDB_ENTRY_INSERTED; 1427 1428 rhythmdb_entry_ref (entry); 1429 db->priv->added_entries_to_emit = g_list_prepend (db->priv->added_entries_to_emit, entry); 1430 1431 return TRUE; 1432 } 1433 1434 static gboolean 1435 process_deleted_entries_cb (RhythmDBEntry *entry, 1436 GThread *thread, 1437 RhythmDB *db) 1438 { 1439 if (thread != g_thread_self ()) 1440 return FALSE; 1441 1442 rhythmdb_entry_ref (entry); 1443 g_assert ((entry->flags & RHYTHMDB_ENTRY_INSERTED) != 0); 1444 entry->flags &= ~(RHYTHMDB_ENTRY_INSERTED); 1445 db->priv->deleted_entries_to_emit = g_list_prepend (db->priv->deleted_entries_to_emit, entry); 1446 1447 return TRUE; 1448 } 1449 1450 static gboolean 1451 process_changed_entries_cb (RhythmDBEntry *entry, 1452 GSList *changes, 1453 RhythmDB *db) 1454 { 1455 GSList *existing; 1456 if (db->priv->changed_entries_to_emit == NULL) { 1457 /* the value destroy function is just g_slist_free because we 1458 * steal the actual change structures to build the value array. 1459 */ 1460 db->priv->changed_entries_to_emit = g_hash_table_new_full (NULL, 1461 NULL, 1462 (GDestroyNotify) rhythmdb_entry_unref, 1463 (GDestroyNotify) g_slist_free); 1464 } 1465 1466 /* if the entry is already in the change map from a previous commit, add the 1467 * new changes to the end of the existing list. 1468 */ 1469 existing = g_hash_table_lookup (db->priv->changed_entries_to_emit, entry); 1470 if (existing != NULL) { 1471 changes = g_slist_concat (existing, changes); 1472 1473 /* steal the hash entry so it doesn't free the changes; also means we 1474 * don't need to add a reference on the entry. 1475 */ 1476 g_hash_table_steal (db->priv->changed_entries_to_emit, entry); 1477 } else { 1478 rhythmdb_entry_ref (entry); 1479 } 1480 1481 g_hash_table_insert (db->priv->changed_entries_to_emit, entry, changes); 1482 return TRUE; 1483 } 1484 1485 static void 1486 sync_entry_changed (RhythmDBEntry *entry, 1487 GSList *changes, 1488 RhythmDB *db) 1489 { 1490 GSList *t; 1491 1492 for (t = changes; t; t = t->next) { 1493 RBMetaDataField field; 1494 RhythmDBEntryChange *change = t->data; 1495 1496 if (metadata_field_from_prop (change->prop, &field)) { 1497 RhythmDBAction *action; 1498 1499 if (!rhythmdb_entry_can_sync_metadata (entry)) { 1500 g_warning ("trying to sync properties of non-editable file"); 1501 break; 1502 } 1503 1504 action = g_slice_new0 (RhythmDBAction); 1505 action->type = RHYTHMDB_ACTION_SYNC; 1506 action->uri = rb_refstring_ref (entry->location); 1507 action->data.changes = copy_entry_changes (changes); 1508 g_async_queue_push (db->priv->action_queue, action); 1509 break; 1510 } 1511 } 1512 } 1513 1514 1515 static void 1516 rhythmdb_commit_internal (RhythmDB *db, 1517 gboolean sync_changes, 1518 GThread *thread) 1519 { 1520 g_mutex_lock (&db->priv->change_mutex); 1521 1522 if (sync_changes) { 1523 g_hash_table_foreach (db->priv->changed_entries, (GHFunc) sync_entry_changed, db); 1524 } 1525 1526 /* update the sets of entry changed/added/deleted signals to emit */ 1527 g_hash_table_foreach_remove (db->priv->changed_entries, (GHRFunc) process_changed_entries_cb, db); 1528 g_hash_table_foreach_remove (db->priv->added_entries, (GHRFunc) process_added_entries_cb, db); 1529 g_hash_table_foreach_remove (db->priv->deleted_entries, (GHRFunc) process_deleted_entries_cb, db); 1530 1531 /* if there are some signals to emit, add a new idle callback if required */ 1532 if (db->priv->added_entries_to_emit || db->priv->deleted_entries_to_emit || db->priv->changed_entries_to_emit) { 1533 if (db->priv->emit_entry_signals_id == 0) 1534 db->priv->emit_entry_signals_id = g_idle_add ((GSourceFunc) rhythmdb_emit_entry_signals_idle, db); 1535 } 1536 1537 g_mutex_unlock (&db->priv->change_mutex); 1538 } 1539 1540 typedef struct { 1541 RhythmDB *db; 1542 gboolean sync; 1543 GThread *thread; 1544 } RhythmDBTimeoutCommitData; 1545 1546 static gboolean 1547 timeout_rhythmdb_commit (RhythmDBTimeoutCommitData *data) 1548 { 1549 rhythmdb_commit_internal (data->db, data->sync, data->thread); 1550 g_object_unref (data->db); 1551 g_free (data); 1552 return FALSE; 1553 } 1554 1555 static void 1556 rhythmdb_add_timeout_commit (RhythmDB *db, 1557 gboolean sync) 1558 { 1559 RhythmDBTimeoutCommitData *data; 1560 1561 g_assert (rb_is_main_thread ()); 1562 1563 data = g_new0 (RhythmDBTimeoutCommitData, 1); 1564 data->db = g_object_ref (db); 1565 data->sync = sync; 1566 data->thread = g_thread_self (); 1567 g_timeout_add (100, (GSourceFunc)timeout_rhythmdb_commit, data); 1568 } 1569 1570 /** 1571 * rhythmdb_commit: 1572 * @db: a #RhythmDB. 1573 * 1574 * Apply all database changes, and send notification of changes and new entries. 1575 * This needs to be called after any changes have been made, such as a group of 1576 * rhythmdb_entry_set() calls, or a new entry has been added. 1577 */ 1578 void 1579 rhythmdb_commit (RhythmDB *db) 1580 { 1581 rhythmdb_commit_internal (db, TRUE, g_thread_self ()); 1582 } 1583 1584 /** 1585 * rhythmdb_error_quark: 1586 * 1587 * Returns the #GQuark used for #RhythmDBError information 1588 * 1589 * Return value: error quark 1590 */ 1591 GQuark 1592 rhythmdb_error_quark (void) 1593 { 1594 static GQuark quark; 1595 if (!quark) 1596 quark = g_quark_from_static_string ("rhythmdb_error"); 1597 1598 return quark; 1599 } 1600 1601 /* structure alignment magic, stolen from glib */ 1602 #define STRUCT_ALIGNMENT (2 * sizeof (gsize)) 1603 #define ALIGN_STRUCT(offset) \ 1604 ((offset + (STRUCT_ALIGNMENT - 1)) & -STRUCT_ALIGNMENT) 1605 1606 /** 1607 * rhythmdb_entry_allocate: 1608 * @db: a #RhythmDB. 1609 * @type: type of entry to allocate 1610 * 1611 * Allocate and initialise memory for a new #RhythmDBEntry of the type @type. 1612 * The entry's initial properties needs to be set with rhythmdb_entry_set (), 1613 * the entry added to the database with rhythmdb_entry_insert(), and committed with 1614 * rhythmdb_commit(). 1615 * 1616 * This should only be used by RhythmDB itself, or a backend (such as rhythmdb-tree). 1617 * 1618 * Returns: the newly allocated #RhythmDBEntry 1619 */ 1620 RhythmDBEntry * 1621 rhythmdb_entry_allocate (RhythmDB *db, 1622 RhythmDBEntryType *type) 1623 { 1624 RhythmDBEntry *ret; 1625 guint type_data_size = 0; 1626 gsize size = sizeof (RhythmDBEntry); 1627 1628 g_object_get (type, "type-data-size", &type_data_size, NULL); 1629 if (type_data_size > 0) { 1630 size = ALIGN_STRUCT (sizeof (RhythmDBEntry)) + type_data_size; 1631 } 1632 ret = g_malloc0 (size); 1633 ret->id = (guint) g_atomic_int_add (&db->priv->next_entry_id, 1); 1634 1635 ret->type = type; 1636 ret->title = rb_refstring_ref (db->priv->empty_string); 1637 ret->genre = rb_refstring_ref (db->priv->empty_string); 1638 ret->artist = rb_refstring_ref (db->priv->empty_string); 1639 ret->album = rb_refstring_ref (db->priv->empty_string); 1640 ret->comment = rb_refstring_ref (db->priv->empty_string); 1641 ret->album_artist = rb_refstring_ref (db->priv->empty_string); 1642 ret->musicbrainz_trackid = rb_refstring_ref (db->priv->empty_string); 1643 ret->musicbrainz_artistid = rb_refstring_ref (db->priv->empty_string); 1644 ret->musicbrainz_albumid = rb_refstring_ref (db->priv->empty_string); 1645 ret->musicbrainz_albumartistid = rb_refstring_ref (db->priv->empty_string); 1646 ret->artist_sortname = rb_refstring_ref (db->priv->empty_string); 1647 ret->album_sortname = rb_refstring_ref (db->priv->empty_string); 1648 ret->album_artist_sortname = rb_refstring_ref (db->priv->empty_string); 1649 ret->media_type = rb_refstring_ref (db->priv->octet_stream_str); 1650 1651 ret->flags |= RHYTHMDB_ENTRY_LAST_PLAYED_DIRTY | 1652 RHYTHMDB_ENTRY_FIRST_SEEN_DIRTY | 1653 RHYTHMDB_ENTRY_LAST_SEEN_DIRTY; 1654 1655 /* The refcount is initially 0, we want to set it to 1 */ 1656 ret->refcount = 1; 1657 1658 rhythmdb_entry_created (ret); 1659 1660 return ret; 1661 } 1662 1663 /** 1664 * rhythmdb_entry_get_type_data: 1665 * @entry: a #RhythmDBEntry 1666 * @expected_size: expected size of the type-specific data. 1667 * 1668 * Retrieves a pointer to the entry's type-specific data, checking that 1669 * the size of the data structure matches what is expected. 1670 * Callers should use the RHYTHMDB_ENTRY_GET_TYPE_DATA macro for 1671 * a slightly more friendly interface to this functionality. 1672 * 1673 * Return value: (transfer none): type-specific data pointer 1674 */ 1675 gpointer 1676 rhythmdb_entry_get_type_data (RhythmDBEntry *entry, 1677 guint expected_size) 1678 { 1679 g_return_val_if_fail (entry != NULL, NULL); 1680 int type_data_size = 0; 1681 gsize offset; 1682 1683 g_object_get (entry->type, "type-data-size", &type_data_size, NULL); 1684 1685 g_assert (expected_size == type_data_size); 1686 offset = ALIGN_STRUCT (sizeof (RhythmDBEntry)); 1687 1688 return (gpointer) (((guint8 *)entry) + offset); 1689 } 1690 1691 /** 1692 * rhythmdb_entry_insert: 1693 * @db: a #RhythmDB. 1694 * @entry: the entry to insert. 1695 * 1696 * Inserts a newly-created entry into the database. 1697 * 1698 * Note that you must call rhythmdb_commit() at some point after invoking 1699 * this function. 1700 */ 1701 void 1702 rhythmdb_entry_insert (RhythmDB *db, 1703 RhythmDBEntry *entry) 1704 { 1705 g_return_if_fail (RHYTHMDB_IS (db)); 1706 g_return_if_fail (entry != NULL); 1707 1708 g_assert ((entry->flags & RHYTHMDB_ENTRY_INSERTED) == 0); 1709 g_return_if_fail (entry->location != NULL); 1710 1711 /* ref the entry before adding to hash, it is unreffed when removed */ 1712 rhythmdb_entry_ref (entry); 1713 g_mutex_lock (&db->priv->change_mutex); 1714 g_hash_table_insert (db->priv->added_entries, entry, g_thread_self ()); 1715 g_mutex_unlock (&db->priv->change_mutex); 1716 } 1717 1718 /** 1719 * rhythmdb_entry_new: 1720 * @db: a #RhythmDB. 1721 * @type: type of entry to create 1722 * @uri: the location of the entry, this be unique amongst all entries. 1723 * 1724 * Creates a new entry of type @type and location @uri, and inserts 1725 * it into the database. You must call rhythmdb_commit() at some point 1726 * after invoking this function. 1727 * 1728 * This may return NULL if entry creation fails. This can occur if there is 1729 * already an entry with the given uri. 1730 * 1731 * Returns: the newly created #RhythmDBEntry 1732 */ 1733 RhythmDBEntry * 1734 rhythmdb_entry_new (RhythmDB *db, 1735 RhythmDBEntryType *type, 1736 const char *uri) 1737 { 1738 RhythmDBEntry *ret; 1739 RhythmDBClass *klass = RHYTHMDB_GET_CLASS (db); 1740 1741 ret = rhythmdb_entry_lookup_by_location (db, uri); 1742 if (ret) { 1743 g_warning ("attempting to create entry that already exists: %s", uri); 1744 return NULL; 1745 } 1746 1747 ret = rhythmdb_entry_allocate (db, type); 1748 ret->location = rb_refstring_new (uri); 1749 klass->impl_entry_new (db, ret); 1750 rb_debug ("emitting entry added"); 1751 rhythmdb_entry_insert (db, ret); 1752 1753 return ret; 1754 } 1755 1756 /** 1757 * rhythmdb_entry_example_new: 1758 * @db: a #RhythmDB. 1759 * @type: type of entry to create 1760 * @uri: the location of the entry, this be unique amongst all entries. 1761 * 1762 * Creates a new sample entry of type @type and location @uri, it does not insert 1763 * it into the database. This is indended for use as a example entry. 1764 * 1765 * This may return NULL if entry creation fails. 1766 * 1767 * Returns: the newly created #RhythmDBEntry 1768 */ 1769 RhythmDBEntry * 1770 rhythmdb_entry_example_new (RhythmDB *db, 1771 RhythmDBEntryType *type, 1772 const char *uri) 1773 { 1774 RhythmDBEntry *ret; 1775 1776 ret = rhythmdb_entry_allocate (db, type); 1777 if (uri) 1778 ret->location = rb_refstring_new (uri); 1779 1780 if (type == RHYTHMDB_ENTRY_TYPE_SONG) { 1781 rb_refstring_unref (ret->artist); 1782 /* Translators: this is an example artist name. It should 1783 * not be translated literally, but could be replaced with 1784 * a local artist name if desired. Ensure the album name 1785 * and song title are also replaced in this case. 1786 */ 1787 ret->artist = rb_refstring_new (_("The Beatles")); 1788 rb_refstring_unref (ret->album); 1789 /* Translators: this is an example album name. If the 1790 * example artist name is localised, this should be replaced 1791 * with the name of an album by that artist. 1792 */ 1793 ret->album = rb_refstring_new (_("Help!")); 1794 rb_refstring_unref (ret->title); 1795 /* Translators: this is an example song title. If the example 1796 * artist and album names are localised, this should be replaced 1797 * with the name of the seventh song from the localised album. 1798 */ 1799 ret->title = rb_refstring_new (_("Ticket To Ride")); 1800 ret->tracknum = 7; 1801 } else { 1802 } 1803 1804 return ret; 1805 } 1806 1807 /** 1808 * rhythmdb_entry_ref: 1809 * @entry: a #RhythmDBEntry. 1810 * 1811 * Increase the reference count of the entry. 1812 * 1813 * Returns: the entry 1814 */ 1815 RhythmDBEntry * 1816 rhythmdb_entry_ref (RhythmDBEntry *entry) 1817 { 1818 g_return_val_if_fail (entry != NULL, NULL); 1819 g_return_val_if_fail (entry->refcount > 0, NULL); 1820 1821 g_atomic_int_inc (&entry->refcount); 1822 1823 return entry; 1824 } 1825 1826 static void 1827 rhythmdb_entry_finalize (RhythmDBEntry *entry) 1828 { 1829 rhythmdb_entry_pre_destroy (entry); 1830 1831 rb_refstring_unref (entry->location); 1832 rb_refstring_unref (entry->playback_error); 1833 rb_refstring_unref (entry->title); 1834 rb_refstring_unref (entry->genre); 1835 rb_refstring_unref (entry->artist); 1836 rb_refstring_unref (entry->album); 1837 rb_refstring_unref (entry->comment); 1838 rb_refstring_unref (entry->musicbrainz_trackid); 1839 rb_refstring_unref (entry->musicbrainz_artistid); 1840 rb_refstring_unref (entry->musicbrainz_albumid); 1841 rb_refstring_unref (entry->musicbrainz_albumartistid); 1842 rb_refstring_unref (entry->artist_sortname); 1843 rb_refstring_unref (entry->album_sortname); 1844 rb_refstring_unref (entry->media_type); 1845 1846 g_free (entry); 1847 } 1848 1849 /** 1850 * rhythmdb_entry_unref: 1851 * @entry: a #RhythmDBEntry. 1852 * 1853 * Decrease the reference count of the entry, and destroys it if there are 1854 * no references left. 1855 */ 1856 void 1857 rhythmdb_entry_unref (RhythmDBEntry *entry) 1858 { 1859 gboolean is_zero; 1860 1861 g_return_if_fail (entry != NULL); 1862 g_return_if_fail (entry->refcount > 0); 1863 1864 is_zero = g_atomic_int_dec_and_test (&entry->refcount); 1865 if (G_UNLIKELY (is_zero)) { 1866 rhythmdb_entry_finalize (entry); 1867 } 1868 } 1869 1870 static void 1871 set_metadata_string_with_default (RhythmDB *db, 1872 RBMetaData *metadata, 1873 RhythmDBEntry *entry, 1874 RBMetaDataField field, 1875 RhythmDBPropType prop, 1876 const char *default_value) 1877 { 1878 GValue val = {0, }; 1879 1880 if (!(rb_metadata_get (metadata, 1881 field, 1882 &val))) { 1883 g_value_init (&val, G_TYPE_STRING); 1884 g_value_set_static_string (&val, default_value); 1885 } else { 1886 const gchar *str = g_value_get_string (&val); 1887 if (str == NULL || str[0] == '\0') 1888 g_value_set_static_string (&val, default_value); 1889 } 1890 rhythmdb_entry_set_internal (db, entry, TRUE, prop, &val); 1891 g_value_unset (&val); 1892 } 1893 1894 static void 1895 set_props_from_metadata (RhythmDB *db, 1896 RhythmDBEntry *entry, 1897 GFileInfo *fileinfo, 1898 RBMetaData *metadata) 1899 { 1900 const char *media_type; 1901 GValue val = {0,}; 1902 1903 g_value_init (&val, G_TYPE_STRING); 1904 media_type = rb_metadata_get_media_type (metadata); 1905 if (media_type) { 1906 g_value_set_string (&val, media_type); 1907 rhythmdb_entry_set_internal (db, entry, TRUE, 1908 RHYTHMDB_PROP_MEDIA_TYPE, &val); 1909 } 1910 g_value_unset (&val); 1911 1912 /* track number */ 1913 if (!rb_metadata_get (metadata, 1914 RB_METADATA_FIELD_TRACK_NUMBER, 1915 &val)) { 1916 g_value_init (&val, G_TYPE_ULONG); 1917 g_value_set_ulong (&val, 0); 1918 } 1919 rhythmdb_entry_set_internal (db, entry, TRUE, 1920 RHYTHMDB_PROP_TRACK_NUMBER, &val); 1921 g_value_unset (&val); 1922 1923 /* disc number */ 1924 if (!rb_metadata_get (metadata, 1925 RB_METADATA_FIELD_DISC_NUMBER, 1926 &val)) { 1927 g_value_init (&val, G_TYPE_ULONG); 1928 g_value_set_ulong (&val, 0); 1929 } 1930 rhythmdb_entry_set_internal (db, entry, TRUE, 1931 RHYTHMDB_PROP_DISC_NUMBER, &val); 1932 g_value_unset (&val); 1933 1934 /* duration */ 1935 if (rb_metadata_get (metadata, 1936 RB_METADATA_FIELD_DURATION, 1937 &val)) { 1938 rhythmdb_entry_set_internal (db, entry, TRUE, 1939 RHYTHMDB_PROP_DURATION, &val); 1940 g_value_unset (&val); 1941 } 1942 1943 /* bitrate */ 1944 if (rb_metadata_get (metadata, 1945 RB_METADATA_FIELD_BITRATE, 1946 &val)) { 1947 rhythmdb_entry_set_internal (db, entry, TRUE, 1948 RHYTHMDB_PROP_BITRATE, &val); 1949 g_value_unset (&val); 1950 } 1951 1952 /* date */ 1953 if (rb_metadata_get (metadata, 1954 RB_METADATA_FIELD_DATE, 1955 &val)) { 1956 rhythmdb_entry_set_internal (db, entry, TRUE, 1957 RHYTHMDB_PROP_DATE, &val); 1958 g_value_unset (&val); 1959 } 1960 1961 /* musicbrainz trackid */ 1962 set_metadata_string_with_default (db, metadata, entry, 1963 RB_METADATA_FIELD_MUSICBRAINZ_TRACKID, 1964 RHYTHMDB_PROP_MUSICBRAINZ_TRACKID, 1965 ""); 1966 1967 /* musicbrainz artistid */ 1968 set_metadata_string_with_default (db, metadata, entry, 1969 RB_METADATA_FIELD_MUSICBRAINZ_ARTISTID, 1970 RHYTHMDB_PROP_MUSICBRAINZ_ARTISTID, 1971 ""); 1972 1973 /* musicbrainz albumid */ 1974 set_metadata_string_with_default (db, metadata, entry, 1975 RB_METADATA_FIELD_MUSICBRAINZ_ALBUMID, 1976 RHYTHMDB_PROP_MUSICBRAINZ_ALBUMID, 1977 ""); 1978 1979 /* musicbrainz albumartistid */ 1980 set_metadata_string_with_default (db, metadata, entry, 1981 RB_METADATA_FIELD_MUSICBRAINZ_ALBUMARTISTID, 1982 RHYTHMDB_PROP_MUSICBRAINZ_ALBUMARTISTID, 1983 ""); 1984 1985 /* filesize */ 1986 g_value_init (&val, G_TYPE_UINT64); 1987 g_value_set_uint64 (&val, g_file_info_get_attribute_uint64 (fileinfo, G_FILE_ATTRIBUTE_STANDARD_SIZE)); 1988 rhythmdb_entry_set_internal (db, entry, TRUE, RHYTHMDB_PROP_FILE_SIZE, &val); 1989 g_value_unset (&val); 1990 1991 /* title */ 1992 if (!rb_metadata_get (metadata, 1993 RB_METADATA_FIELD_TITLE, 1994 &val) || g_value_get_string (&val)[0] == '\0') { 1995 const char *fname; 1996 fname = g_file_info_get_display_name (fileinfo); 1997 if (G_VALUE_HOLDS_STRING (&val)) 1998 g_value_reset (&val); 1999 else 2000 g_value_init (&val, G_TYPE_STRING); 2001 g_value_set_string (&val, fname); 2002 } 2003 rhythmdb_entry_set_internal (db, entry, TRUE, RHYTHMDB_PROP_TITLE, &val); 2004 g_value_unset (&val); 2005 2006 /* genre */ 2007 set_metadata_string_with_default (db, metadata, entry, 2008 RB_METADATA_FIELD_GENRE, 2009 RHYTHMDB_PROP_GENRE, 2010 _("Unknown")); 2011 2012 /* artist */ 2013 set_metadata_string_with_default (db, metadata, entry, 2014 RB_METADATA_FIELD_ARTIST, 2015 RHYTHMDB_PROP_ARTIST, 2016 _("Unknown")); 2017 2018 /* beats per minute */ 2019 if (rb_metadata_get (metadata, 2020 RB_METADATA_FIELD_BPM, 2021 &val)) { 2022 rhythmdb_entry_set_internal (db, entry, TRUE, 2023 RHYTHMDB_PROP_BPM, &val); 2024 g_value_unset (&val); 2025 } 2026 2027 /* album */ 2028 set_metadata_string_with_default (db, metadata, entry, 2029 RB_METADATA_FIELD_ALBUM, 2030 RHYTHMDB_PROP_ALBUM, 2031 _("Unknown")); 2032 /* artist sortname */ 2033 set_metadata_string_with_default (db, metadata, entry, 2034 RB_METADATA_FIELD_ARTIST_SORTNAME, 2035 RHYTHMDB_PROP_ARTIST_SORTNAME, 2036 ""); 2037 2038 /* album sortname */ 2039 set_metadata_string_with_default (db, metadata, entry, 2040 RB_METADATA_FIELD_ALBUM_SORTNAME, 2041 RHYTHMDB_PROP_ALBUM_SORTNAME, 2042 ""); 2043 2044 /* comment */ 2045 set_metadata_string_with_default (db, metadata, entry, 2046 RB_METADATA_FIELD_COMMENT, 2047 RHYTHMDB_PROP_COMMENT, 2048 ""); 2049 /* album artist */ 2050 set_metadata_string_with_default (db, metadata, entry, 2051 RB_METADATA_FIELD_ALBUM_ARTIST, 2052 RHYTHMDB_PROP_ALBUM_ARTIST, 2053 ""); 2054 2055 /* album artist sortname */ 2056 set_metadata_string_with_default (db, metadata, entry, 2057 RB_METADATA_FIELD_ALBUM_ARTIST_SORTNAME, 2058 RHYTHMDB_PROP_ALBUM_ARTIST_SORTNAME, 2059 ""); 2060 } 2061 2062 static void 2063 rhythmdb_process_stat_event (RhythmDB *db, 2064 RhythmDBEvent *event) 2065 { 2066 RhythmDBEntry *entry; 2067 RhythmDBAction *action; 2068 GFileType file_type; 2069 2070 if (event->entry != NULL) { 2071 entry = event->entry; 2072 } else { 2073 entry = rhythmdb_entry_lookup_by_location_refstring (db, event->real_uri); 2074 } 2075 2076 /* handle errors: 2077 * - if a non-ignore entry exists, process ghostliness (hide/delete) 2078 * - otherwise, create an import error entry? hmm. 2079 */ 2080 if (event->error) { 2081 if (entry != NULL) { 2082 rb_debug ("error accessing %s: %s", 2083 rb_refstring_get (event->real_uri), 2084 event->error->message); 2085 rhythmdb_entry_update_availability (entry, RHYTHMDB_ENTRY_AVAIL_NOT_FOUND); 2086 rhythmdb_commit (db); 2087 } 2088 return; 2089 } 2090 2091 g_assert (event->file_info != NULL); 2092 2093 /* figure out what to do based on the file type */ 2094 file_type = g_file_info_get_attribute_uint32 (event->file_info, 2095 G_FILE_ATTRIBUTE_STANDARD_TYPE); 2096 switch (file_type) { 2097 case G_FILE_TYPE_UNKNOWN: 2098 case G_FILE_TYPE_REGULAR: 2099 if (entry != NULL) { 2100 guint64 new_mtime; 2101 guint64 new_size; 2102 2103 /* update the existing entry, as long as the entry type matches */ 2104 if ((event->entry_type != NULL) && 2105 (entry->type != event->entry_type) && 2106 (entry->type != event->ignore_type) && 2107 (entry->type != event->error_type)) { 2108 if (event->entry_type == RHYTHMDB_ENTRY_TYPE_SONG && 2109 entry->type == RHYTHMDB_ENTRY_TYPE_PODCAST_POST) { 2110 rb_debug ("Ignoring stat event for '%s', it's already loaded as a podcast", 2111 rb_refstring_get (event->real_uri)); 2112 break; 2113 } 2114 g_warning ("attempt to use location %s in multiple entry types (%s and %s)", 2115 rb_refstring_get (event->real_uri), 2116 rhythmdb_entry_type_get_name (event->entry_type), 2117 rhythmdb_entry_type_get_name (entry->type)); 2118 } 2119 2120 if (entry->type == event->ignore_type) 2121 rb_debug ("ignoring %p", entry); 2122 2123 rhythmdb_entry_update_availability (entry, RHYTHMDB_ENTRY_AVAIL_CHECKED); 2124 2125 /* compare modification time and size to the values in the database. 2126 * if either has changed, we'll re-read the file. 2127 */ 2128 new_mtime = g_file_info_get_attribute_uint64 (event->file_info, G_FILE_ATTRIBUTE_TIME_MODIFIED); 2129 new_size = g_file_info_get_attribute_uint64 (event->file_info, G_FILE_ATTRIBUTE_STANDARD_SIZE); 2130 if (entry->mtime == new_mtime && (new_size == 0 || entry->file_size == new_size)) { 2131 rb_debug ("not modified: %s", rb_refstring_get (event->real_uri)); 2132 } else { 2133 rb_debug ("changed: %s", rb_refstring_get (event->real_uri)); 2134 action = g_slice_new0 (RhythmDBAction); 2135 action->type = RHYTHMDB_ACTION_LOAD; 2136 action->uri = rb_refstring_ref (event->real_uri); 2137 action->data.types.entry_type = event->entry_type; 2138 action->data.types.ignore_type = event->ignore_type; 2139 action->data.types.error_type = event->error_type; 2140 g_async_queue_push (db->priv->action_queue, action); 2141 } 2142 } else { 2143 /* push a LOAD action */ 2144 action = g_slice_new0 (RhythmDBAction); 2145 action->type = RHYTHMDB_ACTION_LOAD; 2146 action->uri = rb_refstring_ref (event->real_uri); 2147 action->data.types.entry_type = event->entry_type; 2148 action->data.types.ignore_type = event->ignore_type; 2149 action->data.types.error_type = event->error_type; 2150 rb_debug ("queuing a RHYTHMDB_ACTION_LOAD: %s", rb_refstring_get (action->uri)); 2151 g_async_queue_push (db->priv->action_queue, action); 2152 } 2153 break; 2154 2155 case G_FILE_TYPE_DIRECTORY: 2156 rb_debug ("processing directory %s", rb_refstring_get (event->real_uri)); 2157 /* push an ENUM_DIR action */ 2158 action = g_slice_new0 (RhythmDBAction); 2159 action->type = RHYTHMDB_ACTION_ENUM_DIR; 2160 action->uri = rb_refstring_ref (event->real_uri); 2161 action->data.types.entry_type = event->entry_type; 2162 action->data.types.ignore_type = event->ignore_type; 2163 action->data.types.error_type = event->error_type; 2164 rb_debug ("queuing a RHYTHMDB_ACTION_ENUM_DIR: %s", rb_refstring_get (action->uri)); 2165 g_async_queue_push (db->priv->action_queue, action); 2166 break; 2167 2168 case G_FILE_TYPE_SYMBOLIC_LINK: 2169 case G_FILE_TYPE_SHORTCUT: 2170 /* this shouldn't happen, but maybe we should handle it anyway? */ 2171 rb_debug ("ignoring stat results for %s: is link", rb_refstring_get (event->real_uri)); 2172 break; 2173 2174 case G_FILE_TYPE_SPECIAL: 2175 case G_FILE_TYPE_MOUNTABLE: /* hmm. */ 2176 rb_debug ("ignoring stat results for %s: is special", rb_refstring_get (event->real_uri)); 2177 break; 2178 } 2179 2180 rhythmdb_commit (db); 2181 } 2182 2183 typedef struct 2184 { 2185 RhythmDB *db; 2186 char *uri; 2187 char *msg; 2188 } RhythmDBLoadErrorData; 2189 2190 static void 2191 rhythmdb_add_import_error_entry (RhythmDB *db, 2192 RhythmDBEvent *event, 2193 RhythmDBEntryType *error_entry_type) 2194 { 2195 RhythmDBEntry *entry; 2196 GValue value = {0,}; 2197 2198 if (error_entry_type == NULL) { 2199 /* we don't have an error entry type, so we can't add an import error */ 2200 return; 2201 } 2202 rb_debug ("adding import error type %s for %s: %s", 2203 rhythmdb_entry_type_get_name (error_entry_type), 2204 rb_refstring_get (event->real_uri), 2205 event->error ? event->error->message : "<no error>"); 2206 2207 entry = rhythmdb_entry_lookup_by_location_refstring (db, event->real_uri); 2208 if (entry) { 2209 RhythmDBEntryType *entry_type = rhythmdb_entry_get_entry_type (entry); 2210 if (entry_type != event->error_type && 2211 entry_type != event->ignore_type) { 2212 /* FIXME we've successfully read this file before.. so what should we do? */ 2213 rb_debug ("%s already exists in the library.. ignoring import error?", rb_refstring_get (event->real_uri)); 2214 return; 2215 } 2216 2217 if (entry_type != error_entry_type) { 2218 /* delete the existing entry, then create a new one below */ 2219 rhythmdb_entry_delete (db, entry); 2220 entry = NULL; 2221 } else if (error_entry_type == event->error_type && event->error) { 2222 /* we've already got an error for this file, so just update it */ 2223 g_value_init (&value, G_TYPE_STRING); 2224 g_value_set_string (&value, event->error->message); 2225 rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_PLAYBACK_ERROR, &value); 2226 g_value_unset (&value); 2227 } else { 2228 /* no need to update the ignored file entry */ 2229 } 2230 2231 if (entry && event->file_info) { 2232 /* mtime */ 2233 guint64 new_mtime = g_file_info_get_attribute_uint64 (event->file_info, G_FILE_ATTRIBUTE_TIME_MODIFIED); 2234 g_value_init (&value, G_TYPE_ULONG); 2235 g_value_set_ulong (&value, new_mtime); /* hmm, cast */ 2236 rhythmdb_entry_set(db, entry, RHYTHMDB_PROP_MTIME, &value); 2237 g_value_unset (&value); 2238 } 2239 2240 rhythmdb_add_timeout_commit (db, FALSE); 2241 } 2242 2243 if (entry == NULL) { 2244 /* create a new import error or ignore entry */ 2245 entry = rhythmdb_entry_new (db, error_entry_type, rb_refstring_get (event->real_uri)); 2246 if (entry == NULL) 2247 return; 2248 2249 /* if we have missing plugin details, store them in the 2250 * comment field so we can collect them later, and set a 2251 * suitable error message 2252 */ 2253 if (event->metadata != NULL && rb_metadata_has_missing_plugins (event->metadata)) { 2254 char **missing_plugins; 2255 char **plugin_descriptions; 2256 char *comment; 2257 char *list; 2258 const char *msg; 2259 2260 /* Translators: the parameter here is a list of GStreamer plugins. 2261 * The plugin names are already translated. 2262 */ 2263 msg = _("Additional GStreamer plugins are required to play this file: %s"); 2264 2265 if (rb_metadata_has_audio (event->metadata) == TRUE && 2266 rb_metadata_has_video (event->metadata) == FALSE && 2267 rb_metadata_has_missing_plugins (event->metadata) == TRUE) { 2268 rb_metadata_get_missing_plugins (event->metadata, &missing_plugins, &plugin_descriptions); 2269 comment = g_strjoinv ("\n", missing_plugins); 2270 rb_debug ("storing missing plugin details: %s", comment); 2271 2272 g_value_init (&value, G_TYPE_STRING); 2273 g_value_take_string (&value, comment); 2274 rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_COMMENT, &value); 2275 g_value_unset (&value); 2276 2277 g_value_init (&value, G_TYPE_STRING); 2278 list = g_strjoinv (", ", plugin_descriptions); 2279 g_value_take_string (&value, g_strdup_printf (msg, list)); 2280 g_free (list); 2281 rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_PLAYBACK_ERROR, &value); 2282 g_value_unset (&value); 2283 2284 g_strfreev (missing_plugins); 2285 g_strfreev (plugin_descriptions); 2286 2287 } else if (rb_metadata_has_missing_plugins (event->metadata)) { 2288 rb_debug ("ignoring missing plugins for non-audio file"); 2289 } 2290 } else if (error_entry_type == event->error_type && event->error && event->error->message) { 2291 g_value_init (&value, G_TYPE_STRING); 2292 if (g_utf8_validate (event->error->message, -1, NULL)) 2293 g_value_set_string (&value, event->error->message); 2294 else 2295 g_value_set_static_string (&value, _("invalid unicode in error message")); 2296 rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_PLAYBACK_ERROR, &value); 2297 g_value_unset (&value); 2298 } 2299 2300 /* mtime */ 2301 if (event->file_info) { 2302 guint64 new_mtime = g_file_info_get_attribute_uint64 (event->file_info, G_FILE_ATTRIBUTE_TIME_MODIFIED); 2303 g_value_init (&value, G_TYPE_ULONG); 2304 g_value_set_ulong (&value, new_mtime); /* hmm, cast */ 2305 rhythmdb_entry_set(db, entry, RHYTHMDB_PROP_MTIME, &value); 2306 g_value_unset (&value); 2307 } 2308 2309 /* record the mount point so we can delete entries for unmounted volumes */ 2310 rhythmdb_entry_set_mount_point (db, entry, rb_refstring_get (event->real_uri)); 2311 2312 rhythmdb_entry_set_visibility (db, entry, TRUE); 2313 2314 rhythmdb_add_timeout_commit (db, FALSE); 2315 } 2316 } 2317 2318 static gboolean 2319 rhythmdb_process_metadata_load (RhythmDB *db, RhythmDBEvent *event) 2320 { 2321 RhythmDBEntry *entry; 2322 GValue value = {0,}; 2323 GTimeVal time; 2324 gboolean monitor; 2325 2326 if (event->entry_type == NULL) 2327 event->entry_type = RHYTHMDB_ENTRY_TYPE_SONG; 2328 2329 if (event->metadata != NULL) { 2330 /* always ignore anything with video in it */ 2331 if (rb_metadata_has_video (event->metadata)) { 2332 rhythmdb_add_import_error_entry (db, event, event->ignore_type); 2333 return TRUE; 2334 } 2335 2336 /* if we identified the media type, we can ignore anything 2337 * that matches one of the media types we don't care about, 2338 * as well as anything that doesn't contain audio. 2339 */ 2340 const char *media_type = rb_metadata_get_media_type (event->metadata); 2341 if (media_type != NULL && media_type[0] != '\0') { 2342 if (rhythmdb_ignore_media_type (media_type) || 2343 rb_metadata_has_audio (event->metadata) == FALSE) { 2344 rhythmdb_add_import_error_entry (db, event, event->ignore_type); 2345 return TRUE; 2346 } 2347 } 2348 } 2349 2350 /* also ignore really small files we can't identify */ 2351 if (event->error && event->error->code == RB_METADATA_ERROR_UNRECOGNIZED) { 2352 guint64 file_size; 2353 2354 file_size = g_file_info_get_attribute_uint64 (event->file_info, 2355 G_FILE_ATTRIBUTE_STANDARD_SIZE); 2356 if (file_size == 0) { 2357 /* except for empty files */ 2358 g_clear_error (&event->error); 2359 g_set_error (&event->error, 2360 RB_METADATA_ERROR, 2361 RB_METADATA_ERROR_EMPTY_FILE, 2362 _("Empty file")); 2363 } else if (file_size < REALLY_SMALL_FILE_SIZE) { 2364 rhythmdb_add_import_error_entry (db, event, event->ignore_type); 2365 return TRUE; 2366 } 2367 } 2368 2369 if (event->error) { 2370 rhythmdb_add_import_error_entry (db, event, event->error_type); 2371 return TRUE; 2372 } 2373 2374 g_get_current_time (&time); 2375 2376 entry = rhythmdb_entry_lookup_by_location_refstring (db, event->real_uri); 2377 2378 if (entry != NULL) { 2379 RhythmDBEntryType *etype; 2380 etype = rhythmdb_entry_get_entry_type (entry); 2381 if (etype == event->error_type || etype == event->ignore_type) { 2382 /* switching from IGNORE/ERROR to SONG, recreate the entry */ 2383 rhythmdb_entry_delete (db, entry); 2384 rhythmdb_add_timeout_commit (db, FALSE); 2385 entry = NULL; 2386 } 2387 } 2388 2389 if (entry == NULL) { 2390 2391 entry = rhythmdb_entry_new (db, event->entry_type, rb_refstring_get (event->real_uri)); 2392 if (entry == NULL) { 2393 rb_debug ("entry already exists"); 2394 return TRUE; 2395 } 2396 2397 /* initialize the last played date to 0=never */ 2398 g_value_init (&value, G_TYPE_ULONG); 2399 g_value_set_ulong (&value, 0); 2400 rhythmdb_entry_set (db, entry, 2401 RHYTHMDB_PROP_LAST_PLAYED, &value); 2402 g_value_unset (&value); 2403 2404 /* initialize the rating */ 2405 g_value_init (&value, G_TYPE_DOUBLE); 2406 g_value_set_double (&value, 0); 2407 rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_RATING, &value); 2408 g_value_unset (&value); 2409 2410 /* first seen */ 2411 g_value_init (&value, G_TYPE_ULONG); 2412 g_value_set_ulong (&value, time.tv_sec); 2413 rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_FIRST_SEEN, &value); 2414 g_value_unset (&value); 2415 } 2416 2417 if ((event->entry_type != NULL) && (entry->type != event->entry_type)) { 2418 g_warning ("attempt to use same location in multiple entry types"); 2419 return TRUE; 2420 } 2421 2422 /* mtime */ 2423 if (event->file_info) { 2424 guint64 mtime; 2425 2426 mtime = g_file_info_get_attribute_uint64 (event->file_info, G_FILE_ATTRIBUTE_TIME_MODIFIED); 2427 2428 g_value_init (&value, G_TYPE_ULONG); 2429 g_value_set_ulong (&value, (gulong)mtime); 2430 rhythmdb_entry_set_internal (db, entry, TRUE, RHYTHMDB_PROP_MTIME, &value); 2431 g_value_unset (&value); 2432 } 2433 2434 if (event->entry_type != event->ignore_type && 2435 event->entry_type != event->error_type) { 2436 set_props_from_metadata (db, entry, event->file_info, event->metadata); 2437 } 2438 2439 rhythmdb_entry_update_availability (entry, RHYTHMDB_ENTRY_AVAIL_CHECKED); 2440 2441 /* Remember the mount point of the volume the song is on */ 2442 rhythmdb_entry_set_mount_point (db, entry, rb_refstring_get (event->real_uri)); 2443 2444 /* monitor the file for changes */ 2445 /* FIXME: watch for errors */ 2446 monitor = g_settings_get_boolean (db->priv->settings, "monitor-library"); 2447 if (monitor && event->entry_type == RHYTHMDB_ENTRY_TYPE_SONG) 2448 rhythmdb_monitor_uri_path (db, rb_refstring_get (entry->location), NULL); 2449 2450 rhythmdb_commit_internal (db, FALSE, g_thread_self ()); 2451 2452 return TRUE; 2453 } 2454 2455 static void 2456 rhythmdb_process_queued_entry_set_event (RhythmDB *db, 2457 RhythmDBEvent *event) 2458 { 2459 rhythmdb_entry_set_internal (db, event->entry, 2460 event->signal_change, 2461 event->change.prop, 2462 &event->change.new); 2463 /* Don't run rhythmdb_commit right now in case there 2464 * we can run a single commit for several queued 2465 * entry_set 2466 */ 2467 rhythmdb_add_timeout_commit (db, TRUE); 2468 } 2469 2470 static void 2471 rhythmdb_process_one_event (RhythmDBEvent *event, RhythmDB *db) 2472 { 2473 gboolean free = TRUE; 2474 2475 /* if the database is read-only, we can't process those events 2476 * since they call rhythmdb_entry_set. Doing it this way 2477 * is safe if we assume all calls to read_enter/read_leave 2478 * are done from the main thread (the thread this function 2479 * runs in). 2480 */ 2481 if (rhythmdb_get_readonly (db) && 2482 ((event->type == RHYTHMDB_EVENT_STAT) 2483 || (event->type == RHYTHMDB_EVENT_METADATA_LOAD) 2484 || (event->type == RHYTHMDB_EVENT_ENTRY_SET))) { 2485 rb_debug ("Database is read-only, delaying event processing"); 2486 g_async_queue_push (db->priv->delayed_write_queue, event); 2487 return; 2488 } 2489 2490 switch (event->type) { 2491 case RHYTHMDB_EVENT_STAT: 2492 rb_debug ("processing RHYTHMDB_EVENT_STAT"); 2493 rhythmdb_process_stat_event (db, event); 2494 break; 2495 case RHYTHMDB_EVENT_METADATA_LOAD: 2496 rb_debug ("processing RHYTHMDB_EVENT_METADATA_LOAD"); 2497 free = rhythmdb_process_metadata_load (db, event); 2498 break; 2499 case RHYTHMDB_EVENT_ENTRY_SET: 2500 rb_debug ("processing RHYTHMDB_EVENT_ENTRY_SET"); 2501 rhythmdb_process_queued_entry_set_event (db, event); 2502 break; 2503 case RHYTHMDB_EVENT_DB_LOAD: 2504 rb_debug ("processing RHYTHMDB_EVENT_DB_LOAD"); 2505 g_signal_emit (G_OBJECT (db), rhythmdb_signals[LOAD_COMPLETE], 0); 2506 2507 /* save the db every five minutes */ 2508 if (db->priv->save_timeout_id > 0) { 2509 g_source_remove (db->priv->save_timeout_id); 2510 } 2511 db->priv->save_timeout_id = g_timeout_add_seconds_full (G_PRIORITY_LOW, 2512 5 * 60, 2513 (GSourceFunc) rhythmdb_idle_save, 2514 db, 2515 NULL); 2516 break; 2517 case RHYTHMDB_EVENT_THREAD_EXITED: 2518 rb_debug ("processing RHYTHMDB_EVENT_THREAD_EXITED"); 2519 break; 2520 case RHYTHMDB_EVENT_DB_SAVED: 2521 rb_debug ("processing RHYTHMDB_EVENT_DB_SAVED"); 2522 rhythmdb_read_leave (db); 2523 break; 2524 case RHYTHMDB_EVENT_QUERY_COMPLETE: 2525 rb_debug ("processing RHYTHMDB_EVENT_QUERY_COMPLETE"); 2526 rhythmdb_read_leave (db); 2527 break; 2528 } 2529 if (free) 2530 rhythmdb_event_free (db, event); 2531 } 2532 2533 2534 static void 2535 rhythmdb_file_info_query (RhythmDB *db, GFile *file, RhythmDBEvent *event) 2536 { 2537 event->file_info = g_file_query_info (file, 2538 RHYTHMDB_FILE_INFO_ATTRIBUTES, 2539 G_FILE_QUERY_INFO_NONE, 2540 db->priv->exiting, 2541 &event->error); 2542 } 2543 2544 static void 2545 wrap_access_failed_error (RhythmDBEvent *event) 2546 { 2547 GError *wrapped; 2548 2549 wrapped = make_access_failed_error (rb_refstring_get (event->real_uri), event->error); 2550 g_error_free (event->error); 2551 event->error = wrapped; 2552 } 2553 2554 static void 2555 rhythmdb_execute_stat_mount_ready_cb (GObject *source, GAsyncResult *result, RhythmDBEvent *event) 2556 { 2557 GError *error = NULL; 2558 2559 g_file_mount_enclosing_volume_finish (G_FILE (source), result, &error); 2560 if (error != NULL) { 2561 event->error = make_access_failed_error (rb_refstring_get (event->real_uri), error); 2562 g_error_free (error); 2563 2564 g_object_unref (event->file_info); 2565 event->file_info = NULL; 2566 } else { 2567 rhythmdb_file_info_query (event->db, G_FILE (source), event); 2568 } 2569 2570 g_mutex_lock (&event->db->priv->stat_mutex); 2571 event->db->priv->outstanding_stats = g_list_remove (event->db->priv->outstanding_stats, event); 2572 g_mutex_unlock (&event->db->priv->stat_mutex); 2573 2574 g_object_unref (source); 2575 rhythmdb_push_event (event->db, event); 2576 } 2577 2578 2579 static void 2580 rhythmdb_execute_stat (RhythmDB *db, 2581 const char *uri, 2582 RhythmDBEvent *event) 2583 { 2584 GFile *file; 2585 2586 event->real_uri = rb_refstring_new (uri); 2587 file = g_file_new_for_uri (uri); 2588 2589 g_mutex_lock (&db->priv->stat_mutex); 2590 db->priv->outstanding_stats = g_list_prepend (db->priv->outstanding_stats, event); 2591 g_mutex_unlock (&db->priv->stat_mutex); 2592 2593 rhythmdb_file_info_query (db, file, event); 2594 2595 if (event->error != NULL) { 2596 /* if we can't get at it because the location isn't mounted, mount it and try again */ 2597 if (g_error_matches (event->error, G_IO_ERROR, G_IO_ERROR_NOT_MOUNTED)) { 2598 GMountOperation *mount_op = NULL; 2599 2600 g_error_free (event->error); 2601 event->error = NULL; 2602 2603 g_signal_emit (G_OBJECT (event->db), rhythmdb_signals[CREATE_MOUNT_OP], 0, &mount_op); 2604 if (mount_op != NULL) { 2605 g_file_mount_enclosing_volume (file, 2606 G_MOUNT_MOUNT_NONE, 2607 mount_op, 2608 event->db->priv->exiting, 2609 (GAsyncReadyCallback)rhythmdb_execute_stat_mount_ready_cb, 2610 event); 2611 return; 2612 } 2613 } 2614 2615 /* if it's some other error, or we couldn't attempt to mount the location, report the error */ 2616 wrap_access_failed_error (event); 2617 2618 if (event->file_info != NULL) { 2619 g_object_unref (event->file_info); 2620 event->file_info = NULL; 2621 } 2622 } 2623 2624 /* either way, we're done now */ 2625 2626 g_mutex_lock (&event->db->priv->stat_mutex); 2627 event->db->priv->outstanding_stats = g_list_remove (event->db->priv->outstanding_stats, event); 2628 g_mutex_unlock (&event->db->priv->stat_mutex); 2629 2630 rhythmdb_push_event (event->db, event); 2631 g_object_unref (file); 2632 } 2633 2634 static void 2635 rhythmdb_execute_load (RhythmDB *db, 2636 const char *uri, 2637 RhythmDBEvent *event) 2638 { 2639 GError *error = NULL; 2640 char *resolved; 2641 2642 resolved = rb_uri_resolve_symlink (uri, &error); 2643 if (resolved != NULL) { 2644 GFile *file; 2645 2646 file = g_file_new_for_uri (uri); 2647 event->file_info = g_file_query_info (file, 2648 RHYTHMDB_FILE_INFO_ATTRIBUTES, 2649 G_FILE_QUERY_INFO_NONE, 2650 NULL, 2651 &error); 2652 event->real_uri = rb_refstring_new (resolved); 2653 2654 g_free (resolved); 2655 g_object_unref (file); 2656 } else { 2657 event->real_uri = rb_refstring_new (uri); 2658 } 2659 2660 if (error != NULL) { 2661 event->error = make_access_failed_error (uri, error); 2662 if (event->file_info) { 2663 g_object_unref (event->file_info); 2664 event->file_info = NULL; 2665 } 2666 } else if (event->type == RHYTHMDB_EVENT_METADATA_LOAD) { 2667 event->metadata = rb_metadata_new (); 2668 rb_metadata_load (event->metadata, 2669 rb_refstring_get (event->real_uri), 2670 &event->error); 2671 } 2672 2673 rhythmdb_push_event (db, event); 2674 } 2675 2676 static void 2677 rhythmdb_execute_enum_dir (RhythmDB *db, 2678 RhythmDBAction *action) 2679 { 2680 GFile *dir; 2681 GFileEnumerator *dir_enum; 2682 GError *error = NULL; 2683 2684 dir = g_file_new_for_uri (rb_refstring_get (action->uri)); 2685 dir_enum = g_file_enumerate_children (dir, 2686 RHYTHMDB_FILE_CHILD_INFO_ATTRIBUTES, 2687 G_FILE_QUERY_INFO_NONE, 2688 db->priv->exiting, 2689 &error); 2690 if (error != NULL) { 2691 /* don't need to worry about mounting here, as the mount should have 2692 * occurred on the stat. 2693 */ 2694 2695 /* um.. what now? */ 2696 rb_debug ("unable to enumerate children of %s: %s", 2697 rb_refstring_get (action->uri), 2698 error->message); 2699 g_error_free (error); 2700 g_object_unref (dir); 2701 return; 2702 } 2703 2704 while (1) { 2705 RhythmDBEvent *result; 2706 GFileInfo *file_info; 2707 GFile *child; 2708 char *child_uri; 2709 2710 file_info = g_file_enumerator_next_file (dir_enum, db->priv->exiting, &error); 2711 if (file_info == NULL) { 2712 if (error == NULL) { 2713 /* done */ 2714 break; 2715 } 2716 2717 g_warning ("error getting next file: %s", error->message); 2718 g_clear_error (&error); 2719 continue; 2720 } 2721 2722 if (g_file_info_get_attribute_boolean (file_info, G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN)) { 2723 rb_debug ("ignoring hidden file %s", g_file_info_get_name (file_info)); 2724 g_object_unref (file_info); 2725 continue; 2726 } 2727 2728 child = g_file_get_child (dir, g_file_info_get_name (file_info)); 2729 child_uri = g_file_get_uri (child); 2730 2731 result = g_slice_new0 (RhythmDBEvent); 2732 result->db = db; 2733 result->type = RHYTHMDB_EVENT_STAT; 2734 result->entry_type = action->data.types.entry_type; 2735 result->error_type = action->data.types.error_type; 2736 result->ignore_type = action->data.types.ignore_type; 2737 result->real_uri = rb_refstring_new (child_uri); 2738 result->file_info = file_info; 2739 result->error = error; 2740 2741 rhythmdb_push_event (db, result); 2742 g_free (child_uri); 2743 } 2744 2745 g_file_enumerator_close (dir_enum, db->priv->exiting, &error); 2746 if (error != NULL) { 2747 /* hmm.. */ 2748 rb_debug ("error closing file enumerator: %s", error->message); 2749 g_error_free (error); 2750 } 2751 2752 g_object_unref (dir); 2753 g_object_unref (dir_enum); 2754 } 2755 2756 /** 2757 * rhythmdb_entry_get: 2758 * @db: the #RhythmDB 2759 * @entry: a #RhythmDBEntry. 2760 * @propid: the id of the property to get. 2761 * @val: return location for the property value. 2762 * 2763 * Gets a property of an entry, storing it in the given #GValue. 2764 */ 2765 void 2766 rhythmdb_entry_get (RhythmDB *db, 2767 RhythmDBEntry *entry, 2768 RhythmDBPropType propid, 2769 GValue *val) 2770 { 2771 g_return_if_fail (RHYTHMDB_IS (db)); 2772 g_return_if_fail (entry != NULL); 2773 g_return_if_fail (entry->refcount > 0); 2774 2775 rhythmdb_entry_sync_mirrored (entry, propid); 2776 2777 g_assert (G_VALUE_TYPE (val) == rhythmdb_get_property_type (db, propid)); 2778 switch (rhythmdb_properties[propid].prop_type) { 2779 case G_TYPE_STRING: 2780 g_value_set_string (val, rhythmdb_entry_get_string (entry, propid)); 2781 break; 2782 case G_TYPE_BOOLEAN: 2783 g_value_set_boolean (val, rhythmdb_entry_get_boolean (entry, propid)); 2784 break; 2785 case G_TYPE_ULONG: 2786 g_value_set_ulong (val, rhythmdb_entry_get_ulong (entry, propid)); 2787 break; 2788 case G_TYPE_UINT64: 2789 g_value_set_uint64 (val, rhythmdb_entry_get_uint64 (entry, propid)); 2790 break; 2791 case G_TYPE_DOUBLE: 2792 g_value_set_double (val, rhythmdb_entry_get_double (entry, propid)); 2793 break; 2794 case G_TYPE_OBJECT: 2795 g_value_set_object (val, rhythmdb_entry_get_object (entry, propid)); 2796 break; 2797 default: 2798 g_assert_not_reached (); 2799 break; 2800 } 2801 } 2802 2803 typedef struct 2804 { 2805 RhythmDB *db; 2806 char *uri; 2807 GError *error; 2808 } RhythmDBSaveErrorData; 2809 2810 static gboolean 2811 emit_save_error_idle (RhythmDBSaveErrorData *data) 2812 { 2813 g_signal_emit (G_OBJECT (data->db), rhythmdb_signals[SAVE_ERROR], 0, data->uri, data->error); 2814 g_object_unref (G_OBJECT (data->db)); 2815 g_free (data->uri); 2816 g_error_free (data->error); 2817 g_free (data); 2818 return FALSE; 2819 } 2820 2821 static gpointer 2822 action_thread_main (RhythmDB *db) 2823 { 2824 RhythmDBEvent *result; 2825 2826 while (!g_cancellable_is_cancelled (db->priv->exiting)) { 2827 RhythmDBAction *action; 2828 2829 action = g_async_queue_pop (db->priv->action_queue); 2830 2831 /* hrm, do we need this check at all? */ 2832 if (!g_cancellable_is_cancelled (db->priv->exiting)) { 2833 switch (action->type) { 2834 case RHYTHMDB_ACTION_STAT: 2835 result = g_slice_new0 (RhythmDBEvent); 2836 result->db = db; 2837 result->type = RHYTHMDB_EVENT_STAT; 2838 result->entry_type = action->data.types.entry_type; 2839 result->error_type = action->data.types.error_type; 2840 result->ignore_type = action->data.types.ignore_type; 2841 2842 rb_debug ("executing RHYTHMDB_ACTION_STAT for \"%s\"", rb_refstring_get (action->uri)); 2843 2844 rhythmdb_execute_stat (db, rb_refstring_get (action->uri), result); 2845 break; 2846 2847 case RHYTHMDB_ACTION_LOAD: 2848 result = g_slice_new0 (RhythmDBEvent); 2849 result->db = db; 2850 result->type = RHYTHMDB_EVENT_METADATA_LOAD; 2851 result->entry_type = action->data.types.entry_type; 2852 result->error_type = action->data.types.error_type; 2853 result->ignore_type = action->data.types.ignore_type; 2854 2855 rb_debug ("executing RHYTHMDB_ACTION_LOAD for \"%s\"", rb_refstring_get (action->uri)); 2856 2857 rhythmdb_execute_load (db, rb_refstring_get (action->uri), result); 2858 break; 2859 2860 case RHYTHMDB_ACTION_ENUM_DIR: 2861 rb_debug ("executing RHYTHMDB_ACTION_ENUM_DIR for \"%s\"", rb_refstring_get (action->uri)); 2862 rhythmdb_execute_enum_dir (db, action); 2863 break; 2864 2865 case RHYTHMDB_ACTION_SYNC: 2866 { 2867 GError *error = NULL; 2868 RhythmDBEntry *entry; 2869 2870 if (db->priv->dry_run) { 2871 rb_debug ("dry run is enabled, not syncing metadata"); 2872 break; 2873 } 2874 2875 entry = rhythmdb_entry_lookup_by_location_refstring (db, action->uri); 2876 if (!entry) 2877 break; 2878 2879 rhythmdb_entry_sync_metadata (entry, action->data.changes, &error); 2880 2881 if (error != NULL) { 2882 RhythmDBSaveErrorData *data; 2883 2884 data = g_new0 (RhythmDBSaveErrorData, 1); 2885 g_object_ref (db); 2886 data->db = db; 2887 data->uri = g_strdup (rb_refstring_get (action->uri)); 2888 data->error = error; 2889 g_idle_add ((GSourceFunc)emit_save_error_idle, data); 2890 break; 2891 } 2892 break; 2893 } 2894 2895 case RHYTHMDB_ACTION_QUIT: 2896 /* don't do any real work here, since we may not process it */ 2897 rb_debug ("received QUIT action"); 2898 break; 2899 2900 default: 2901 g_assert_not_reached (); 2902 break; 2903 } 2904 } 2905 2906 rhythmdb_action_free (db, action); 2907 } 2908 2909 rb_debug ("exiting action thread"); 2910 result = g_slice_new0 (RhythmDBEvent); 2911 result->db = db; 2912 result->type = RHYTHMDB_EVENT_THREAD_EXITED; 2913 rhythmdb_push_event (db, result); 2914 2915 return NULL; 2916 } 2917 2918 /** 2919 * rhythmdb_add_uri: 2920 * @db: a #RhythmDB. 2921 * @uri: the URI to add an entry/entries for 2922 * 2923 * Adds the file(s) pointed to by @uri to the database, as entries of type 2924 * RHYTHMDB_ENTRY_TYPE_SONG. If the URI is that of a file, it will be added. 2925 * If the URI is that of a directory, everything under it will be added recursively. 2926 */ 2927 void 2928 rhythmdb_add_uri (RhythmDB *db, 2929 const char *uri) 2930 { 2931 rhythmdb_add_uri_with_types (db, 2932 uri, 2933 RHYTHMDB_ENTRY_TYPE_SONG, 2934 RHYTHMDB_ENTRY_TYPE_IGNORE, 2935 RHYTHMDB_ENTRY_TYPE_IMPORT_ERROR); 2936 } 2937 2938 static void 2939 rhythmdb_add_to_stat_list (RhythmDB *db, 2940 const char *uri, 2941 RhythmDBEntry *entry, 2942 RhythmDBEntryType *type, 2943 RhythmDBEntryType *ignore_type, 2944 RhythmDBEntryType *error_type) 2945 { 2946 RhythmDBEvent *result; 2947 2948 result = g_slice_new0 (RhythmDBEvent); 2949 result->db = db; 2950 result->type = RHYTHMDB_EVENT_STAT; 2951 result->entry_type = type; 2952 result->ignore_type = ignore_type; 2953 result->error_type = error_type; 2954 2955 if (entry != NULL) { 2956 result->entry = rhythmdb_entry_ref (entry); 2957 } 2958 2959 /* do we really need to check for duplicate requests here? .. nah. */ 2960 result->uri = rb_refstring_new (uri); 2961 db->priv->stat_list = g_list_prepend (db->priv->stat_list, result); 2962 } 2963 2964 2965 /** 2966 * rhythmdb_add_uri_with_types: 2967 * @db: a #RhythmDB. 2968 * @uri: the URI to add 2969 * @type: the #RhythmDBEntryType to use for new entries 2970 * @ignore_type: the #RhythmDBEntryType to use for ignored files 2971 * @error_type: the #RhythmDBEntryType to use for import errors 2972 * 2973 * Adds the file(s) pointed to by @uri to the database, as entries 2974 * of the specified type. If the URI points to a file, it will be added. 2975 * The the URI identifies a directory, everything under it will be added 2976 * recursively. 2977 */ 2978 void 2979 rhythmdb_add_uri_with_types (RhythmDB *db, 2980 const char *uri, 2981 RhythmDBEntryType *type, 2982 RhythmDBEntryType *ignore_type, 2983 RhythmDBEntryType *error_type) 2984 { 2985 rb_debug ("queueing stat for \"%s\"", uri); 2986 g_assert (uri && *uri); 2987 2988 /* 2989 * before the action thread is started, we queue up stat actions, 2990 * as we're still creating and running queries, as well as loading 2991 * the database. when we start the action thread, we'll kick off 2992 * a thread to process all the stat events too. 2993 * 2994 * when the action thread is already running, stat actions go through 2995 * the normal action queue and are processed by the action thread. 2996 */ 2997 g_mutex_lock (&db->priv->stat_mutex); 2998 if (db->priv->action_thread_running) { 2999 RhythmDBAction *action; 3000 g_mutex_unlock (&db->priv->stat_mutex); 3001 3002 action = g_slice_new0 (RhythmDBAction); 3003 action->type = RHYTHMDB_ACTION_STAT; 3004 action->uri = rb_refstring_new (uri); 3005 action->data.types.entry_type = type; 3006 action->data.types.ignore_type = ignore_type; 3007 action->data.types.error_type = error_type; 3008 3009 g_async_queue_push (db->priv->action_queue, action); 3010 } else { 3011 RhythmDBEntry *entry; 3012 3013 entry = rhythmdb_entry_lookup_by_location (db, uri); 3014 rhythmdb_add_to_stat_list (db, uri, entry, type, ignore_type, error_type); 3015 3016 g_mutex_unlock (&db->priv->stat_mutex); 3017 } 3018 } 3019 3020 3021 static gboolean 3022 rhythmdb_sync_library_idle (RhythmDB *db) 3023 { 3024 rhythmdb_sync_library_location (db); 3025 g_object_unref (db); 3026 return FALSE; 3027 } 3028 3029 static gboolean 3030 rhythmdb_load_error_cb (GError *error) 3031 { 3032 GDK_THREADS_ENTER (); 3033 rb_error_dialog (NULL, 3034 _("Could not load the music database:"), 3035 "%s", error->message); 3036 g_error_free (error); 3037 3038 GDK_THREADS_LEAVE (); 3039 return FALSE; 3040 } 3041 3042 static gpointer 3043 rhythmdb_load_thread_main (RhythmDB *db) 3044 { 3045 RhythmDBEvent *result; 3046 RhythmDBClass *klass = RHYTHMDB_GET_CLASS (db); 3047 GError *error = NULL; 3048 3049 db->priv->active_mounts = rhythmdb_get_active_mounts (db); 3050 3051 rb_profile_start ("loading db"); 3052 g_mutex_lock (&db->priv->saving_mutex); 3053 if (klass->impl_load (db, db->priv->exiting, &error) == FALSE) { 3054 rb_debug ("db load failed: disabling saving"); 3055 db->priv->can_save = FALSE; 3056 3057 if (error) { 3058 g_idle_add ((GSourceFunc) rhythmdb_load_error_cb, error); 3059 } 3060 } 3061 g_mutex_unlock (&db->priv->saving_mutex); 3062 3063 rb_list_deep_free (db->priv->active_mounts); 3064 db->priv->active_mounts = NULL; 3065 3066 g_object_ref (db); 3067 g_timeout_add_seconds (10, (GSourceFunc) rhythmdb_sync_library_idle, db); 3068 3069 rb_debug ("queuing db load complete signal"); 3070 result = g_slice_new0 (RhythmDBEvent); 3071 result->type = RHYTHMDB_EVENT_DB_LOAD; 3072 g_async_queue_push (db->priv->event_queue, result); 3073 3074 rb_debug ("exiting"); 3075 result = g_slice_new0 (RhythmDBEvent); 3076 result->type = RHYTHMDB_EVENT_THREAD_EXITED; 3077 rhythmdb_push_event (db, result); 3078 3079 return NULL; 3080 } 3081 3082 /** 3083 * rhythmdb_load: 3084 * @db: a #RhythmDB. 3085 * 3086 * Load the database from disk. 3087 */ 3088 void 3089 rhythmdb_load (RhythmDB *db) 3090 { 3091 rhythmdb_thread_create (db, NULL, (GThreadFunc) rhythmdb_load_thread_main, db); 3092 } 3093 3094 static gpointer 3095 rhythmdb_save_thread_main (RhythmDB *db) 3096 { 3097 RhythmDBClass *klass; 3098 RhythmDBEvent *result; 3099 3100 rb_debug ("entering save thread"); 3101 3102 g_mutex_lock (&db->priv->saving_mutex); 3103 3104 db->priv->save_count++; 3105 g_cond_broadcast (&db->priv->saving_condition); 3106 3107 if (!(db->priv->dirty && db->priv->can_save)) { 3108 rb_debug ("no save needed, ignoring"); 3109 g_mutex_unlock (&db->priv->saving_mutex); 3110 goto out; 3111 } 3112 3113 while (db->priv->saving) 3114 g_cond_wait (&db->priv->saving_condition, &db->priv->saving_mutex); 3115 3116 db->priv->saving = TRUE; 3117 3118 rb_debug ("saving rhythmdb"); 3119 3120 klass = RHYTHMDB_GET_CLASS (db); 3121 klass->impl_save (db); 3122 3123 db->priv->saving = FALSE; 3124 db->priv->dirty = FALSE; 3125 3126 g_mutex_unlock (&db->priv->saving_mutex); 3127 3128 g_cond_broadcast (&db->priv->saving_condition); 3129 3130 out: 3131 result = g_slice_new0 (RhythmDBEvent); 3132 result->db = db; 3133 result->type = RHYTHMDB_EVENT_DB_SAVED; 3134 g_async_queue_push (db->priv->event_queue, result); 3135 3136 result = g_slice_new0 (RhythmDBEvent); 3137 result->db = db; 3138 result->type = RHYTHMDB_EVENT_THREAD_EXITED; 3139 rhythmdb_push_event (db, result); 3140 return NULL; 3141 } 3142 3143 /** 3144 * rhythmdb_save_async: 3145 * @db: a #RhythmDB. 3146 * 3147 * Save the database to disk, asynchronously. 3148 */ 3149 void 3150 rhythmdb_save_async (RhythmDB *db) 3151 { 3152 rb_debug ("saving the rhythmdb in the background"); 3153 3154 rhythmdb_read_enter (db); 3155 3156 rhythmdb_thread_create (db, NULL, (GThreadFunc) rhythmdb_save_thread_main, db); 3157 } 3158 3159 /** 3160 * rhythmdb_save: 3161 * @db: a #RhythmDB. 3162 * 3163 * Save the database to disk, not returning until it has been saved. 3164 */ 3165 void 3166 rhythmdb_save (RhythmDB *db) 3167 { 3168 int new_save_count; 3169 3170 rb_debug("saving the rhythmdb and blocking"); 3171 3172 g_mutex_lock (&db->priv->saving_mutex); 3173 new_save_count = db->priv->save_count + 1; 3174 3175 rhythmdb_save_async (db); 3176 3177 /* wait until this save request is being processed */ 3178 while (db->priv->save_count < new_save_count) { 3179 g_cond_wait (&db->priv->saving_condition, &db->priv->saving_mutex); 3180 } 3181 3182 /* wait until it's done */ 3183 while (db->priv->saving) { 3184 g_cond_wait (&db->priv->saving_condition, &db->priv->saving_mutex); 3185 } 3186 3187 rb_debug ("done"); 3188 3189 g_mutex_unlock (&db->priv->saving_mutex); 3190 } 3191 3192 /** 3193 * rhythmdb_entry_set: 3194 * @db:# a RhythmDB. 3195 * @entry: a #RhythmDBEntry. 3196 * @propid: the id of the property to set. 3197 * @value: the property value. 3198 * 3199 * This function can be called by any code which wishes to change a 3200 * song property and send a notification. It may be called when the 3201 * database is read-only; in this case the change will be queued for 3202 * an unspecified time in the future. The implication of this is that 3203 * rhythmdb_entry_get() may not reflect the changes immediately. However, 3204 * if this property is exposed in the user interface, you should still 3205 * make the change in the widget. Then when the database returns to a 3206 * writable state, your change will take effect in the database too, 3207 * and a notification will be sent at that point. 3208 * 3209 * Note that you must call rhythmdb_commit() at some point after invoking 3210 * this function, and that even after the commit, your change may not 3211 * have taken effect. 3212 */ 3213 void 3214 rhythmdb_entry_set (RhythmDB *db, 3215 RhythmDBEntry *entry, 3216 guint propid, 3217 const GValue *value) 3218 { 3219 g_return_if_fail (RHYTHMDB_IS (db)); 3220 g_return_if_fail (entry != NULL); 3221 3222 if ((entry->flags & RHYTHMDB_ENTRY_INSERTED) != 0) { 3223 if (!rhythmdb_get_readonly (db) && rb_is_main_thread ()) { 3224 rhythmdb_entry_set_internal (db, entry, TRUE, propid, value); 3225 } else { 3226 RhythmDBEvent *result; 3227 3228 result = g_slice_new0 (RhythmDBEvent); 3229 result->db = db; 3230 result->type = RHYTHMDB_EVENT_ENTRY_SET; 3231 3232 rb_debug ("queuing RHYTHMDB_ACTION_ENTRY_SET"); 3233 3234 result->entry = rhythmdb_entry_ref (entry); 3235 result->change.prop = propid; 3236 result->signal_change = TRUE; 3237 g_value_init (&result->change.new, G_VALUE_TYPE (value)); 3238 g_value_copy (value, &result->change.new); 3239 rhythmdb_push_event (db, result); 3240 } 3241 } else { 3242 rhythmdb_entry_set_internal (db, entry, FALSE, propid, value); 3243 } 3244 } 3245 3246 static void 3247 record_entry_change (RhythmDB *db, 3248 RhythmDBEntry *entry, 3249 guint propid, 3250 const GValue *old_value, 3251 const GValue *new_value) 3252 { 3253 RhythmDBEntryChange *changedata; 3254 GSList *changelist; 3255 3256 changedata = g_slice_new0 (RhythmDBEntryChange); 3257 changedata->prop = propid; 3258 3259 g_value_init (&changedata->old, G_VALUE_TYPE (old_value)); 3260 g_value_init (&changedata->new, G_VALUE_TYPE (new_value)); 3261 g_value_copy (old_value, &changedata->old); 3262 g_value_copy (new_value, &changedata->new); 3263 3264 g_mutex_lock (&db->priv->change_mutex); 3265 /* ref the entry before adding to hash, it is unreffed when removed */ 3266 rhythmdb_entry_ref (entry); 3267 changelist = g_hash_table_lookup (db->priv->changed_entries, entry); 3268 changelist = g_slist_append (changelist, changedata); 3269 g_hash_table_insert (db->priv->changed_entries, entry, changelist); 3270 g_mutex_unlock (&db->priv->change_mutex); 3271 } 3272 3273 void 3274 rhythmdb_entry_set_internal (RhythmDB *db, 3275 RhythmDBEntry *entry, 3276 gboolean notify_if_inserted, 3277 guint propid, 3278 const GValue *value) 3279 { 3280 RhythmDBClass *klass = RHYTHMDB_GET_CLASS (db); 3281 gboolean handled; 3282 RhythmDBPodcastFields *podcast = NULL; 3283 GValue conv_value = {0,}; 3284 GValue old_value = {0,}; 3285 gboolean nop; 3286 3287 g_return_if_fail (entry != NULL); 3288 3289 /* convert the value if necessary */ 3290 if (G_VALUE_TYPE (value) != rhythmdb_get_property_type (db, propid)) { 3291 g_value_init (&conv_value, rhythmdb_get_property_type (db, propid)); 3292 if (g_value_transform (value, &conv_value) == FALSE) { 3293 g_warning ("Unable to convert new value for property %s from %s to %s", 3294 rhythmdb_nice_elt_name_from_propid (db, propid), 3295 g_type_name (G_VALUE_TYPE (value)), 3296 g_type_name (rhythmdb_get_property_type (db, propid))); 3297 g_assert_not_reached (); 3298 } 3299 value = &conv_value; 3300 } 3301 3302 /* compare the value with what's already there */ 3303 g_value_init (&old_value, G_VALUE_TYPE (value)); 3304 rhythmdb_entry_get (db, entry, propid, &old_value); 3305 switch (G_VALUE_TYPE (value)) { 3306 case G_TYPE_STRING: 3307 #ifndef G_DISABLE_ASSERT 3308 /* the playback error is allowed to be NULL */ 3309 if (propid != RHYTHMDB_PROP_PLAYBACK_ERROR || g_value_get_string (value)) 3310 g_assert (g_utf8_validate (g_value_get_string (value), -1, NULL)); 3311 #endif 3312 if (g_value_get_string (value) && g_value_get_string (&old_value)) { 3313 nop = (strcmp (g_value_get_string (value), g_value_get_string (&old_value)) == 0); 3314 } else { 3315 nop = FALSE; 3316 } 3317 break; 3318 case G_TYPE_BOOLEAN: 3319 nop = (g_value_get_boolean (value) == g_value_get_boolean (&old_value)); 3320 break; 3321 case G_TYPE_ULONG: 3322 nop = (g_value_get_ulong (value) == g_value_get_ulong (&old_value)); 3323 break; 3324 case G_TYPE_UINT64: 3325 nop = (g_value_get_uint64 (value) == g_value_get_uint64 (&old_value)); 3326 break; 3327 case G_TYPE_DOUBLE: 3328 nop = (g_value_get_double (value) == g_value_get_double (&old_value)); 3329 break; 3330 case G_TYPE_OBJECT: 3331 nop = (g_value_get_object (value) == g_value_get_object (&old_value)); 3332 break; 3333 default: 3334 g_assert_not_reached (); 3335 break; 3336 } 3337 3338 if (nop == FALSE && (entry->flags & RHYTHMDB_ENTRY_INSERTED) && notify_if_inserted) { 3339 record_entry_change (db, entry, propid, &old_value, value); 3340 } 3341 g_value_unset (&old_value); 3342 3343 if (nop) { 3344 if (value == &conv_value) { 3345 g_value_unset (&conv_value); 3346 } 3347 return; 3348 } 3349 3350 handled = klass->impl_entry_set (db, entry, propid, value); 3351 3352 if (!handled) { 3353 if (entry->type == RHYTHMDB_ENTRY_TYPE_PODCAST_FEED || 3354 entry->type == RHYTHMDB_ENTRY_TYPE_PODCAST_POST || 3355 entry->type == RHYTHMDB_ENTRY_TYPE_PODCAST_SEARCH) 3356 podcast = RHYTHMDB_ENTRY_GET_TYPE_DATA (entry, RhythmDBPodcastFields); 3357 3358 switch (propid) { 3359 case RHYTHMDB_PROP_TYPE: 3360 case RHYTHMDB_PROP_ENTRY_ID: 3361 g_assert_not_reached (); 3362 break; 3363 case RHYTHMDB_PROP_TITLE: 3364 if (entry->title != NULL) { 3365 rb_refstring_unref (entry->title); 3366 } 3367 entry->title = rb_refstring_new (g_value_get_string (value)); 3368 break; 3369 case RHYTHMDB_PROP_ALBUM: 3370 if (entry->album != NULL) { 3371 rb_refstring_unref (entry->album); 3372 } 3373 entry->album = rb_refstring_new (g_value_get_string (value)); 3374 break; 3375 case RHYTHMDB_PROP_ARTIST: 3376 if (entry->artist != NULL) { 3377 rb_refstring_unref (entry->artist); 3378 } 3379 entry->artist = rb_refstring_new (g_value_get_string (value)); 3380 break; 3381 case RHYTHMDB_PROP_GENRE: 3382 if (entry->genre != NULL) { 3383 rb_refstring_unref (entry->genre); 3384 } 3385 entry->genre = rb_refstring_new (g_value_get_string (value)); 3386 break; 3387 case RHYTHMDB_PROP_COMMENT: 3388 if (entry->comment != NULL) { 3389 rb_refstring_unref (entry->comment); 3390 } 3391 entry->comment = rb_refstring_new (g_value_get_string (value)); 3392 break; 3393 case RHYTHMDB_PROP_TRACK_NUMBER: 3394 entry->tracknum = g_value_get_ulong (value); 3395 break; 3396 case RHYTHMDB_PROP_DISC_NUMBER: 3397 entry->discnum = g_value_get_ulong (value); 3398 break; 3399 case RHYTHMDB_PROP_DURATION: 3400 entry->duration = g_value_get_ulong (value); 3401 break; 3402 case RHYTHMDB_PROP_BITRATE: 3403 entry->bitrate = g_value_get_ulong (value); 3404 break; 3405 case RHYTHMDB_PROP_DATE: 3406 { 3407 gulong julian; 3408 julian = g_value_get_ulong (value); 3409 if (julian > 0) 3410 g_date_set_julian (&entry->date, julian); 3411 else 3412 g_date_clear (&entry->date, 1); 3413 break; 3414 } 3415 case RHYTHMDB_PROP_TRACK_GAIN: 3416 g_warning ("RHYTHMDB_PROP_TRACK_GAIN no longer supported"); 3417 break; 3418 case RHYTHMDB_PROP_TRACK_PEAK: 3419 g_warning ("RHYTHMDB_PROP_TRACK_PEAK no longer supported"); 3420 break; 3421 case RHYTHMDB_PROP_ALBUM_GAIN: 3422 g_warning ("RHYTHMDB_PROP_ALBUM_GAIN no longer supported"); 3423 break; 3424 case RHYTHMDB_PROP_ALBUM_PEAK: 3425 g_warning ("RHYTHMDB_PROP_ALBUM_PEAK no longer supported"); 3426 break; 3427 case RHYTHMDB_PROP_LOCATION: 3428 rb_refstring_unref (entry->location); 3429 entry->location = rb_refstring_new (g_value_get_string (value)); 3430 break; 3431 case RHYTHMDB_PROP_PLAYBACK_ERROR: 3432 rb_refstring_unref (entry->playback_error); 3433 if (g_value_get_string (value)) 3434 entry->playback_error = rb_refstring_new (g_value_get_string (value)); 3435 else 3436 entry->playback_error = NULL; 3437 break; 3438 case RHYTHMDB_PROP_MOUNTPOINT: 3439 if (entry->mountpoint != NULL) { 3440 rb_refstring_unref (entry->mountpoint); 3441 } 3442 entry->mountpoint = rb_refstring_new (g_value_get_string (value)); 3443 break; 3444 case RHYTHMDB_PROP_FILE_SIZE: 3445 entry->file_size = g_value_get_uint64 (value); 3446 break; 3447 case RHYTHMDB_PROP_MEDIA_TYPE: 3448 if (entry->media_type != NULL) { 3449 rb_refstring_unref (entry->media_type); 3450 } 3451 entry->media_type = rb_refstring_new (g_value_get_string (value)); 3452 break; 3453 case RHYTHMDB_PROP_MTIME: 3454 entry->mtime = g_value_get_ulong (value); 3455 break; 3456 case RHYTHMDB_PROP_FIRST_SEEN: 3457 entry->first_seen = g_value_get_ulong (value); 3458 entry->flags |= RHYTHMDB_ENTRY_FIRST_SEEN_DIRTY; 3459 break; 3460 case RHYTHMDB_PROP_LAST_SEEN: 3461 entry->last_seen = g_value_get_ulong (value); 3462 entry->flags |= RHYTHMDB_ENTRY_LAST_SEEN_DIRTY; 3463 break; 3464 case RHYTHMDB_PROP_RATING: 3465 entry->rating = g_value_get_double (value); 3466 break; 3467 case RHYTHMDB_PROP_PLAY_COUNT: 3468 entry->play_count = g_value_get_ulong (value); 3469 break; 3470 case RHYTHMDB_PROP_LAST_PLAYED: 3471 entry->last_played = g_value_get_ulong (value); 3472 entry->flags |= RHYTHMDB_ENTRY_LAST_PLAYED_DIRTY; 3473 break; 3474 case RHYTHMDB_PROP_BPM: 3475 entry->bpm = g_value_get_double (value); 3476 break; 3477 case RHYTHMDB_PROP_MUSICBRAINZ_TRACKID: 3478 rb_refstring_unref (entry->musicbrainz_trackid); 3479 entry->musicbrainz_trackid = rb_refstring_new (g_value_get_string (value)); 3480 break; 3481 case RHYTHMDB_PROP_MUSICBRAINZ_ARTISTID: 3482 rb_refstring_unref (entry->musicbrainz_artistid); 3483 entry->musicbrainz_artistid = rb_refstring_new (g_value_get_string (value)); 3484 break; 3485 case RHYTHMDB_PROP_MUSICBRAINZ_ALBUMID: 3486 rb_refstring_unref (entry->musicbrainz_albumid); 3487 entry->musicbrainz_albumid = rb_refstring_new (g_value_get_string (value)); 3488 break; 3489 case RHYTHMDB_PROP_MUSICBRAINZ_ALBUMARTISTID: 3490 rb_refstring_unref (entry->musicbrainz_albumartistid); 3491 entry->musicbrainz_albumartistid = rb_refstring_new (g_value_get_string (value)); 3492 break; 3493 case RHYTHMDB_PROP_ARTIST_SORTNAME: 3494 rb_refstring_unref (entry->artist_sortname); 3495 entry->artist_sortname = rb_refstring_new (g_value_get_string (value)); 3496 break; 3497 case RHYTHMDB_PROP_ALBUM_SORTNAME: 3498 rb_refstring_unref (entry->album_sortname); 3499 entry->album_sortname = rb_refstring_new (g_value_get_string (value)); 3500 break; 3501 case RHYTHMDB_PROP_ALBUM_ARTIST: 3502 rb_refstring_unref (entry->album_artist); 3503 entry->album_artist = rb_refstring_new (g_value_get_string (value)); 3504 break; 3505 case RHYTHMDB_PROP_ALBUM_ARTIST_SORTNAME: 3506 rb_refstring_unref (entry->album_artist_sortname); 3507 entry->album_artist_sortname = rb_refstring_new (g_value_get_string (value)); 3508 break; 3509 case RHYTHMDB_PROP_HIDDEN: 3510 if (g_value_get_boolean (value)) { 3511 entry->flags |= RHYTHMDB_ENTRY_HIDDEN; 3512 } else { 3513 entry->flags &= ~RHYTHMDB_ENTRY_HIDDEN; 3514 } 3515 entry->flags |= RHYTHMDB_ENTRY_LAST_SEEN_DIRTY; 3516 break; 3517 case RHYTHMDB_PROP_STATUS: 3518 g_assert (podcast); 3519 podcast->status = g_value_get_ulong (value); 3520 break; 3521 case RHYTHMDB_PROP_DESCRIPTION: 3522 g_assert (podcast); 3523 rb_refstring_unref (podcast->description); 3524 podcast->description = rb_refstring_new (g_value_get_string (value)); 3525 break; 3526 case RHYTHMDB_PROP_SUBTITLE: 3527 g_assert (podcast); 3528 rb_refstring_unref (podcast->subtitle); 3529 podcast->subtitle = rb_refstring_new (g_value_get_string (value)); 3530 break; 3531 case RHYTHMDB_PROP_SUMMARY: 3532 g_assert (podcast); 3533 rb_refstring_unref (podcast->summary); 3534 podcast->summary = rb_refstring_new (g_value_get_string (value)); 3535 break; 3536 case RHYTHMDB_PROP_LANG: 3537 g_assert (podcast); 3538 if (podcast->lang != NULL) { 3539 rb_refstring_unref (podcast->lang); 3540 } 3541 podcast->lang = rb_refstring_new (g_value_get_string (value)); 3542 break; 3543 case RHYTHMDB_PROP_COPYRIGHT: 3544 g_assert (podcast); 3545 if (podcast->copyright != NULL) { 3546 rb_refstring_unref (podcast->copyright); 3547 } 3548 podcast->copyright = rb_refstring_new (g_value_get_string (value)); 3549 break; 3550 case RHYTHMDB_PROP_IMAGE: 3551 g_assert (podcast); 3552 if (podcast->image != NULL) { 3553 rb_refstring_unref (podcast->image); 3554 } 3555 podcast->image = rb_refstring_new (g_value_get_string (value)); 3556 break; 3557 case RHYTHMDB_PROP_POST_TIME: 3558 g_assert (podcast); 3559 podcast->post_time = g_value_get_ulong (value); 3560 break; 3561 case RHYTHMDB_NUM_PROPERTIES: 3562 g_assert_not_reached (); 3563 break; 3564 } 3565 } 3566 3567 if (value == &conv_value) { 3568 g_value_unset (&conv_value); 3569 } 3570 3571 /* set the dirty state */ 3572 db->priv->dirty = TRUE; 3573 } 3574 3575 /** 3576 * rhythmdb_entry_sync_mirrored: 3577 * @db: a #RhythmDB. 3578 * @type: a #RhythmDBEntry. 3579 * @propid: the property to sync the mirrored version of. 3580 * 3581 * Synchronise "mirrored" properties, such as the string version of the last-played 3582 * time. This should be called when a property is directly modified, passing the 3583 * original property. 3584 * 3585 * This should only be used by RhythmDB itself, or a backend (such as rhythmdb-tree). 3586 */ 3587 static void 3588 rhythmdb_entry_sync_mirrored (RhythmDBEntry *entry, 3589 guint propid) 3590 { 3591 static const char *never; 3592 char *val; 3593 3594 if (never == NULL) 3595 never = _("Never"); 3596 3597 switch (propid) { 3598 case RHYTHMDB_PROP_LAST_PLAYED_STR: 3599 { 3600 RBRefString *old, *new; 3601 3602 if (!(entry->flags & RHYTHMDB_ENTRY_LAST_PLAYED_DIRTY)) 3603 break; 3604 3605 old = g_atomic_pointer_get (&entry->last_played_str); 3606 if (entry->last_played == 0) { 3607 new = rb_refstring_new (never); 3608 } else { 3609 val = rb_utf_friendly_time (entry->last_played); 3610 new = rb_refstring_new (val); 3611 g_free (val); 3612 } 3613 3614 if (g_atomic_pointer_compare_and_exchange (&entry->last_played_str, old, new)) { 3615 if (old != NULL) { 3616 rb_refstring_unref (old); 3617 } 3618 } else { 3619 rb_refstring_unref (new); 3620 } 3621 3622 break; 3623 } 3624 case RHYTHMDB_PROP_FIRST_SEEN_STR: 3625 { 3626 RBRefString *old, *new; 3627 3628 if (!(entry->flags & RHYTHMDB_ENTRY_FIRST_SEEN_DIRTY)) 3629 break; 3630 3631 old = g_atomic_pointer_get (&entry->first_seen_str); 3632 if (entry->first_seen == 0) { 3633 new = rb_refstring_new (never); 3634 } else { 3635 val = rb_utf_friendly_time (entry->first_seen); 3636 new = rb_refstring_new (val); 3637 g_free (val); 3638 } 3639 3640 if (g_atomic_pointer_compare_and_exchange (&entry->first_seen_str, old, new)) { 3641 if (old != NULL) { 3642 rb_refstring_unref (old); 3643 } 3644 } else { 3645 rb_refstring_unref (new); 3646 } 3647 3648 break; 3649 } 3650 case RHYTHMDB_PROP_LAST_SEEN_STR: 3651 { 3652 RBRefString *old, *new; 3653 3654 if (!(entry->flags & RHYTHMDB_ENTRY_LAST_SEEN_DIRTY)) 3655 break; 3656 3657 old = g_atomic_pointer_get (&entry->last_seen_str); 3658 /* only store last seen time as a string for hidden entries */ 3659 if (entry->flags & RHYTHMDB_ENTRY_HIDDEN) { 3660 val = rb_utf_friendly_time (entry->last_seen); 3661 new = rb_refstring_new (val); 3662 g_free (val); 3663 } else { 3664 new = NULL; 3665 } 3666 3667 if (g_atomic_pointer_compare_and_exchange (&entry->last_seen_str, old, new)) { 3668 if (old != NULL) { 3669 rb_refstring_unref (old); 3670 } 3671 } else { 3672 rb_refstring_unref (new); 3673 } 3674 3675 break; 3676 } 3677 default: 3678 break; 3679 } 3680 } 3681 3682 /** 3683 * rhythmdb_entry_delete: 3684 * @db: a #RhythmDB. 3685 * @entry: a #RhythmDBEntry. 3686 * 3687 * Delete entry @entry from the database, sending notification of its deletion. 3688 * This is usually used by sources where entries can disappear randomly, such 3689 * as a network source. 3690 */ 3691 void 3692 rhythmdb_entry_delete (RhythmDB *db, 3693 RhythmDBEntry *entry) 3694 { 3695 RhythmDBClass *klass = RHYTHMDB_GET_CLASS (db); 3696 3697 g_return_if_fail (RHYTHMDB_IS (db)); 3698 g_return_if_fail (entry != NULL); 3699 3700 rb_debug ("deleting entry %p", entry); 3701 3702 /* ref the entry before adding to hash, it is unreffed when removed */ 3703 rhythmdb_entry_ref (entry); 3704 3705 klass->impl_entry_delete (db, entry);
Access to field 'impl_entry_delete' results in a dereference of a null pointer (loaded from variable 'klass')
(emitted by clang-analyzer)

TODO: a detailed trace is available in the data model (not yet rendered in this report)

Access to field 'impl_entry_delete' results in a dereference of a null pointer (loaded from variable 'klass')
(emitted by clang-analyzer)

TODO: a detailed trace is available in the data model (not yet rendered in this report)

3706 3707 g_mutex_lock (&db->priv->change_mutex); 3708 g_hash_table_insert (db->priv->deleted_entries, entry, g_thread_self ()); 3709 g_mutex_unlock (&db->priv->change_mutex); 3710 3711 /* deleting an entry makes the db dirty */ 3712 db->priv->dirty = TRUE; 3713 } 3714 3715 /** 3716 * rhythmdb_entry_move_to_trash: 3717 * @db: the #RhythmDB 3718 * @entry: #RhythmDBEntry to trash 3719 * 3720 * Trashes the file represented by #entry. If possible, the file is 3721 * moved to the user's trash directory and the entry is set to hidden, 3722 * otherwise the error will be stored as the playback error for the entry. 3723 */ 3724 void 3725 rhythmdb_entry_move_to_trash (RhythmDB *db, 3726 RhythmDBEntry *entry) 3727 { 3728 const char *uri; 3729 GFile *file; 3730 GError *error = NULL; 3731 3732 uri = rb_refstring_get (entry->location); 3733 file = g_file_new_for_uri (uri); 3734 3735 g_file_trash (file, NULL, &error); 3736 if (error != NULL) { 3737 GValue value = { 0, }; 3738 3739 g_value_init (&value, G_TYPE_STRING); 3740 g_value_set_string (&value, error->message); 3741 rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_PLAYBACK_ERROR, &value); 3742 g_value_unset (&value); 3743 3744 rb_debug ("trashing %s failed: %s", 3745 uri, 3746 error->message); 3747 g_error_free (error); 3748 3749 } else { 3750 rhythmdb_entry_set_visibility (db, entry, FALSE); 3751 } 3752 g_object_unref (file); 3753 } 3754 3755 /** 3756 * rhythmdb_entry_delete_by_type: 3757 * @db: a #RhythmDB. 3758 * @type: type of entried to delete. 3759 * 3760 * Delete all entries from the database of the given type. 3761 * This is usually used by non-permanent sources when they disappear, such as 3762 * removable media being removed, or a network share becoming unavailable. 3763 */ 3764 void 3765 rhythmdb_entry_delete_by_type (RhythmDB *db, 3766 RhythmDBEntryType *type) 3767 { 3768 RhythmDBClass *klass = RHYTHMDB_GET_CLASS (db); 3769 3770 if (klass->impl_entry_delete_by_type) { 3771 klass->impl_entry_delete_by_type (db, type); 3772 } else { 3773 g_warning ("delete_by_type not implemented"); 3774 } 3775 } 3776 3777 /** 3778 * rhythmdb_nice_elt_name_from_propid: 3779 * @db: the #RhythmDB 3780 * @propid: property ID 3781 * 3782 * Returns a short non-translated name for the property #propid. 3783 * This name is suitable for use as an XML tag name, for example. 3784 * 3785 * Return value: property ID name, must not be freed 3786 */ 3787 const xmlChar * 3788 rhythmdb_nice_elt_name_from_propid (RhythmDB *db, 3789 RhythmDBPropType propid) 3790 { 3791 return (xmlChar *)rhythmdb_properties[propid].elt_name; 3792 } 3793 3794 /** 3795 * rhythmdb_propid_from_nice_elt_name: 3796 * @db: the #RhythmDB 3797 * @name: a property ID name 3798 * 3799 * Converts a property name returned by @rhythmdb_propid_from_nice_elt_name 3800 * back to a #RhythmDBPropType. If the name does not match a property ID, 3801 * -1 will be returned instead. 3802 * 3803 * Return value: a #RhythmDBPropType, or -1 3804 */ 3805 int 3806 rhythmdb_propid_from_nice_elt_name (RhythmDB *db, 3807 const xmlChar *name) 3808 { 3809 gpointer ret, orig; 3810 if (g_hash_table_lookup_extended (db->priv->propname_map, name, 3811 &orig, &ret)) { 3812 return GPOINTER_TO_INT (ret); 3813 } 3814 return -1; 3815 } 3816 3817 /** 3818 * rhythmdb_entry_lookup_by_location: 3819 * @db: a #RhythmDB. 3820 * @uri: the URI of the entry to lookup. 3821 * 3822 * Looks up the entry with location @uri. 3823 * 3824 * Returns: the entry with location @uri, or NULL if no such entry exists. 3825 */ 3826 RhythmDBEntry * 3827 rhythmdb_entry_lookup_by_location (RhythmDB *db, 3828 const char *uri) 3829 { 3830 RBRefString *rs; 3831 3832 rs = rb_refstring_find (uri); 3833 if (rs != NULL) { 3834 return rhythmdb_entry_lookup_by_location_refstring (db, rs); 3835 } else { 3836 return NULL; 3837 } 3838 } 3839 3840 /** 3841 * rhythmdb_entry_lookup_by_location_refstring: 3842 * @db: the #RhythmDB 3843 * @uri: #RBRefString for the entry location 3844 * 3845 * Looks up the entry with location @uri. 3846 * 3847 * Returns: the entry with location @uri, or NULL if no such entry exists. 3848 */ 3849 RhythmDBEntry * 3850 rhythmdb_entry_lookup_by_location_refstring (RhythmDB *db, 3851 RBRefString *uri) 3852 { 3853 RhythmDBClass *klass = RHYTHMDB_GET_CLASS (db); 3854 3855 return klass->impl_lookup_by_location (db, uri); 3856 } 3857 3858 /** 3859 * rhythmdb_entry_lookup_by_id: 3860 * @db: a #RhythmDB. 3861 * @id: entry ID 3862 * 3863 * Looks up the entry with id @id. 3864 * 3865 * Returns: the entry with id @id, or NULL if no such entry exists. 3866 */ 3867 RhythmDBEntry * 3868 rhythmdb_entry_lookup_by_id (RhythmDB *db, 3869 gint id) 3870 { 3871 RhythmDBClass *klass = RHYTHMDB_GET_CLASS (db); 3872 3873 return klass->impl_lookup_by_id (db, id); 3874 } 3875 3876 /** 3877 * rhythmdb_entry_lookup_from_string: 3878 * @db: a #RhythmDB. 3879 * @str: string 3880 * @is_id: whether the string is an entry ID or a location. 3881 * 3882 * Locates an entry using a string containing either an entry ID 3883 * or a location. 3884 * 3885 * Returns: the entry matching the string, or NULL if no such entry exists. 3886 */ 3887 RhythmDBEntry * 3888 rhythmdb_entry_lookup_from_string (RhythmDB *db, 3889 const char *str, 3890 gboolean is_id) 3891 { 3892 if (is_id) { 3893 gint id; 3894 3895 id = strtoul (str, NULL, 10); 3896 if (id == 0) 3897 return NULL; 3898 3899 return rhythmdb_entry_lookup_by_id (db, id); 3900 } else { 3901 return rhythmdb_entry_lookup_by_location (db, str); 3902 } 3903 } 3904 3905 /** 3906 * rhythmdb_entry_foreach: 3907 * @db: a #RhythmDB. 3908 * @func: (scope call): the function to call with each entry. 3909 * @data: user data to pass to the function. 3910 * 3911 * Calls the given function for each of the entries in the database. 3912 */ 3913 void 3914 rhythmdb_entry_foreach (RhythmDB *db, 3915 GFunc func, 3916 gpointer data) 3917 { 3918 RhythmDBClass *klass = RHYTHMDB_GET_CLASS (db); 3919 3920 klass->impl_entry_foreach (db, func, data); 3921 } 3922 3923 /** 3924 * rhythmdb_entry_count: 3925 * @db: a #RhythmDB. 3926 * 3927 * Returns the number of entries in the database. 3928 * 3929 * Return value: number of entries 3930 */ 3931 gint64 3932 rhythmdb_entry_count (RhythmDB *db) 3933 { 3934 RhythmDBClass *klass = RHYTHMDB_GET_CLASS (db); 3935 3936 return klass->impl_entry_count (db); 3937 } 3938 3939 /** 3940 * rhythmdb_entry_foreach_by_type: 3941 * @db: a #RhythmDB. 3942 * @entry_type: the type of entry to retrieve 3943 * @func: (scope call): the function to call with each entry 3944 * @data: user data to pass to the function. 3945 * 3946 * Calls the given function for each of the entries in the database 3947 * of a given type. 3948 */ 3949 void 3950 rhythmdb_entry_foreach_by_type (RhythmDB *db, 3951 RhythmDBEntryType *entry_type, 3952 GFunc func, 3953 gpointer data) 3954 { 3955 RhythmDBClass *klass = RHYTHMDB_GET_CLASS (db); 3956 3957 klass->impl_entry_foreach_by_type (db, entry_type, func, data); 3958 } 3959 3960 /** 3961 * rhythmdb_entry_count_by_type: 3962 * @db: a #RhythmDB. 3963 * @entry_type: a #RhythmDBEntryType. 3964 * 3965 * Returns the number of entries in the database of a particular type. 3966 * 3967 * Return value: entry count 3968 */ 3969 gint64 3970 rhythmdb_entry_count_by_type (RhythmDB *db, 3971 RhythmDBEntryType *entry_type) 3972 { 3973 RhythmDBClass *klass = RHYTHMDB_GET_CLASS (db); 3974 3975 return klass->impl_entry_count_by_type (db, entry_type); 3976 } 3977 3978 3979 /** 3980 * rhythmdb_evaluate_query: 3981 * @db: a #RhythmDB. 3982 * @query: a query. 3983 * @entry: a @RhythmDBEntry. 3984 * 3985 * Evaluates the given entry against the given query. 3986 * 3987 * Returns: whether the given entry matches the criteria of the given query. 3988 */ 3989 gboolean 3990 rhythmdb_evaluate_query (RhythmDB *db, 3991 GPtrArray *query, 3992 RhythmDBEntry *entry) 3993 { 3994 RhythmDBClass *klass = RHYTHMDB_GET_CLASS (db); 3995 3996 return klass->impl_evaluate_query (db, query, entry); 3997 } 3998 3999 static void 4000 rhythmdb_query_internal (RhythmDBQueryThreadData *data) 4001 { 4002 RhythmDBEvent *result; 4003 RhythmDBClass *klass = RHYTHMDB_GET_CLASS (data->db); 4004 4005 rhythmdb_query_preprocess (data->db, data->query); 4006 4007 rb_debug ("doing query"); 4008 4009 klass->impl_do_full_query (data->db, data->query, 4010 data->results, 4011 &data->cancel); 4012 4013 rb_debug ("completed"); 4014 rhythmdb_query_results_query_complete (data->results); 4015 4016 result = g_slice_new0 (RhythmDBEvent); 4017 result->db = data->db; 4018 result->type = RHYTHMDB_EVENT_QUERY_COMPLETE; 4019 result->results = data->results; 4020 rhythmdb_push_event (data->db, result); 4021 4022 rhythmdb_query_free (data->query); 4023 } 4024 4025 static gpointer 4026 query_thread_main (RhythmDBQueryThreadData *data) 4027 { 4028 RhythmDBEvent *result; 4029 4030 rb_debug ("entering query thread"); 4031 4032 rhythmdb_query_internal (data); 4033 4034 result = g_slice_new0 (RhythmDBEvent); 4035 result->db = data->db; 4036 result->type = RHYTHMDB_EVENT_THREAD_EXITED; 4037 rhythmdb_push_event (data->db, result); 4038 g_free (data); 4039 return NULL; 4040 } 4041 4042 /** 4043 * rhythmdb_do_full_query_async_parsed: 4044 * @db: the #RhythmDB 4045 * @results: a #RhythmDBQueryResults instance to feed results to 4046 * @query: the query to run 4047 * 4048 * Asynchronously runs a parsed query across the database, feeding matching 4049 * entries to @results in chunks. This can only be called from the 4050 * main thread. 4051 * 4052 * Since @results is always a @RhythmDBQueryModel, 4053 * use the RhythmDBQueryModel::complete signal to identify when the 4054 * query is complete. 4055 */ 4056 void 4057 rhythmdb_do_full_query_async_parsed (RhythmDB *db, 4058 RhythmDBQueryResults *results, 4059 GPtrArray *query) 4060 { 4061 RhythmDBQueryThreadData *data; 4062 4063 data = g_new0 (RhythmDBQueryThreadData, 1); 4064 data->db = db; 4065 data->query = rhythmdb_query_copy (query); 4066 data->results = results; 4067 data->cancel = FALSE; 4068 4069 rhythmdb_read_enter (db); 4070 4071 rhythmdb_query_results_set_query (results, query); 4072 4073 g_object_ref (results); 4074 g_object_ref (db); 4075 g_atomic_int_inc (&db->priv->outstanding_threads); 4076 g_async_queue_ref (db->priv->action_queue); 4077 g_async_queue_ref (db->priv->event_queue); 4078 g_thread_pool_push (db->priv->query_thread_pool, data, NULL); 4079 } 4080 4081 /** 4082 * rhythmdb_do_full_query_async: 4083 * @db: the #RhythmDB 4084 * @results: a #RhythmDBQueryResults to feed results to 4085 * @Varargs: query parameters 4086 * 4087 * Asynchronously runs a query specified in the function arguments 4088 * across the database, feeding matching entries to @results in chunks. 4089 * This can only be called from the main thread. 4090 * 4091 * Since @results is always a @RhythmDBQueryModel, 4092 * use the RhythmDBQueryModel::complete signal to identify when the 4093 * query is complete. 4094 * 4095 * FIXME: example 4096 */ 4097 void 4098 rhythmdb_do_full_query_async (RhythmDB *db, 4099 RhythmDBQueryResults *results, 4100 ...) 4101 { 4102 GPtrArray *query; 4103 va_list args; 4104 4105 va_start (args, results); 4106 4107 query = rhythmdb_query_parse_valist (db, args); 4108 4109 rhythmdb_do_full_query_async_parsed (db, results, query); 4110 4111 rhythmdb_query_free (query); 4112 4113 va_end (args); 4114 } 4115 4116 static void 4117 rhythmdb_do_full_query_internal (RhythmDB *db, 4118 RhythmDBQueryResults *results, 4119 GPtrArray *query) 4120 { 4121 RhythmDBQueryThreadData *data; 4122 4123 data = g_new0 (RhythmDBQueryThreadData, 1); 4124 data->db = db; 4125 data->query = rhythmdb_query_copy (query); 4126 data->results = results; 4127 data->cancel = FALSE; 4128 4129 rhythmdb_read_enter (db); 4130 4131 rhythmdb_query_results_set_query (results, query); 4132 g_object_ref (results); 4133 4134 rhythmdb_query_internal (data); 4135 g_free (data); 4136 } 4137 4138 /** 4139 * rhythmdb_do_full_query_parsed: 4140 * @db: the #RhythmDB 4141 * @results: a #RhythmDBQueryResults instance to feed results to 4142 * @query: a parsed query 4143 * 4144 * Synchronously evaluates the parsed query @query, feeding results 4145 * to @results in chunks. Does not return until the query is complete. 4146 */ 4147 void 4148 rhythmdb_do_full_query_parsed (RhythmDB *db, 4149 RhythmDBQueryResults *results, 4150 GPtrArray *query) 4151 { 4152 rhythmdb_do_full_query_internal (db, results, query); 4153 } 4154 4155 /** 4156 * rhythmdb_do_full_query: 4157 * @db: the #RhythmDB 4158 * @results: a #RhythmDBQueryResults instance to feed results to 4159 * @Varargs: query parameters 4160 * 4161 * Synchronously evaluates @query, feeding results to @results in 4162 * chunks. Does not return until the query is complete. 4163 * This can only be called from the main thread. 4164 * 4165 * FIXME: example 4166 */ 4167 void 4168 rhythmdb_do_full_query (RhythmDB *db, 4169 RhythmDBQueryResults *results, 4170 ...) 4171 { 4172 GPtrArray *query; 4173 va_list args; 4174 4175 va_start (args, results); 4176 4177 query = rhythmdb_query_parse_valist (db, args); 4178 4179 rhythmdb_do_full_query_internal (db, results, query); 4180 4181 rhythmdb_query_free (query); 4182 4183 va_end (args); 4184 } 4185 4186 /* This should really be standard. */ 4187 #define ENUM_ENTRY(NAME, DESC) { NAME, "" #NAME "", DESC } 4188 4189 GType 4190 rhythmdb_query_type_get_type (void) 4191 { 4192 static GType etype = 0; 4193 4194 if (etype == 0) 4195 { 4196 static const GEnumValue values[] = 4197 { 4198 4199 ENUM_ENTRY (RHYTHMDB_QUERY_END, "query-end"), 4200 ENUM_ENTRY (RHYTHMDB_QUERY_DISJUNCTION, "disjunctive-marker"), 4201 ENUM_ENTRY (RHYTHMDB_QUERY_SUBQUERY, "subquery"), 4202 ENUM_ENTRY (RHYTHMDB_QUERY_PROP_EQUALS, "equals"), 4203 ENUM_ENTRY (RHYTHMDB_QUERY_PROP_NOT_EQUAL, "not-equal"), 4204 ENUM_ENTRY (RHYTHMDB_QUERY_PROP_LIKE, "fuzzy-match"), 4205 ENUM_ENTRY (RHYTHMDB_QUERY_PROP_NOT_LIKE, "inverted-fuzzy-match"), 4206 ENUM_ENTRY (RHYTHMDB_QUERY_PROP_PREFIX, "starts-with"), 4207 ENUM_ENTRY (RHYTHMDB_QUERY_PROP_SUFFIX, "ends-with"), 4208 ENUM_ENTRY (RHYTHMDB_QUERY_PROP_GREATER, "greater-than"), 4209 ENUM_ENTRY (RHYTHMDB_QUERY_PROP_LESS, "less-than"), 4210 ENUM_ENTRY (RHYTHMDB_QUERY_PROP_CURRENT_TIME_WITHIN, "within-current-time"), 4211 ENUM_ENTRY (RHYTHMDB_QUERY_PROP_CURRENT_TIME_NOT_WITHIN, "not-within-current-time"), 4212 ENUM_ENTRY (RHYTHMDB_QUERY_PROP_YEAR_EQUALS, "year-equals"), 4213 ENUM_ENTRY (RHYTHMDB_QUERY_PROP_YEAR_NOT_EQUAL, "year-not-equals"), 4214 ENUM_ENTRY (RHYTHMDB_QUERY_PROP_YEAR_GREATER, "year-greater-than"), 4215 ENUM_ENTRY (RHYTHMDB_QUERY_PROP_YEAR_LESS, "year-less-than"), 4216 { 0, 0, 0 } 4217 }; 4218 4219 etype = g_enum_register_static ("RhythmDBQueryType", values); 4220 } 4221 4222 return etype; 4223 } 4224 4225 GType 4226 rhythmdb_prop_type_get_type (void) 4227 { 4228 static GType etype = 0; 4229 4230 if (etype == 0) 4231 { 4232 int i; 4233 static GEnumValue values[G_N_ELEMENTS(rhythmdb_properties)]; 4234 g_assert(G_N_ELEMENTS(rhythmdb_properties)-1 == RHYTHMDB_NUM_PROPERTIES); 4235 for (i = 0; i < G_N_ELEMENTS(rhythmdb_properties)-1; i++) { 4236 g_assert (i == rhythmdb_properties[i].prop_id); 4237 values[i].value = rhythmdb_properties[i].prop_id; 4238 values[i].value_name = rhythmdb_properties[i].prop_name; 4239 values[i].value_nick = rhythmdb_properties[i].elt_name; 4240 } 4241 etype = g_enum_register_static ("RhythmDBPropType", values); 4242 } 4243 4244 return etype; 4245 } 4246 4247 void 4248 rhythmdb_emit_entry_deleted (RhythmDB *db, 4249 RhythmDBEntry *entry) 4250 { 4251 g_signal_emit (G_OBJECT (db), rhythmdb_signals[ENTRY_DELETED], 0, entry); 4252 } 4253 4254 static gboolean 4255 rhythmdb_entry_extra_metadata_accumulator (GSignalInvocationHint *ihint, 4256 GValue *return_accu, 4257 const GValue *handler_return, 4258 gpointer data) 4259 { 4260 if (handler_return == NULL) 4261 return TRUE; 4262 4263 g_value_copy (handler_return, return_accu); 4264 return (g_value_get_boxed (return_accu) == NULL); 4265 } 4266 4267 /** 4268 * rhythmdb_entry_request_extra_metadata: 4269 * @db: a #RhythmDB 4270 * @entry: a #RhythmDBEntry 4271 * @property_name: the metadata predicate 4272 * 4273 * Emits a request for extra metadata for the @entry. 4274 * The @property_name argument is emitted as the ::detail part of the 4275 * "entry_extra_metadata_request" signal. It should be a namespaced RDF 4276 * predicate e.g. from Dublin Core, MusicBrainz, or internal to Rhythmbox 4277 * (namespace "rb:"). Suitable predicates would be those that are expensive to 4278 * acquire or only apply to a limited range of entries. 4279 * Handlers capable of providing a particular predicate may ensure they only 4280 * see appropriate requests by supplying an appropriate ::detail part when 4281 * connecting to the signal. Upon a handler returning a non-%NULL value, 4282 * emission will be stopped and the value returned to the caller; if no 4283 * handlers return a non-%NULL value, the caller will receive %NULL. Priority 4284 * is determined by signal connection order, with %G_C