Attachment #391102 for bug #523838

View | Details | Raw Unified | Return to bug 523838
Collapse All | Expand All

Lines 231-237 NETWORK_MANAGER_REQUIRED=0.8 Link Here

(-)tracker-1.0.4.orig/configure.ac (-2 / +8 lines)
231	GSTREAMER_REQUIRED=0.10.31	231	GSTREAMER_REQUIRED=0.10.31
232	GUPNP_DLNA_REQUIRED=0.9.4	232	GUPNP_DLNA_REQUIRED=0.9.4
233	LIBPNG_REQUIRED=0.89	233	LIBPNG_REQUIRED=0.89
234	LIBMEDIAART_REQUIRED=0.1.0	234	LIBMEDIAART_REQUIRED=0.5.0
235		235
236	# 3.6.11 for sqlite_backup API	236	# 3.6.11 for sqlite_backup API
237	# 3.6.16 to fix test failures	237	# 3.6.16 to fix test failures
Lines 1073-1081 if test "x$enable_libmediaart" != "xno" Link Here
1073	LIBTRACKER_MINER_CFLAGS="$LIBTRACKER_MINER_CFLAGS $LIBMEDIAART_CFLAGS"	1073	LIBTRACKER_MINER_CFLAGS="$LIBTRACKER_MINER_CFLAGS $LIBMEDIAART_CFLAGS"
1074	LIBTRACKER_MINER_LIBS="$LIBTRACKER_MINER_LIBS $LIBMEDIAART_LIBS"	1074	LIBTRACKER_MINER_LIBS="$LIBTRACKER_MINER_LIBS $LIBMEDIAART_LIBS"
1075		1075
		1076	LIBTRACKER_EXTRACT_CFLAGS="$LIBTRACKER_EXTRACT_CFLAGS $LIBMEDIAART_CFLAGS"
		1077	LIBTRACKER_EXTRACT_LIBS="$LIBTRACKER_EXTRACT_LIBS $LIBMEDIAART_LIBS"
		1078
1076	TRACKER_EXTRACT_CFLAGS="$TRACKER_EXTRACT_CFLAGS $LIBMEDIAART_CFLAGS"	1079	TRACKER_EXTRACT_CFLAGS="$TRACKER_EXTRACT_CFLAGS $LIBMEDIAART_CFLAGS"
1077	TRACKER_EXTRACT_LIBS="$TRACKER_EXTRACT_LIBS $LIBMEDIAART_LIBS"	1080	TRACKER_EXTRACT_LIBS="$TRACKER_EXTRACT_LIBS $LIBMEDIAART_LIBS"
1078		1081
		1082	TRACKER_MINER_FS_CFLAGS="$TRACKER_MINER_FS_CFLAGS $LIBMEDIAART_CFLAGS"
		1083	TRACKER_MINER_FS_LIBS="$TRACKER_MINER_FS_LIBS $LIBMEDIAART_LIBS"
		1084
1079	# Used for .pc file...	1085	# Used for .pc file...
1080	LIBTRACKER_MINER_PC_REQUIRES="libmediaart-1.0"	1086	LIBTRACKER_MINER_PC_REQUIRES="libmediaart-1.0"
1081	AC_SUBST(LIBTRACKER_MINER_PC_REQUIRES)	1087	AC_SUBST(LIBTRACKER_MINER_PC_REQUIRES)
Lines 1762-1768 PKG_CHECK_MODULES(AVCODEC, Link Here
1762	AC_SUBST(AVCODEC_CFLAGS)	1768	AC_SUBST(AVCODEC_CFLAGS)
1763	AC_SUBST(AVCODEC_LIBS)	1769	AC_SUBST(AVCODEC_LIBS)
1764		1770
1765	PKG_CHECK_MODULES(AVCODEC,	1771	PKG_CHECK_MODULES(AVUTIL,
1766	[libavutil >= 0.8.4],	1772	[libavutil >= 0.8.4],
1767	[have_libavutil=yes],	1773	[have_libavutil=yes],
1768	[have_libavutil=no])	1774	[have_libavutil=no])

Lines 19-24 Link Here

(-)tracker-1.0.4.orig/src/libtracker-extract/tracker-extract-info.c (+56 lines)
19	* Author: Carlos Garnacho <carlos@lanedo.com>	19	* Author: Carlos Garnacho <carlos@lanedo.com>
20	*/	20	*/
21		21
		22	#include "config.h"
		23
22	#include "tracker-extract-info.h"	24	#include "tracker-extract-info.h"
23		25
24	/**	26	/**
Lines 46-51 struct _TrackerExtractInfo Link Here
46	gchar *mimetype;	48	gchar *mimetype;
47	gchar *graph;	49	gchar *graph;
48		50
		51	#ifdef HAVE_LIBMEDIAART
		52	MediaArtProcess *media_art_process;
		53	#endif
		54
49	gint ref_count;	55	gint ref_count;
50	};	56	};
51		57
Lines 84-89 tracker_extract_info_new (GFile *f Link Here
84		90
85	info->where_clause = NULL;	91	info->where_clause = NULL;
86		92
		93	#ifdef HAVE_LIBMEDIAART
		94	info->media_art_process = NULL;
		95	#endif
		96
87	info->ref_count = 1;	97	info->ref_count = 1;
88		98
89	return info;	99	return info;
Lines 294-296 tracker_extract_info_set_where_clause (T Link Here
294	g_free (info->where_clause);	304	g_free (info->where_clause);
295	info->where_clause = g_strdup (where);	305	info->where_clause = g_strdup (where);
296	}	306	}
		307
		308	#ifdef HAVE_LIBMEDIAART
		309
		310	/**
		311	* tracker_extract_info_get_media_art_process:
		312	* @info: a #TrackerExtractInfo
		313	*
		314	* Returns the #MediaArtProcess object that can be used to retrieve
		315	* and store media art caches found in extracted content.
		316	*
		317	* Returns: (transfer none): The #MediaArtProcess. This object should
		318	* not be unreferenced.
		319	*
		320	* Since: 1.2
		321	**/
		322	MediaArtProcess *
		323	tracker_extract_info_get_media_art_process (TrackerExtractInfo *info)
		324	{
		325	g_return_if_fail (info != NULL);
		326	return info->media_art_process;
		327	}
		328
		329	/**
		330	* tracker_extract_info_set_media_art_process:
		331	* @info: a #TrackerExtractInfo
		332	* @media_art_process: a #MediaArtProcess.
		333	*
		334	* Use @media_art_process for caching and looking up media art.
		335	*
		336	* Since: 1.2
		337	**/
		338	void
		339	tracker_extract_info_set_media_art_process (TrackerExtractInfo *info,
		340	MediaArtProcess *media_art_process)
		341	{
		342	g_return_if_fail (info != NULL);
		343	g_return_if_fail (MEDIA_ART_IS_PROCESS (media_art_process));
		344
		345	if (info->media_art_process) {
		346	g_object_unref (info->media_art_process);
		347	}
		348
		349	info->media_art_process = g_object_ref (media_art_process);
		350	}
		351
		352	#endif /* HAVE_LIBMEDIAART */

Lines 29-34 Link Here

(-)tracker-1.0.4.orig/src/libtracker-extract/tracker-extract-info.h (+12 lines)
29	#include <libtracker-sparql/tracker-sparql.h>	29	#include <libtracker-sparql/tracker-sparql.h>
30	#include <gio/gio.h>	30	#include <gio/gio.h>
31		31
		32	#ifdef HAVE_LIBMEDIAART
		33	#include <libmediaart/mediaart.h>
		34	#endif
		35
32	G_BEGIN_DECLS	36	G_BEGIN_DECLS
33		37
34	typedef struct _TrackerExtractInfo TrackerExtractInfo;	38	typedef struct _TrackerExtractInfo TrackerExtractInfo;
Lines 50-55 const gchar * tracker_extract_in Link Here
50	void tracker_extract_info_set_where_clause (TrackerExtractInfo *info,	54	void tracker_extract_info_set_where_clause (TrackerExtractInfo *info,
51	const gchar *where);	55	const gchar *where);
52		56
		57	#ifdef HAVE_LIBMEDIAART
		58
		59	MediaArtProcess * tracker_extract_info_get_media_art_process (TrackerExtractInfo *info);
		60	void tracker_extract_info_set_media_art_process (TrackerExtractInfo *info,
		61	MediaArtProcess *media_art_process);
		62
		63	#endif /* HAVE_LIBMEDIAART */
		64
53	G_END_DECLS	65	G_END_DECLS
54		66
55	#endif /* __LIBTRACKER_EXTRACT_INFO_H__ */	67	#endif /* __LIBTRACKER_EXTRACT_INFO_H__ */

Lines 73-78 typedef struct { Link Here

(-)tracker-1.0.4.orig/src/tracker-extract/tracker-extract.c (+41 lines)
73	gchar *force_module;	73	gchar *force_module;
74		74
75	gint unhandled_count;	75	gint unhandled_count;
		76
		77	#ifdef HAVE_LIBMEDIAART
		78	MediaArtProcess *media_art_process;
		79	#endif
76	} TrackerExtractPrivate;	80	} TrackerExtractPrivate;
77		81
78	typedef struct {	82	typedef struct {
Lines 131-136 tracker_extract_init (TrackerExtract *ob Link Here
131	priv->thread_pool = g_thread_pool_new ((GFunc) get_metadata,	135	priv->thread_pool = g_thread_pool_new ((GFunc) get_metadata,
132	NULL, 10, TRUE, NULL);	136	NULL, 10, TRUE, NULL);
133		137
		138	#ifdef HAVE_LIBMEDIAART
		139	GError *error = NULL;
		140
		141	priv->media_art_process = media_art_process_new (&error);
		142	if (!priv->media_art_process \|\| error) {
		143	g_warning ("Could not initialize media art, %s",
		144	error ? error->message : _("No error given"));
		145	g_error_free (error);
		146	}
		147	#endif
		148
134	g_mutex_init (&priv->task_mutex);	149	g_mutex_init (&priv->task_mutex);
135	}	150	}
136		151
Lines 152-157 tracker_extract_finalize (GObject *objec Link Here
152		167
153	g_hash_table_destroy (priv->statistics_data);	168	g_hash_table_destroy (priv->statistics_data);
154		169
		170	#ifdef HAVE_LIBMEDIAART
		171	if (priv->media_art_process) {
		172	g_object_unref (priv->media_art_process);
		173	}
		174	#endif
		175
155	g_mutex_clear (&priv->task_mutex);	176	g_mutex_clear (&priv->task_mutex);
156		177
157	G_OBJECT_CLASS (tracker_extract_parent_class)->finalize (object);	178	G_OBJECT_CLASS (tracker_extract_parent_class)->finalize (object);
Lines 280-285 get_file_metadata (TrackerExtractTask * Link Here
280	info = tracker_extract_info_new (file, task->mimetype, task->graph);	301	info = tracker_extract_info_new (file, task->mimetype, task->graph);
281	g_object_unref (file);	302	g_object_unref (file);
282		303
		304	#ifdef HAVE_LIBMEDIAART
		305	tracker_extract_info_set_media_art_process (info, tracker_extract_get_media_art_process (task->extract));
		306	#endif
		307
283	if (task->mimetype && *task->mimetype) {	308	if (task->mimetype && *task->mimetype) {
284	/* We know the mime */	309	/* We know the mime */
285	mime_used = g_strdup (task->mimetype);	310	mime_used = g_strdup (task->mimetype);
Lines 720-725 tracker_extract_file (TrackerExtract Link Here
720	g_object_unref (res);	745	g_object_unref (res);
721	}	746	}
722		747
		748	#ifdef HAVE_LIBMEDIAART
		749
		750	MediaArtProcess *
		751	tracker_extract_get_media_art_process (TrackerExtract *extract)
		752	{
		753	TrackerExtractPrivate *priv;
		754
		755	g_return_val_if_fail (TRACKER_IS_EXTRACT (extract), NULL);
		756
		757	priv = TRACKER_EXTRACT_GET_PRIVATE (extract);
		758
		759	return priv->media_art_process;
		760	}
		761
		762	#endif
		763
723	void	764	void
724	tracker_extract_get_metadata_by_cmdline (TrackerExtract *object,	765	tracker_extract_get_metadata_by_cmdline (TrackerExtract *object,
725	const gchar *uri,	766	const gchar *uri,





static void
tracker_extract_gstreamer (const gchar          *uri,
                           TrackerExtractInfo   *info,
                           TrackerSparqlBuilder *postupdate,
                           TrackerSparqlBuilder *metadata,
                           ExtractMime           type,
                           const gchar          *graph)
{
	TrackerSparqlBuilder *metadata, *preupdate, *postupdate;
	MetadataExtractor *extractor;
	GstBuffer *buffer;
	gchar *cue_sheet;
	gboolean success;

#ifdef HAVE_LIBMEDIAART
	MediaArtProcess *media_art_process;
#endif

	g_return_if_fail (uri);

	graph = tracker_extract_info_get_graph (info);
	metadata = tracker_extract_info_get_metadata_builder (info);
	preupdate = tracker_extract_info_get_preupdate_builder (info);
	postupdate = tracker_extract_info_get_postupdate_builder (info);

	g_return_if_fail (metadata);

	gst_init (NULL, NULL);

	extractor->tagcache = gst_tag_list_new_empty ();

#ifdef HAVE_LIBMEDIAART
	media_art_process = tracker_extract_info_get_media_art_process (info);
	extractor->media_art_type = MEDIA_ART_NONE;
#endif



#ifdef HAVE_LIBMEDIAART
		if (extractor->media_art_type != MEDIA_ART_NONE) {
			GError *error = NULL;
			gboolean success = TRUE;

			if (extractor->media_art_buffer) {
				success = media_art_process_buffer (media_art_process,
				                                    extractor->media_art_type,
				                                    MEDIA_ART_PROCESS_FLAGS_NONE,
				                                    tracker_extract_info_get_file (info),
				                                    extractor->media_art_buffer,
				                                    extractor->media_art_buffer_size,
				                                    extractor->media_art_buffer_mime,
				                                    extractor->media_art_artist,
				                                    extractor->media_art_title,
				                                    &error);
			} else {
				success = media_art_process_file (media_art_process,
				                                  extractor->media_art_type,
				                                  MEDIA_ART_PROCESS_FLAGS_NONE,
				                                  tracker_extract_info_get_file (info),
				                                  extractor->media_art_artist,
				                                  extractor->media_art_title,
				                                  &error);
			}

			if (!success || error) {
				g_warning ("Could not process media art for '%s', %s",
				           uri,
				           error ? error->message : "No error given");
				g_clear_error (&error);
			}
		}
#endif
	}

G_MODULE_EXPORT gboolean
tracker_extract_get_metadata (TrackerExtractInfo *info)
{
	TrackerSparqlBuilder *metadata, *preupdate, *postupdate;
	const gchar *mimetype;
	GFile *file;
	gchar *uri;
	const gchar *graph;
	const gchar *mimetype;
	graph = tracker_extract_info_get_graph (info);
	metadata = tracker_extract_info_get_metadata_builder (info);
	preupdate = tracker_extract_info_get_preupdate_builder (info);
	postupdate = tracker_extract_info_get_postupdate_builder (info);
	mimetype = tracker_extract_info_get_mimetype (info);

	file = tracker_extract_info_get_file (info);
	uri = g_file_get_uri (file);
	graph = tracker_extract_info_get_graph (info);
	mimetype = tracker_extract_info_get_mimetype (info);

#if defined(GSTREAMER_BACKEND_GUPNP_DLNA)
	if (g_str_has_prefix (mimetype, "dlna/")) {
		tracker_extract_gstreamer (uri, info, EXTRACT_MIME_GUESS, graph);
	} else
#endif /* GSTREAMER_BACKEND_GUPNP_DLNA */

	if (strcmp (mimetype, "image/svg+xml") == 0) {
		tracker_extract_gstreamer (uri, info, EXTRACT_MIME_SVG, graph);
	} else if (strcmp (mimetype, "video/3gpp") == 0 ||
	           strcmp (mimetype, "video/mp4") == 0 ||
                   strcmp (mimetype, "video/x-ms-asf") == 0 ||
                   strcmp (mimetype, "application/vnd.ms-asf") == 0 ||
	           strcmp (mimetype, "application/vnd.rn-realmedia") == 0) {
		tracker_extract_gstreamer (uri, info, EXTRACT_MIME_GUESS, graph);
	} else if (g_str_has_prefix (mimetype, "audio/")) {
		tracker_extract_gstreamer (uri, info, EXTRACT_MIME_AUDIO, graph);
	} else if (g_str_has_prefix (mimetype, "video/")) {
		tracker_extract_gstreamer (uri, info, EXTRACT_MIME_VIDEO, graph);
	} else if (g_str_has_prefix (mimetype, "image/")) {
		tracker_extract_gstreamer (uri, info, EXTRACT_MIME_IMAGE, graph);
	} else {
		g_free (uri);
		return FALSE;

Lines 60-65 void tracker_extract_file Link Here

(-)tracker-1.0.4.orig/src/tracker-extract/tracker-extract.h (+5 lines)
60	GAsyncReadyCallback cb,	60	GAsyncReadyCallback cb,
61	gpointer user_data);	61	gpointer user_data);
62		62
		63	#ifdef HAVE_LIBMEDIAART
		64	MediaArtProcess *
		65	tracker_extract_get_media_art_process (TrackerExtract *extract);
		66	#endif
		67
63	void tracker_extract_dbus_start (TrackerExtract *extract);	68	void tracker_extract_dbus_start (TrackerExtract *extract);
64	void tracker_extract_dbus_stop (TrackerExtract *extract);	69	void tracker_extract_dbus_stop (TrackerExtract *extract);
65		70




		}

#ifdef HAVE_LIBMEDIAART
		if (album_artist || album_title) {
			MediaArtProcess *media_art_process;
			GError *error = NULL;
			gboolean success;

			media_art_process = tracker_extract_info_get_media_art_process (info);
			success = media_art_process_file (media_art_process,
			                                  MEDIA_ART_ALBUM,
			                                  MEDIA_ART_PROCESS_FLAGS_NONE,
			                                  file,
			                                  album_artist,
			                                  album_title,
			                                  &error);

			if (!success || error) {
				g_warning ("Could not process media art for '%s', %s",
				           uri,
				           error ? error->message : "No error given");
				g_clear_error (&error);
			}
		}
#endif

		g_free(performer_uri);




	mp3_parse (buffer, buffer_size, audio_offset, uri, metadata, &md);

#ifdef HAVE_LIBMEDIAART
	if (md.performer || md.title) {
		MediaArtProcess *media_art_process;
		GError *error = NULL;
		gboolean success = TRUE;

		media_art_process = tracker_extract_info_get_media_art_process (info);

		if (md.media_art_data) {
			success = media_art_process_buffer (media_art_process,
			                                    MEDIA_ART_ALBUM,
			                                    MEDIA_ART_PROCESS_FLAGS_NONE,
			                                    file,
			                                    md.media_art_data,
			                                    md.media_art_size,
			                                    md.media_art_mime,
			                                    md.performer,
			                                    md.title,
			                                    &error);
		} else {
			success = media_art_process_file (media_art_process,
			                                  MEDIA_ART_ALBUM,
			                                  MEDIA_ART_PROCESS_FLAGS_NONE,
			                                  file,
			                                  md.performer,
			                                  md.title,
			                                  &error);
		}

		if (!success || error) {
			g_warning ("Could not process media art for '%s', %s",
			           uri,
			           error ? error->message : "No error given");
			g_clear_error (&error);
		}
	}
#endif
	g_free (md.media_art_data);
	g_free (md.media_art_mime);




	}

#ifdef HAVE_LIBMEDIAART
	if ((vd.album_artist || vd.artist) || vd.album) {
		MediaArtProcess *media_art_process;
		GError *error = NULL;
		gboolean success;

		media_art_process = tracker_extract_info_get_media_art_process (info);

		success = media_art_process_file (media_art_process,
		                                  MEDIA_ART_ALBUM,
		                                  MEDIA_ART_PROCESS_FLAGS_NONE,
		                                  file,
		                                  vd.album_artist ? vd.album_artist : vd.artist,
		                                  vd.album,
		                                  &error);

		if (!success || error) {
			gchar *uri;

			uri = g_file_get_uri (file);
			g_warning ("Could not process media art for '%s', %s",
			           uri,
			           error ? error->message : "No error given");
			g_free (uri);
			g_clear_error (&error);
		}
	}
#endif






	tracker_locale_init ();

#ifdef HAVE_LIBMEDIAART
	if (!media_art_init ()) {
		g_warning ("Could not initialize media art, will not be available");
	}
#endif

	/* This makes sure we don't steal all the system's resources */
	initialize_priority_and_scheduling (tracker_config_get_sched_idle (config),
	                                    tracker_db_manager_get_first_index_done () == FALSE);

	if (!object) {
		g_object_unref (file);
		g_free (uri);
#ifdef HAVE_LIBMEDIAART
		media_art_shutdown ();
#endif
		tracker_locale_shutdown ();
		return EXIT_FAILURE;
	}

	g_object_unref (file);
	g_free (uri);

#ifdef HAVE_LIBMEDIAART
	media_art_shutdown ();
#endif
	tracker_locale_shutdown ();

	return EXIT_SUCCESS;


	tracker_locale_init ();

#ifdef HAVE_LIBMEDIAART
	if (!media_art_init ()) {
		g_warning ("Could not initialize media art, will not be available");
	}
#endif

	controller = tracker_extract_controller_new (decorator);
	tracker_miner_start (TRACKER_MINER (decorator));


	tracker_miner_stop (TRACKER_MINER (decorator));

	/* Shutdown subsystems */
#ifdef HAVE_LIBMEDIAART
	media_art_shutdown ();
#endif
	tracker_locale_shutdown ();

	g_object_unref (extract);

Return to bug 523838

Lines 1558-1575 discoverer_init_and_run (MetadataExtract Link Here

(-)tracker-1.0.4.orig/src/tracker-extract/tracker-extract-gstreamer.c (-24 / +52 lines)
1558		1558
1559	static void	1559	static void
1560	tracker_extract_gstreamer (const gchar *uri,	1560	tracker_extract_gstreamer (const gchar *uri,
1561	TrackerSparqlBuilder *preupdate,	1561	TrackerExtractInfo *info,
1562	TrackerSparqlBuilder *postupdate,
1563	TrackerSparqlBuilder *metadata,
1564	ExtractMime type,	1562	ExtractMime type,
1565	const gchar *graph)	1563	const gchar *graph)
1566	{	1564	{
		1565	TrackerSparqlBuilder metadata, preupdate, *postupdate;
1567	MetadataExtractor *extractor;	1566	MetadataExtractor *extractor;
1568	GstBuffer *buffer;	1567	GstBuffer *buffer;
1569	gchar *cue_sheet;	1568	gchar *cue_sheet;
1570	gboolean success;	1569	gboolean success;
1571		1570
		1571	#ifdef HAVE_LIBMEDIAART
		1572	MediaArtProcess *media_art_process;
		1573	#endif
		1574
1572	g_return_if_fail (uri);	1575	g_return_if_fail (uri);
		1576
		1577	graph = tracker_extract_info_get_graph (info);
		1578	metadata = tracker_extract_info_get_metadata_builder (info);
		1579	preupdate = tracker_extract_info_get_preupdate_builder (info);
		1580	postupdate = tracker_extract_info_get_postupdate_builder (info);
		1581
1573	g_return_if_fail (metadata);	1582	g_return_if_fail (metadata);
1574		1583
1575	gst_init (NULL, NULL);	1584	gst_init (NULL, NULL);
Lines 1579-1584 tracker_extract_gstreamer (const gchar Link Here
1579	extractor->tagcache = gst_tag_list_new_empty ();	1588	extractor->tagcache = gst_tag_list_new_empty ();
1580		1589
1581	#ifdef HAVE_LIBMEDIAART	1590	#ifdef HAVE_LIBMEDIAART
		1591	media_art_process = tracker_extract_info_get_media_art_process (info);
1582	extractor->media_art_type = MEDIA_ART_NONE;	1592	extractor->media_art_type = MEDIA_ART_NONE;
1583	#endif	1593	#endif
1584		1594
Lines 1608-1620 tracker_extract_gstreamer (const gchar Link Here
1608		1618
1609	#ifdef HAVE_LIBMEDIAART	1619	#ifdef HAVE_LIBMEDIAART
1610	if (extractor->media_art_type != MEDIA_ART_NONE) {	1620	if (extractor->media_art_type != MEDIA_ART_NONE) {
1611	media_art_process (extractor->media_art_buffer,	1621	GError *error = NULL;
1612	extractor->media_art_buffer_size,	1622	gboolean success = TRUE;
1613	extractor->media_art_buffer_mime,	1623
1614	extractor->media_art_type,	1624	if (extractor->media_art_buffer) {
1615	extractor->media_art_artist,	1625	success = media_art_process_buffer (media_art_process,
1616	extractor->media_art_title,	1626	extractor->media_art_type,
1617	uri);	1627	MEDIA_ART_PROCESS_FLAGS_NONE,
		1628	tracker_extract_info_get_file (info),
		1629	extractor->media_art_buffer,
		1630	extractor->media_art_buffer_size,
		1631	extractor->media_art_buffer_mime,
		1632	extractor->media_art_artist,
		1633	extractor->media_art_title,
		1634	&error);
		1635	} else {
		1636	success = media_art_process_file (media_art_process,
		1637	extractor->media_art_type,
		1638	MEDIA_ART_PROCESS_FLAGS_NONE,
		1639	tracker_extract_info_get_file (info),
		1640	extractor->media_art_artist,
		1641	extractor->media_art_title,
		1642	&error);
		1643	}
		1644
		1645	if (!success \|\| error) {
		1646	g_warning ("Could not process media art for '%s', %s",
		1647	uri,
		1648	error ? error->message : "No error given");
		1649	g_clear_error (&error);
		1650	}
1618	}	1651	}
1619	#endif	1652	#endif
1620	}	1653	}
Lines 1646-1686 tracker_extract_gstreamer (const gchar Link Here
1646	G_MODULE_EXPORT gboolean	1679	G_MODULE_EXPORT gboolean
1647	tracker_extract_get_metadata (TrackerExtractInfo *info)	1680	tracker_extract_get_metadata (TrackerExtractInfo *info)
1648	{	1681	{
1649	TrackerSparqlBuilder metadata, preupdate, *postupdate;
1650	const gchar *mimetype;
1651	GFile *file;	1682	GFile *file;
1652	gchar *uri;	1683	gchar *uri;
1653	const gchar *graph;	1684	const gchar *graph;
1654		1685	const gchar *mimetype;
1655	graph = tracker_extract_info_get_graph (info);
1656	metadata = tracker_extract_info_get_metadata_builder (info);
1657	preupdate = tracker_extract_info_get_preupdate_builder (info);
1658	postupdate = tracker_extract_info_get_postupdate_builder (info);
1659	mimetype = tracker_extract_info_get_mimetype (info);
1660		1686
1661	file = tracker_extract_info_get_file (info);	1687	file = tracker_extract_info_get_file (info);
1662	uri = g_file_get_uri (file);	1688	uri = g_file_get_uri (file);
		1689	graph = tracker_extract_info_get_graph (info);
		1690	mimetype = tracker_extract_info_get_mimetype (info);
1663		1691
1664	#if defined(GSTREAMER_BACKEND_GUPNP_DLNA)	1692	#if defined(GSTREAMER_BACKEND_GUPNP_DLNA)
1665	if (g_str_has_prefix (mimetype, "dlna/")) {	1693	if (g_str_has_prefix (mimetype, "dlna/")) {
1666	tracker_extract_gstreamer (uri, preupdate, postupdate, metadata, EXTRACT_MIME_GUESS, graph);	1694	tracker_extract_gstreamer (uri, info, EXTRACT_MIME_GUESS, graph);
1667	} else	1695	} else
1668	#endif /* GSTREAMER_BACKEND_GUPNP_DLNA */	1696	#endif /* GSTREAMER_BACKEND_GUPNP_DLNA */
1669		1697
1670	if (strcmp (mimetype, "image/svg+xml") == 0) {	1698	if (strcmp (mimetype, "image/svg+xml") == 0) {
1671	tracker_extract_gstreamer (uri, preupdate, postupdate, metadata, EXTRACT_MIME_SVG, graph);	1699	tracker_extract_gstreamer (uri, info, EXTRACT_MIME_SVG, graph);
1672	} else if (strcmp (mimetype, "video/3gpp") == 0 \|\|	1700	} else if (strcmp (mimetype, "video/3gpp") == 0 \|\|
1673	strcmp (mimetype, "video/mp4") == 0 \|\|	1701	strcmp (mimetype, "video/mp4") == 0 \|\|
1674	strcmp (mimetype, "video/x-ms-asf") == 0 \|\|	1702	strcmp (mimetype, "video/x-ms-asf") == 0 \|\|
1675	strcmp (mimetype, "application/vnd.ms-asf") == 0 \|\|	1703	strcmp (mimetype, "application/vnd.ms-asf") == 0 \|\|
1676	strcmp (mimetype, "application/vnd.rn-realmedia") == 0) {	1704	strcmp (mimetype, "application/vnd.rn-realmedia") == 0) {
1677	tracker_extract_gstreamer (uri, preupdate, postupdate, metadata, EXTRACT_MIME_GUESS, graph);	1705	tracker_extract_gstreamer (uri, info, EXTRACT_MIME_GUESS, graph);
1678	} else if (g_str_has_prefix (mimetype, "audio/")) {	1706	} else if (g_str_has_prefix (mimetype, "audio/")) {
1679	tracker_extract_gstreamer (uri, preupdate, postupdate, metadata, EXTRACT_MIME_AUDIO, graph);	1707	tracker_extract_gstreamer (uri, info, EXTRACT_MIME_AUDIO, graph);
1680	} else if (g_str_has_prefix (mimetype, "video/")) {	1708	} else if (g_str_has_prefix (mimetype, "video/")) {
1681	tracker_extract_gstreamer (uri, preupdate, postupdate, metadata, EXTRACT_MIME_VIDEO, graph);	1709	tracker_extract_gstreamer (uri, info, EXTRACT_MIME_VIDEO, graph);
1682	} else if (g_str_has_prefix (mimetype, "image/")) {	1710	} else if (g_str_has_prefix (mimetype, "image/")) {
1683	tracker_extract_gstreamer (uri, preupdate, postupdate, metadata, EXTRACT_MIME_IMAGE, graph);	1711	tracker_extract_gstreamer (uri, info, EXTRACT_MIME_IMAGE, graph);
1684	} else {	1712	} else {
1685	g_free (uri);	1713	g_free (uri);
1686	return FALSE;	1714	return FALSE;

Lines 2647-2659 tracker_extract_get_metadata (TrackerExt Link Here

(-)tracker-1.0.4.orig/src/tracker-extract/tracker-extract-mp3.c (-7 / +35 lines)
2647	mp3_parse (buffer, buffer_size, audio_offset, uri, metadata, &md);	2647	mp3_parse (buffer, buffer_size, audio_offset, uri, metadata, &md);
2648		2648
2649	#ifdef HAVE_LIBMEDIAART	2649	#ifdef HAVE_LIBMEDIAART
2650	media_art_process (md.media_art_data,	2650	if (md.performer \|\| md.title) {
2651	md.media_art_size,	2651	MediaArtProcess *media_art_process;
2652	md.media_art_mime,	2652	GError *error = NULL;
2653	MEDIA_ART_ALBUM,	2653	gboolean success = TRUE;
2654	md.performer,	2654
2655	md.album,	2655	media_art_process = tracker_extract_info_get_media_art_process (info);
2656	uri);	2656
		2657	if (md.media_art_data) {
		2658	success = media_art_process_buffer (media_art_process,
		2659	MEDIA_ART_ALBUM,
		2660	MEDIA_ART_PROCESS_FLAGS_NONE,
		2661	file,
		2662	md.media_art_data,
		2663	md.media_art_size,
		2664	md.media_art_mime,
		2665	md.performer,
		2666	md.title,
		2667	&error);
		2668	} else {
		2669	success = media_art_process_file (media_art_process,
		2670	MEDIA_ART_ALBUM,
		2671	MEDIA_ART_PROCESS_FLAGS_NONE,
		2672	file,
		2673	md.performer,
		2674	md.title,
		2675	&error);
		2676	}
		2677
		2678	if (!success \|\| error) {
		2679	g_warning ("Could not process media art for '%s', %s",
		2680	uri,
		2681	error ? error->message : "No error given");
		2682	g_clear_error (&error);
		2683	}
		2684	}
2657	#endif	2685	#endif
2658	g_free (md.media_art_data);	2686	g_free (md.media_art_data);
2659	g_free (md.media_art_mime);	2687	g_free (md.media_art_mime);

Lines 514-529 tracker_extract_get_metadata (TrackerExt Link Here

(-)tracker-1.0.4.orig/src/tracker-extract/tracker-extract-vorbis.c (-10 / +25 lines)
514	}	514	}
515		515
516	#ifdef HAVE_LIBMEDIAART	516	#ifdef HAVE_LIBMEDIAART
517	{	517	if ((vd.album_artist \|\| vd.artist) \|\| vd.album) {
518	gchar *uri = g_file_get_uri (file);	518	MediaArtProcess *media_art_process;
519	media_art_process (NULL,	519	GError *error = NULL;
520	0,	520	gboolean success;
521	NULL,	521
522	MEDIA_ART_ALBUM,	522	media_art_process = tracker_extract_info_get_media_art_process (info);
523	vd.album_artist ? vd.album_artist : vd.artist,	523
524	vd.album,	524	success = media_art_process_file (media_art_process,
525	uri);	525	MEDIA_ART_ALBUM,
526	g_free (uri);	526	MEDIA_ART_PROCESS_FLAGS_NONE,
		527	file,
		528	vd.album_artist ? vd.album_artist : vd.artist,
		529	vd.album,
		530	&error);
		531
		532	if (!success \|\| error) {
		533	gchar *uri;
		534
		535	uri = g_file_get_uri (file);
		536	g_warning ("Could not process media art for '%s', %s",
		537	uri,
		538	error ? error->message : "No error given");
		539	g_free (uri);
		540	g_clear_error (&error);
		541	}
527	}	542	}
528	#endif	543	#endif
529		544

Lines 262-273 run_standalone (TrackerConfig *config) Link Here

(-)tracker-1.0.4.orig/src/tracker-extract/tracker-main.c (-21 lines)
262		262
263	tracker_locale_init ();	263	tracker_locale_init ();
264		264
265	#ifdef HAVE_LIBMEDIAART
266	if (!media_art_init ()) {
267	g_warning ("Could not initialize media art, will not be available");
268	}
269	#endif
270
271	/* This makes sure we don't steal all the system's resources */	265	/* This makes sure we don't steal all the system's resources */
272	initialize_priority_and_scheduling (tracker_config_get_sched_idle (config),	266	initialize_priority_and_scheduling (tracker_config_get_sched_idle (config),
273	tracker_db_manager_get_first_index_done () == FALSE);	267	tracker_db_manager_get_first_index_done () == FALSE);
Lines 280-288 run_standalone (TrackerConfig *config) Link Here
280	if (!object) {	274	if (!object) {
281	g_object_unref (file);	275	g_object_unref (file);
282	g_free (uri);	276	g_free (uri);
283	#ifdef HAVE_LIBMEDIAART
284	media_art_shutdown ();
285	#endif
286	tracker_locale_shutdown ();	277	tracker_locale_shutdown ();
287	return EXIT_FAILURE;	278	return EXIT_FAILURE;
288	}	279	}
Lines 295-303 run_standalone (TrackerConfig *config) Link Here
295	g_object_unref (file);	286	g_object_unref (file);
296	g_free (uri);	287	g_free (uri);
297		288
298	#ifdef HAVE_LIBMEDIAART
299	media_art_shutdown ();
300	#endif
301	tracker_locale_shutdown ();	289	tracker_locale_shutdown ();
302		290
303	return EXIT_SUCCESS;	291	return EXIT_SUCCESS;
Lines 404-415 main (int argc, char *argv[]) Link Here
404		392
405	tracker_locale_init ();	393	tracker_locale_init ();
406		394
407	#ifdef HAVE_LIBMEDIAART
408	if (!media_art_init ()) {
409	g_warning ("Could not initialize media art, will not be available");
410	}
411	#endif
412
413	controller = tracker_extract_controller_new (decorator);	395	controller = tracker_extract_controller_new (decorator);
414	tracker_miner_start (TRACKER_MINER (decorator));	396	tracker_miner_start (TRACKER_MINER (decorator));
415		397
Lines 424-432 main (int argc, char *argv[]) Link Here
424	tracker_miner_stop (TRACKER_MINER (decorator));	406	tracker_miner_stop (TRACKER_MINER (decorator));
425		407
426	/* Shutdown subsystems */	408	/* Shutdown subsystems */
427	#ifdef HAVE_LIBMEDIAART
428	media_art_shutdown ();
429	#endif
430	tracker_locale_shutdown ();	409	tracker_locale_shutdown ();
431		410
432	g_object_unref (extract);	411	g_object_unref (extract);