brasero r1567 - in trunk: . src

[philippr svn gnome org]

Author: philippr
Date: Tue Nov 25 20:12:17 2008
New Revision: 1567
URL: http://svn.gnome.org/viewvc/brasero?rev=1567&view=rev

Log:
	Try to fix
	#561050 â Brasero Hangs after trying to add mp3 files in an Audio Project
	and perhaps #558291 â Crash after New Audio Project and change path into folder /etc

	* src/brasero-io.c (brasero_io_find_metadata),
	(brasero_io_wait_for_metadata), (brasero_io_get_metadata_info),
	(brasero_io_init), (brasero_io_finalize):
	* src/brasero-metadata.c (brasero_metadata_stop),
	(brasero_metadata_set_uri), (brasero_metadata_wait_cancelled),
	(brasero_metadata_wait),
	(brasero_metadata_increase_listener_number),
	(brasero_metadata_decrease_listener_number),
	(brasero_metadata_get_result), (brasero_metadata_init),
	(brasero_metadata_finalize):
	* src/brasero-metadata.h:
	* src/brasero-split-dialog.c
	(brasero_split_dialog_metadata_finished_cb):


Modified:
   trunk/ChangeLog
   trunk/src/brasero-io.c
   trunk/src/brasero-metadata.c
   trunk/src/brasero-metadata.h
   trunk/src/brasero-split-dialog.c

Modified: trunk/src/brasero-io.c
==============================================================================
--- trunk/src/brasero-io.c	(original)
+++ trunk/src/brasero-io.c	Tue Nov 25 20:12:17 2008
@@ -59,6 +59,8 @@
 	gint results_id;
 
 	/* used for metadata */
+	GMutex *lock_metadata;
+
 	GSList *metadatas;
 	GSList *metadata_running;
 
@@ -789,36 +791,20 @@
 	/* FIXME: what about silences */
 }
 
-static gboolean
-brasero_io_get_metadata_info (BraseroIO *self,
-			      GCancellable *cancel,
-			      const gchar *uri,
-			      GFileInfo *info,
-			      BraseroMetadataFlag flags,
-			      BraseroMetadataInfo *meta_info)
+static BraseroMetadata *
+brasero_io_find_metadata (BraseroIO *self,
+			  GCancellable *cancel,
+			  const gchar *uri,
+			  BraseroMetadataFlag flags,
+			  GError **error)
 {
-	BraseroMetadata *metadata = NULL;
-	BraseroIOPrivate *priv;
-	const gchar *mime;
-	gboolean result;
 	GSList *iter;
-	GList *node;
-
-	if (g_cancellable_is_cancelled (cancel))
-		return FALSE;
+	BraseroIOPrivate *priv;
+	BraseroMetadata *metadata;
 
 	priv = BRASERO_IO_PRIVATE (self);
 
-	mime = g_file_info_get_content_type (info);
-	if (mime
-	&& (!strncmp (mime, "image/", 6)
-	||  !strcmp (mime, "text/plain")
-	||  !strcmp (mime, "application/x-cue") /* this one make gstreamer crash */
-	||  !strcmp (mime, "application/x-cd-image")
-	||  !strcmp (mime, "application/octet-stream")))
-		return FALSE;
-
-	g_mutex_lock (priv->lock);
+	BRASERO_BURN_LOG ("Retrieving available metadata %s", uri);
 
 	/* First see if a metadata is running with the same uri and the same
 	 * flags as us. In this case, acquire the lock and wait for the lock
@@ -827,11 +813,10 @@
 	 * an available metadata won't be able to have this one. */
 	for (iter = priv->metadata_running; iter; iter = iter->next) {
 		const gchar *metadata_uri;
-		BraseroMetadata *metadata_iter;
 		BraseroMetadataFlag metadata_flags;
 
-		metadata_iter = iter->data;
-		metadata_uri = brasero_metadata_get_uri (metadata_iter);
+		metadata = iter->data;
+		metadata_uri = brasero_metadata_get_uri (metadata);
 		if (!metadata_uri) {
 			/* It could a metadata that was running but failed to
 			 * retrieve anything and is waiting to be inserted back
@@ -839,7 +824,7 @@
 			continue;
 		}
 
-		metadata_flags = brasero_metadata_get_flags (metadata_iter);
+		metadata_flags = brasero_metadata_get_flags (metadata);
 
 		if (((flags & metadata_flags) == flags)
 		&&  !strcmp (uri, metadata_uri)) {
@@ -848,93 +833,66 @@
 			 * Let the thread that got the lock first move it back
 			 * to waiting queue */
 			BRASERO_BURN_LOG ("Already ongoing search for %s", uri);
-
-			metadata = metadata_iter;
-
-			g_mutex_unlock (priv->lock);
-			brasero_metadata_lock (metadata);
-			result = brasero_metadata_set_info (metadata, meta_info);
-			brasero_metadata_unlock (metadata);
-
-			return result;
+			brasero_metadata_increase_listener_number (metadata);
+			return metadata;
 		}
 	}
-	/* Seek in the buffer if we have already explored these metadata. Check 
-	 * the info last modified time in case a result should be updated. */
-	node = g_queue_find_custom (priv->meta_buffer,
-				    uri,
-				    brasero_io_metadata_lookup_buffer);
-	if (node) {
-		guint64 last_modified;
-		BraseroIOMetadataCached *cached;
-
-		cached = node->data;
-		last_modified = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_STANDARD_SIZE);
-		if (last_modified == cached->last_modified) {
-			if (flags & BRASERO_METADATA_FLAG_THUMBNAIL) {
-				/* If there isn't any snapshot retry */
-				if (cached->info->snapshot) {
-					brasero_metadata_info_copy (meta_info, cached->info);
-					g_mutex_unlock (priv->lock);
-					return TRUE;
-				}
-			}
-			else {
-				brasero_metadata_info_copy (meta_info, cached->info);
-				g_mutex_unlock (priv->lock);
-				return TRUE;
-			}
-		}
 
-		/* remove it from the queue => no same URI twice */
-		g_queue_remove (priv->meta_buffer, cached);
-		brasero_io_metadata_cached_free (cached);
+	/* Grab an available metadata (NOTE: there should always be at least one
+	 * since we run 2 threads at max and have two metadatas available) */
+	while (!priv->metadatas) {
+		if (g_cancellable_is_cancelled (cancel))
+			return NULL;
 
-		BRASERO_BURN_LOG ("Updating cache information for %s", uri);
+		g_mutex_unlock (priv->lock_metadata);
+		g_usleep (250);
+		g_mutex_lock (priv->lock_metadata);
 	}
 
-	/* grab an available metadata (NOTE: there should always be at least one
-	 * since we run 2 threads at max and have two metadatas available) */
-	do {
+	/* One metadata is finally available */
+	metadata = priv->metadatas->data;
 
-		if (g_cancellable_is_cancelled (cancel)) {
-			g_mutex_unlock (priv->lock);
-			return FALSE;
-		}
+	/* Try to set it up for running */
+	if (!brasero_metadata_set_uri (metadata, flags, uri, error))
+		return NULL;
 
-		for (iter = priv->metadatas; iter; iter = iter->next) {
-			BraseroMetadata *metadata_iter;
+	/* The metadata is ready for running put it in right queue */
+	brasero_metadata_increase_listener_number (metadata);
+	priv->metadatas = g_slist_remove (priv->metadatas, metadata);
+	priv->metadata_running = g_slist_prepend (priv->metadata_running, metadata);
 
-			metadata_iter = iter->data;
-			if (brasero_metadata_try_lock (metadata_iter)) {
-				metadata = priv->metadatas->data;
-				priv->metadatas = g_slist_remove (priv->metadatas, metadata);
-				priv->metadata_running = g_slist_prepend (priv->metadata_running, metadata);
-				break;
-			}
-		}
+	return metadata;
+}
 
-		g_mutex_unlock (priv->lock);
-		g_usleep (250);
-		g_mutex_lock (priv->lock);
+static gboolean
+brasero_io_wait_for_metadata (BraseroIO *self,
+			      GCancellable *cancel,
+			      GFileInfo *info,
+			      BraseroMetadata *metadata,
+			      BraseroMetadataInfo *meta_info)
+{
+	gboolean result;
+	gboolean is_last;
+	BraseroIOPrivate *priv;
 
-	} while (!metadata);
+	priv = BRASERO_IO_PRIVATE (self);
 
-	g_mutex_unlock (priv->lock);
+	brasero_metadata_wait (metadata, cancel);
+	g_mutex_lock (priv->lock_metadata);
 
-	result = brasero_metadata_get_info_wait (metadata,
-						 cancel,
-						 uri,
-						 flags,
-						 NULL);
-	brasero_metadata_set_info (metadata, meta_info);
+	is_last = brasero_metadata_decrease_listener_number (metadata);
 
-	g_mutex_lock (priv->lock);
+	if (!g_cancellable_is_cancelled (cancel))
+		result = brasero_metadata_get_result (metadata, meta_info, NULL);
+	else
+		result = FALSE;
 
-	/* release the lock on the metadata in case another thread is waiting 
-	 * for this search result. That way that thread will be able to wake
-	 * up. */
-	brasero_metadata_unlock (metadata);
+	/* Only the last thread waiting for the result will put metadata back
+	 * into the available queue and cache the results. */
+	if (!is_last) {
+		g_mutex_unlock (priv->lock_metadata);
+		return result;
+	}
 
 	if (result) {
 		/* see if we should add it to the buffer */
@@ -945,7 +903,7 @@
 			cached->last_modified = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_STANDARD_SIZE);
 
 			cached->info = g_new0 (BraseroMetadataInfo, 1);
-			brasero_metadata_set_info (metadata, cached->info);
+			brasero_metadata_get_result (metadata, cached->info, NULL);
 
 			g_queue_push_head (priv->meta_buffer, cached);
 			if (g_queue_get_length (priv->meta_buffer) > MAX_BUFFERED_META) {
@@ -955,14 +913,98 @@
 		}
 	}
 
+	/* Make sure it is stopped */
+	BRASERO_BURN_LOG ("Stopping metadata information retrieval (%p)", metadata);
+	brasero_metadata_cancel (metadata);
+
 	priv->metadata_running = g_slist_remove (priv->metadata_running, metadata);
-	priv->metadatas = g_slist_prepend (priv->metadatas, metadata);
+	priv->metadatas = g_slist_append (priv->metadatas, metadata);
 
-	g_mutex_unlock (priv->lock);
+	g_mutex_unlock (priv->lock_metadata);
 
 	return result;
 }
 
+static gboolean
+brasero_io_get_metadata_info (BraseroIO *self,
+			      GCancellable *cancel,
+			      const gchar *uri,
+			      GFileInfo *info,
+			      BraseroMetadataFlag flags,
+			      BraseroMetadataInfo *meta_info)
+{
+	BraseroMetadata *metadata = NULL;
+	BraseroIOPrivate *priv;
+	const gchar *mime;
+	GList *node;
+
+	if (g_cancellable_is_cancelled (cancel))
+		return FALSE;
+
+	priv = BRASERO_IO_PRIVATE (self);
+
+	mime = g_file_info_get_content_type (info);
+	if (mime
+	&& (!strncmp (mime, "image/", 6)
+	||  !strcmp (mime, "text/plain")
+	||  !strcmp (mime, "application/x-cue") /* this one make gstreamer crash */
+	||  !strcmp (mime, "application/x-cd-image")
+	||  !strcmp (mime, "application/octet-stream")))
+		return FALSE;
+
+	BRASERO_BURN_LOG ("Retrieving metadata info");
+	g_mutex_lock (priv->lock_metadata);
+
+	/* Seek in the buffer if we have already explored these metadata. Check 
+	 * the info last modified time in case a result should be updated. */
+	node = g_queue_find_custom (priv->meta_buffer,
+				    uri,
+				    brasero_io_metadata_lookup_buffer);
+	if (node) {
+		guint64 last_modified;
+		BraseroIOMetadataCached *cached;
+
+		cached = node->data;
+		last_modified = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_STANDARD_SIZE);
+		if (last_modified == cached->last_modified) {
+			if (flags & BRASERO_METADATA_FLAG_THUMBNAIL) {
+				/* If there isn't any snapshot retry */
+				if (cached->info->snapshot) {
+					brasero_metadata_info_copy (meta_info, cached->info);
+					g_mutex_unlock (priv->lock_metadata);
+					return TRUE;
+				}
+			}
+			else {
+				brasero_metadata_info_copy (meta_info, cached->info);
+				g_mutex_unlock (priv->lock_metadata);
+				return TRUE;
+			}
+		}
+
+		/* Found the same URI but it didn't have all required flags so
+		 * we'll get another metadata information; Remove it from the
+		 * queue => no same URI twice */
+		g_queue_remove (priv->meta_buffer, cached);
+		brasero_io_metadata_cached_free (cached);
+
+		BRASERO_BURN_LOG ("Updating cache information for %s", uri);
+	}
+
+	/* Find a metadata */
+	metadata = brasero_io_find_metadata (self, cancel, uri, flags, NULL);
+	g_mutex_unlock (priv->lock_metadata);
+
+	if (!metadata)
+		return FALSE;
+
+	return brasero_io_wait_for_metadata (self,
+					     cancel,
+					     info,
+					     metadata,
+					     meta_info);
+}
+
 /**
  * Used to get information about files
  */
@@ -2700,6 +2742,7 @@
 	priv = BRASERO_IO_PRIVATE (object);
 
 	priv->lock = g_mutex_new ();
+	priv->lock_metadata = g_mutex_new ();
 
 	priv->meta_buffer = g_queue_new ();
 
@@ -2782,6 +2825,11 @@
 		priv->lock = NULL;
 	}
 
+	if (priv->lock_metadata) {
+		g_mutex_free (priv->lock_metadata);
+		priv->lock_metadata = NULL;
+	}
+
 	if (priv->mounted) {
 		GSList *iter;
 

Modified: trunk/src/brasero-metadata.c
==============================================================================
--- trunk/src/brasero-metadata.c	(original)
+++ trunk/src/brasero-metadata.c	Tue Nov 25 20:12:17 2008
@@ -81,10 +81,9 @@
 	GSList *downloads;
 
 	GMutex *mutex;
-	GCond *cond;
+	GSList *conditions;
 
-	/* Used by threads */
-	GMutex *lock;
+	gint listeners;
 
 	guint started:1;
 	guint moved_forward:1;
@@ -247,6 +246,7 @@
 brasero_metadata_stop (BraseroMetadata *self)
 {
 	BraseroMetadataPrivate *priv;
+	GSList *iter;
 
 	priv = BRASERO_METADATA_PRIVATE (self);
 
@@ -254,22 +254,11 @@
   			  priv->info ? priv->info->uri:"Unknown",
 			  self);
 
-	/* Destroy the pipeline as it has become unusable. */
+	g_mutex_lock (priv->mutex);
+
+	/* Destroy the pipeline as it has become un-re-usable */
 	if (priv->pipeline)
 		brasero_metadata_destroy_pipeline (self);
-/*	else if (priv->pipeline)
-	{	
-		GstState state = GST_STATE_NULL;
-
-		gst_element_set_state (priv->pipeline, GST_STATE_NULL);
-		gst_element_get_state (priv->pipeline, &state, NULL, GST_MSECOND);
-		while (state != GST_STATE_NULL)
-			gst_element_get_state (priv->pipeline,
-					       &state,
-					       NULL,
-					       GST_MSECOND);
-	}
-*/
 
 	if (priv->progress_id) {
 		g_source_remove (priv->progress_id);
@@ -283,7 +272,9 @@
 
 	/* That's automatic missing plugin installation */
 	if (priv->missing_plugins) {
-		g_slist_foreach (priv->missing_plugins, (GFunc) gst_mini_object_unref, NULL);
+		g_slist_foreach (priv->missing_plugins,
+				 (GFunc) gst_mini_object_unref,
+				 NULL);
 		g_slist_free (priv->missing_plugins);
 		priv->missing_plugins = NULL;
 	}
@@ -305,11 +296,14 @@
 	/* stop the pipeline */
 	priv->started = 0;
 
-	/* that's for sync_wait */
-	g_mutex_lock (priv->mutex);
+	/* Tell all the waiting threads that we're done */
+	for (iter = priv->conditions; iter; iter = iter->next) {
+		GCond *condition;
+
+		condition = iter->data;
+		g_cond_broadcast (condition);
+	}
 
-	/* use broadcast here as there could be more than one thread waiting */
-	g_cond_broadcast (priv->cond);
 	g_mutex_unlock (priv->mutex);
 }
 
@@ -1468,26 +1462,19 @@
 	return TRUE;
 }
 
-static void
-brasero_metadata_cancelled_cb (GCancellable *cancel,
-			       BraseroMetadata *self)
-{
-	brasero_metadata_cancel (self);
-}
-
 gboolean
-brasero_metadata_get_info_wait (BraseroMetadata *self,
-				GCancellable *cancel,
-				const gchar *uri,
-				BraseroMetadataFlag flags,
-				GError **error)
+brasero_metadata_set_uri (BraseroMetadata *self,
+			  BraseroMetadataFlag flags,
+			  const gchar *uri,
+			  GError **error)
 {
 	GstStateChangeReturn state_change;
 	BraseroMetadataPrivate *priv;
-	gulong cancel_signal = 0;
 
 	priv = BRASERO_METADATA_PRIVATE (self);
 
+	g_mutex_lock (priv->mutex);
+
 	priv->flags = flags;
 	if (!brasero_metadata_set_new_uri (self, uri)) {
 		g_propagate_error (error, priv->error);
@@ -1496,64 +1483,20 @@
 		brasero_metadata_info_free (priv->info);
 		priv->info = NULL;
 
-		return FALSE;
-	}
-
-	g_mutex_lock (priv->mutex);
-
-	/* Now wait ... but check a last time otherwise we wouldn't get the
-	 * any notice of cancellation if it had been cancelled before we 
-	 * connected to the signal */
-	if (g_cancellable_is_cancelled (cancel)) {
 		g_mutex_unlock (priv->mutex);
-
-		brasero_metadata_stop (self);
-		brasero_metadata_info_free (priv->info);
-		priv->info = NULL;
-
 		return FALSE;
 	}
 
-	cancel_signal = g_signal_connect (cancel,
-					  "cancelled",
-					  G_CALLBACK (brasero_metadata_cancelled_cb),
-					  self);
-
 	priv->started = 1;
 	state_change = gst_element_set_state (GST_ELEMENT (priv->pipeline),
 					      BRASERO_METADATA_INITIAL_STATE);
 
-	if (state_change != GST_STATE_CHANGE_FAILURE) {
-		/* no need to wait for a condition if it failed */
-		g_cond_wait (priv->cond, priv->mutex);
-		g_mutex_unlock (priv->mutex);
-	}
-	else {
-		g_mutex_unlock (priv->mutex);
-		brasero_metadata_stop (self);
-	}
-
-	g_signal_handler_disconnect (cancel, cancel_signal);
-
-	if (priv->pipeline)
-		gst_element_set_state (GST_ELEMENT (priv->pipeline), GST_STATE_NULL);
-
-	if (priv->error) {
-		if (error) {
-			g_propagate_error (error, priv->error);
-			priv->error = NULL;
-		} 
-		else {
-			BRASERO_BURN_LOG ("ERROR getting metadata : %s", priv->error->message);
-			g_error_free (priv->error);
-			priv->error = NULL;
-		}
+	g_mutex_unlock (priv->mutex);
 
-		return FALSE;
-	}
+	if (state_change == GST_STATE_CHANGE_FAILURE)
+		brasero_metadata_stop (self);
 
-	return (g_cancellable_is_cancelled (cancel) == FALSE) &&
-	       (state_change != GST_STATE_CHANGE_FAILURE);
+	return (state_change != GST_STATE_CHANGE_FAILURE);
 }
 
 gboolean
@@ -1590,31 +1533,71 @@
 	return priv->started;
 }
 
+static void
+brasero_metadata_wait_cancelled (GCancellable *cancel,
+				 GCond *condition)
+{
+	BRASERO_BURN_LOG ("Thread waiting for retrieval end cancelled");
+	g_cond_broadcast (condition);
+}
+
 void
-brasero_metadata_lock (BraseroMetadata *self)
+brasero_metadata_wait (BraseroMetadata *self,
+		       GCancellable *cancel)
 {
 	BraseroMetadataPrivate *priv;
+	GCond *condition;
+	gulong sig;
 
 	priv = BRASERO_METADATA_PRIVATE (self);
-	g_mutex_lock (priv->lock);
+
+	BRASERO_BURN_LOG ("Metadata lock and wait %p", self);
+
+	g_mutex_lock (priv->mutex);
+
+	if (!priv->started) {
+		/* Maybe we were waiting for the lock which was held by the 
+		 * finish function. That's why we check if it didn't finish in
+		 * the mean time. */
+		g_mutex_unlock (priv->mutex);
+		return;
+	}
+
+	condition = g_cond_new ();
+	priv->conditions = g_slist_prepend (priv->conditions, condition);
+
+	sig = g_signal_connect (cancel,
+				"cancelled",
+				G_CALLBACK (brasero_metadata_wait_cancelled),
+				condition);
+
+	if (!g_cancellable_is_cancelled (cancel))
+		g_cond_wait (condition, priv->mutex);
+
+	priv->conditions = g_slist_remove (priv->conditions, condition);
+	g_cond_free (condition);
+
+	g_mutex_unlock (priv->mutex);
+
+	g_signal_handler_disconnect (cancel, sig);
 }
 
 void
-brasero_metadata_unlock (BraseroMetadata *self)
+brasero_metadata_increase_listener_number (BraseroMetadata *self)
 {
 	BraseroMetadataPrivate *priv;
 
 	priv = BRASERO_METADATA_PRIVATE (self);
-	g_mutex_unlock (priv->lock);
+	g_atomic_int_inc (&priv->listeners);
 }
 
 gboolean
-brasero_metadata_try_lock (BraseroMetadata *self)
+brasero_metadata_decrease_listener_number (BraseroMetadata *self)
 {
 	BraseroMetadataPrivate *priv;
 
 	priv = BRASERO_METADATA_PRIVATE (self);
-	return g_mutex_trylock (priv->lock);
+	return g_atomic_int_dec_and_test (&priv->listeners);
 }
 
 const gchar *
@@ -1691,16 +1674,27 @@
 }
 
 gboolean
-brasero_metadata_set_info (BraseroMetadata *self,
-			   BraseroMetadataInfo *info)
+brasero_metadata_get_result (BraseroMetadata *self,
+			     BraseroMetadataInfo *info,
+			     GError **error)
 {
 	BraseroMetadataPrivate *priv;
 
 	priv = BRASERO_METADATA_PRIVATE (self);
 
+	if (priv->error) {
+		if (error)
+			*error = g_error_copy (priv->error);
+
+		return FALSE;
+	}
+
 	if (!priv->info)
 		return FALSE;
 
+	if (priv->started)
+		return FALSE;
+
 	memset (info, 0, sizeof (BraseroMetadataInfo));
 	brasero_metadata_info_copy (info, priv->info);
 	return TRUE;
@@ -1713,15 +1707,14 @@
 
 	priv = BRASERO_METADATA_PRIVATE (obj);
 
-	priv->cond = g_cond_new ();
 	priv->mutex = g_mutex_new ();
-	priv->lock = g_mutex_new ();
 }
 
 static void
 brasero_metadata_finalize (GObject *object)
 {
 	BraseroMetadataPrivate *priv;
+	GSList *iter;
 
 	priv = BRASERO_METADATA_PRIVATE (object);
 
@@ -1752,19 +1745,19 @@
 		priv->info = NULL;
 	}
 
-	if (priv->mutex) {
-		g_mutex_free (priv->mutex);
-		priv->mutex = NULL;
-	}
+	for (iter = priv->conditions; iter; iter = iter->next) {
+		GCond *condition;
 
-	if (priv->cond) {
-		g_cond_free (priv->cond);
-		priv->cond = NULL;
+		condition = iter->data;
+		g_cond_broadcast (condition);
+		g_cond_free (condition);
 	}
+	g_slist_free (priv->conditions);
+	priv->conditions = NULL;
 
-	if (priv->lock) {
-		g_mutex_free (priv->lock);
-		priv->lock = NULL;
+	if (priv->mutex) {
+		g_mutex_free (priv->mutex);
+		priv->mutex = NULL;
 	}
 
 	G_OBJECT_CLASS (parent_class)->finalize (object);

Modified: trunk/src/brasero-metadata.h
==============================================================================
--- trunk/src/brasero-metadata.h	(original)
+++ trunk/src/brasero-metadata.h	Tue Nov 25 20:12:17 2008
@@ -103,28 +103,28 @@
 GType brasero_metadata_get_type ();
 BraseroMetadata *brasero_metadata_new (void);
 
-void
-brasero_metadata_cancel (BraseroMetadata *metadata);
-
-gboolean
-brasero_metadata_get_info_wait (BraseroMetadata *metadata,
-				GCancellable *cancel,
-				const gchar *uri,
-				BraseroMetadataFlag flags,
-				GError **error);
-
 gboolean
 brasero_metadata_get_info_async (BraseroMetadata *metadata,
 				 const gchar *uri,
 				 BraseroMetadataFlag flags);
+
 void
-brasero_metadata_lock (BraseroMetadata *metadata);
+brasero_metadata_cancel (BraseroMetadata *metadata);
 
+gboolean
+brasero_metadata_set_uri (BraseroMetadata *metadata,
+			  BraseroMetadataFlag flags,
+			  const gchar *uri,
+			  GError **error);
+
+void
+brasero_metadata_wait (BraseroMetadata *metadata,
+		       GCancellable *cancel);
 void
-brasero_metadata_unlock (BraseroMetadata *metadata);
+brasero_metadata_increase_listener_number (BraseroMetadata *metadata);
 
 gboolean
-brasero_metadata_try_lock (BraseroMetadata *metadata);
+brasero_metadata_decrease_listener_number (BraseroMetadata *metadata);
 
 const gchar *
 brasero_metadata_get_uri (BraseroMetadata *metadata);
@@ -133,7 +133,8 @@
 brasero_metadata_get_flags (BraseroMetadata *metadata);
 
 gboolean
-brasero_metadata_set_info (BraseroMetadata *metadata,
-			   BraseroMetadataInfo *info);
+brasero_metadata_get_result (BraseroMetadata *metadata,
+			     BraseroMetadataInfo *info,
+			     GError **error);
 
 #endif				/* METADATA_H */

Modified: trunk/src/brasero-split-dialog.c
==============================================================================
--- trunk/src/brasero-split-dialog.c	(original)
+++ trunk/src/brasero-split-dialog.c	Tue Nov 25 20:12:17 2008
@@ -621,7 +621,7 @@
 		return;
 	}
 
-	brasero_metadata_set_info (metadata, &info);
+	brasero_metadata_get_result (metadata, &info, NULL);
 	if (!info.silences) {
 		brasero_split_dialog_no_silence_message (self);
 		return;