Merge lp:~om26er/ubuntu/natty/totem/totem-fixes into lp:~ubuntu-desktop/totem/ubuntu

[Omer Akram]

backporting the fixes for bug 705361 and bug 659001 from gnome git.

builds on 32-bit https://launchpad.net/~om26er/+archive/unity/+buildjob/2322265 64-bit is still waiting to build

=== modified file 'debian/changelog'
--- debian/changelog	2011-02-17 01:22:04 +0000
+++ debian/changelog	2011-03-15 12:48:47 +0000
@@ -1,3 +1,15 @@
+totem (2.32.0-0ubuntu10) natty; urgency=low
+
+  * debian/patches/74_add_new_playlist_api.patch
+    debian/patches/74_use_new_playlist_api.patch:
+    - Fix the DnD of files in the playlist sidepane. (LP: #659001)
+  * debian/patches/74_fix_compile.patch:
+    - Fix compiling after the above two patches.
+  * debian/patches/75_fix_screenshotting_of_interlaced_videos.patch:
+    - Take screenshot does not work for some videos. (LP: #705361)
+
+ -- Omer Akram <[e-mail]>  Tue, 15 Mar 2011 17:29:09 +0500
+
 totem (2.32.0-0ubuntu9) natty; urgency=low
 
   * debian/{control{,.in},rules}: enable PIE build for security hardening

=== added file 'debian/patches/74_add_new_playlist_api.patch'
--- debian/patches/74_add_new_playlist_api.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/74_add_new_playlist_api.patch	2011-03-15 12:48:47 +0000
@@ -0,0 +1,296 @@
+From: Omer Akram <[e-mail]>
+Author: Philip Withnall <[e-mail]>
+Subject: Add totem_playlist_add_mrls() API.
+Origin: http://git.gnome.org/browse/totem/commit/?h=gnome-2-32&id=a9ed336231663812c58ac0fb544d9b9a9862a90e
+Bug: https://bugs.gnome.org/636686
+Bug-Ubuntu: https://launchpad.net/bugs/659001
+
+--- a/src/totem-playlist.c
++++ b/src/totem-playlist.c
+@@ -1949,6 +1949,257 @@ totem_playlist_add_mrl_sync (TotemPlaylist *playlist, const char *mrl, const cha
+ 	return handle_parse_result (totem_pl_parser_parse (playlist->priv->parser, mrl, FALSE), playlist, mrl, display_name);
+ }
+ 
++typedef struct {
++	TotemPlaylist *playlist;
++	GList *mrls; /* list of TotemPlaylistMrlDatas */
++	gboolean cursor;
++	GAsyncReadyCallback callback;
++	gpointer user_data;
++
++	guint next_index_to_add;
++	GList *unadded_entries; /* list of TotemPlaylistMrlDatas */
++	volatile gint entries_remaining;
++} AddMrlsOperationData;
++
++static void
++add_mrls_operation_data_free (AddMrlsOperationData *data)
++{
++	/* Remove the cursor, if one was set */
++	if (data->cursor)
++		unset_waiting_cursor (data->playlist);
++
++	g_list_foreach (data->mrls, (GFunc) totem_playlist_mrl_data_free, NULL);
++	g_list_free (data->mrls);
++	g_object_unref (data->playlist);
++
++	g_slice_free (AddMrlsOperationData, data);
++}
++
++struct TotemPlaylistMrlData {
++	gchar *mrl;
++	gchar *display_name;
++
++	/* Implementation details */
++	AddMrlsOperationData *operation_data;
++	guint index;
++};
++
++/**
++ * totem_playlist_mrl_data_new:
++ * @mrl: a MRL
++ * @display_name: (allow-none): a human-readable display name for the MRL, or %NULL
++ *
++ * Create a new #TotemPlaylistMrlData struct storing the given @mrl and @display_name.
++ *
++ * This will typically be immediately appended to a #GList to be passed to totem_playlist_add_mrls().
++ *
++ * Return value: (transfer full): a new #TotemPlaylistMrlData; free with totem_playlist_mrl_data_free()
++ *
++ * Since: 3.0
++ */
++TotemPlaylistMrlData *
++totem_playlist_mrl_data_new (const gchar *mrl,
++                             const gchar *display_name)
++{
++	TotemPlaylistMrlData *data;
++
++	g_return_val_if_fail (mrl != NULL && *mrl != '\0', NULL);
++
++	data = g_slice_new (TotemPlaylistMrlData);
++	data->mrl = g_strdup (mrl);
++	data->display_name = g_strdup (display_name);
++
++	return data;
++}
++
++/**
++ * totem_playlist_mrl_data_free:
++ * @data: (transfer full): a #TotemPlaylistMrlData
++ *
++ * Free the given #TotemPlaylistMrlData struct. This should not generally be called by code outside #TotemPlaylist.
++ *
++ * Since: 3.0
++ */
++void
++totem_playlist_mrl_data_free (TotemPlaylistMrlData *data)
++{
++	g_return_if_fail (data != NULL);
++
++	/* NOTE: This doesn't call add_mrls_operation_data_free() on @data->operation_data, since it's shared with other instances of
++	 * TotemPlaylistMrlData, and not truly reference counted. */
++	g_free (data->display_name);
++	g_free (data->mrl);
++
++	g_slice_free (TotemPlaylistMrlData, data);
++}
++
++static void
++add_mrls_finish_operation (AddMrlsOperationData *operation_data)
++{
++	/* Check whether this is the final callback invocation; iff it is, we can call the user's callback for the entire operation and free the
++	 * operation data */
++	if (g_atomic_int_dec_and_test (&(operation_data->entries_remaining)) == TRUE) {
++		GSimpleAsyncResult *async_result;
++
++		async_result = g_simple_async_result_new (G_OBJECT (operation_data->playlist), operation_data->callback, operation_data->user_data,
++		                                          totem_playlist_add_mrls);
++		g_simple_async_result_complete (async_result);
++		g_object_unref (async_result);
++
++		add_mrls_operation_data_free (operation_data);
++	}
++}
++
++/* Called exactly once for each MRL in a totem_playlist_add_mrls() operation. Called in the thread running the main loop. If the MRL which has just
++ * been parsed is the next one in the sequence (of entries in @mrls as passed to totem_playlist_add_mrls()), it's added to the playlist proper.
++ * Otherwise, it's added to a sorted queue of MRLs which have had their callbacks called out of order.
++ * When a MRL is added to the playlist proper, any successor MRLs which are in the sorted queue are also added to the playlist proper.
++ * When add_mrls_cb() is called for the last time for a given call to totem_playlist_add_mrls(), it calls the user's callback for the operation
++ * (passed as @callback to totem_playlist_add_mrls()) and frees the #AddMrlsOperationData struct. This is handled by add_mrls_finish_operation().
++ * The #TotemPlaylistMrlData for each MRL is freed by add_mrls_operation_data_free() at the end of the entire operation. */
++static void
++add_mrls_cb (TotemPlParser *parser, GAsyncResult *result, TotemPlaylistMrlData *mrl_data)
++{
++	TotemPlParserResult res;
++	AddMrlsOperationData *operation_data = mrl_data->operation_data;
++
++	/* Finish parsing the playlist */
++	res = totem_pl_parser_parse_finish (parser, result, NULL);
++
++	g_assert (mrl_data->index >= operation_data->next_index_to_add);
++
++	if (mrl_data->index == operation_data->next_index_to_add) {
++		GList *i;
++
++		/* The entry is the next one in the order, so doesn't need to be added to the unadded list, and can be added to playlist proper */
++		operation_data->next_index_to_add++;
++		handle_parse_result (res, operation_data->playlist, mrl_data->mrl, mrl_data->display_name);
++
++		/* See if we can now add any other entries which have already been processed */
++		for (i = operation_data->unadded_entries;
++		     i != NULL && ((TotemPlaylistMrlData*) i->data)->index == operation_data->next_index_to_add;
++		     i = g_list_delete_link (i, i)) {
++			TotemPlaylistMrlData *_mrl_data = (TotemPlaylistMrlData*) i->data;
++
++			operation_data->next_index_to_add++;
++			handle_parse_result (res, operation_data->playlist, _mrl_data->mrl, _mrl_data->display_name);
++		}
++
++		operation_data->unadded_entries = i;
++	} else {
++		GList *i;
++
++		/* The entry has been parsed out of order, so needs to be added (in the correct position) to the unadded list for latter addition to
++		 * the playlist proper */
++		for (i = operation_data->unadded_entries; i != NULL && mrl_data->index > ((TotemPlaylistMrlData*) i->data)->index; i = i->next);
++		operation_data->unadded_entries = g_list_insert_before (operation_data->unadded_entries, i, mrl_data);
++	}
++
++	/* Check whether this is the last callback; call the user's callback for the entire operation and free the operation data if appropriate */
++	add_mrls_finish_operation (operation_data);
++}
++
++/**
++ * totem_playlist_add_mrls:
++ * @self: a #TotemPlaylist
++ * @mrls: (element-type TotemPlaylistMrlData) (transfer full): a list of #TotemPlaylistMrlData structs
++ * @cursor: %TRUE to set a waiting cursor on the playlist for the duration of the operation, %FALSE otherwise
++ * @cancellable: (allow-none): a #Cancellable, or %NULL
++ * @callback: (scope async) (allow-none): callback to call once all the MRLs have been added to the playlist, or %NULL
++ * @user_data: (closure) (allow-none): user data to pass to @callback, or %NULL
++ *
++ * Add the MRLs listed in @mrls to the playlist asynchronously, and ensuring that they're added to the playlist in the order they appear in the
++ * input #GList.
++ *
++ * @mrls should be a #GList of #TotemPlaylistMrlData structs, each created with totem_playlist_mrl_data_new(). This function takes ownership of both
++ * the list and its elements when called, so don't free either after calling totem_playlist_add_mrls().
++ *
++ * @callback will be called after all the MRLs in @mrls have been parsed and (if they were parsed successfully) added to the playlist. In the
++ * callback function, totem_playlist_add_mrls_finish() should be called to check for errors.
++ *
++ * Since: 3.0
++ */
++void
++totem_playlist_add_mrls (TotemPlaylist *self,
++                         GList *mrls,
++                         gboolean cursor,
++                         GCancellable *cancellable,
++                         GAsyncReadyCallback callback,
++                         gpointer user_data)
++{
++	AddMrlsOperationData *operation_data;
++	GList *i;
++	guint mrl_index = 0;
++
++	g_return_if_fail (TOTEM_IS_PLAYLIST (self));
++	g_return_if_fail (mrls != NULL);
++	g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
++
++	/* Build the data struct to pass to the callback function */
++	operation_data = g_slice_new (AddMrlsOperationData);
++	operation_data->playlist = g_object_ref (self);
++	operation_data->mrls = mrls;
++	operation_data->cursor = cursor;
++	operation_data->callback = callback;
++	operation_data->user_data = user_data;
++	operation_data->next_index_to_add = mrl_index;
++	operation_data->unadded_entries = NULL;
++	g_atomic_int_set (&(operation_data->entries_remaining), 1);
++
++	/* Display a waiting cursor if required */
++	if (cursor)
++		set_waiting_cursor (self);
++
++	for (i = mrls; i != NULL; i = i->next) {
++		TotemPlaylistMrlData *mrl_data = (TotemPlaylistMrlData*) i->data;
++
++		if (mrl_data == NULL)
++			continue;
++
++		/* Set the item's parsing index, so that it's inserted into the playlist in the position it appeared in @mrls */
++		mrl_data->operation_data = operation_data;
++		mrl_data->index = mrl_index++;
++
++		g_atomic_int_inc (&(operation_data->entries_remaining));
++
++		/* Start parsing the playlist. Once this is complete, add_mrls_cb() is called (i.e. it's called exactly once for each entry in
++		 * @mrls).
++		 * TODO: Cancellation is currently not supoprted, since no consumers of this API make use of it, and it needs careful thought when
++		 * being implemented, as a separate #GCancellable instance will have to be created for each parallel computation. */
++		totem_pl_parser_parse_async (self->priv->parser, mrl_data->mrl, FALSE, NULL, (GAsyncReadyCallback) add_mrls_cb, mrl_data);
++	}
++
++	/* Deal with the case that all async operations completed before we got to this point (since we've held a reference to the operation data so
++	 * that it doesn't get freed prematurely if all the scheduled async parse operations complete before we've finished scheduling the rest. */
++	add_mrls_finish_operation (operation_data);
++}
++
++/**
++ * totem_playlist_add_mrls_finish:
++ * @self: a #TotemPlaylist
++ * @result: the #GAsyncResult that was provided to the callback
++ * @error: (allow-none): a #GError for error reporting, or %NULL
++ *
++ * Finish an asynchronous batch MRL addition operation started by totem_playlist_add_mrls().
++ *
++ * Return value: %TRUE on success, %FALSE otherwise
++ *
++ * Since: 3.0
++ */
++gboolean
++totem_playlist_add_mrls_finish (TotemPlaylist *self,
++                                GAsyncResult *result,
++                                GError **error)
++{
++	g_return_val_if_fail (TOTEM_IS_PLAYLIST (self), FALSE);
++	g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
++	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
++	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self), totem_playlist_add_mrls), FALSE);
++
++	/* We don't have anything to return at the moment. */
++	return TRUE;
++}
++
+ static gboolean
+ totem_playlist_clear_cb (GtkTreeModel *model,
+ 			 GtkTreePath  *path,
+diff --git a/src/totem-playlist.h b/src/totem-playlist.h
+index d7e5a65..7342e0a 100644
+--- a/src/totem-playlist.h
++++ b/src/totem-playlist.h
+@@ -100,6 +100,22 @@ gboolean totem_playlist_add_mrl_sync (TotemPlaylist *playlist,
+                                       const char *mrl,
+                                       const char *display_name);
+ 
++typedef struct TotemPlaylistMrlData TotemPlaylistMrlData;
++
++TotemPlaylistMrlData *totem_playlist_mrl_data_new (const gchar *mrl,
++                                                   const gchar *display_name);
++void totem_playlist_mrl_data_free (TotemPlaylistMrlData *data);
++
++void totem_playlist_add_mrls (TotemPlaylist *self,
++                              GList *mrls,
++                              gboolean cursor,
++                              GCancellable *cancellable,
++                              GAsyncReadyCallback callback,
++                              gpointer user_data);
++gboolean totem_playlist_add_mrls_finish (TotemPlaylist *self,
++                                         GAsyncResult *result,
++                                         GError **error);
++
+ void totem_playlist_save_current_playlist (TotemPlaylist *playlist,
+ 					   const char *output);
+ void totem_playlist_save_current_playlist_ext (TotemPlaylist *playlist,
+--
+cgit v0.8.3.4

=== added file 'debian/patches/74_fix_compile.patch'
--- debian/patches/74_fix_compile.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/74_fix_compile.patch	2011-03-15 12:48:47 +0000
@@ -0,0 +1,20 @@
+From: Omer Akram <[e-mail]>
+Author: Bastien Nocera <[e-mail]>
+Subject: Publish: Make it compile again.
+Origin: http://git.gnome.org/browse/totem/commit/?h=gnome-2-32&id=67c4c2e07b00487391ab8b906360d3f3f09e9b84
+Bug: https://bugs.gnome.org/636686
+Bug-Ubuntu: https://launchpad.net/bugs/659001
+
+--- a/src/plugins/publish/totem-publish.c
++++ b/src/plugins/publish/totem-publish.c
+@@ -443,7 +443,7 @@ totem_publish_plugin_load_playlist (TotemPublishPlugin   *self,
+ 
+ 		/* Add the MRLs to the playlist asynchronously and in order */
+ 		if (mrl_list != NULL)
+-			totem_playlist_add_mrls (self->priv->totem->playlist, g_list_reverse (mrl_list), FALSE, NULL, NULL, NULL);
++			totem_playlist_add_mrls (self->totem->playlist, g_list_reverse (mrl_list), FALSE, NULL, NULL, NULL);
+ 	}
+ 
+ out:
+--
+cgit v0.8.3.4

=== added file 'debian/patches/74_use_new_playlist_api.patch'
--- debian/patches/74_use_new_playlist_api.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/74_use_new_playlist_api.patch	2011-03-15 12:48:47 +0000
@@ -0,0 +1,275 @@
+From: Omer Akram <[e-mail]>
+Author: Philip Withnall <[e-mail]>
+Subject: Use the new totem_playlist_add_mrls() API to add multiple playlist entries.
+Origin: http://git.gnome.org/browse/totem/commit/?h=gnome-2-32&id=75f0ef09df10d3a1d6a8a3063c3258b128bc2e08
+Bug: https://bugs.gnome.org/636686
+Bug-Ubuntu: https://launchpad.net/bugs/659001
+
+--- a/src/plugins/publish/totem-publish.c
++++ b/src/plugins/publish/totem-publish.c
+@@ -412,6 +412,7 @@ totem_publish_plugin_load_playlist (TotemPublishPlugin   *self,
+ 
+ 	if (contents && g_key_file_load_from_data (keyfile, contents, length, G_KEY_FILE_NONE, &error)) {
+ 		gint i, n_entries;
++		GList *mrl_list = NULL;
+ 
+ 		/* returns zero in case of errors */
+ 		n_entries = g_key_file_get_integer (keyfile, "playlist", "NumberOfEntries", &error);
+@@ -434,11 +435,15 @@ totem_publish_plugin_load_playlist (TotemPublishPlugin   *self,
+ 			g_free (key);
+ 
+ 			if (mrl)
+-				totem_playlist_add_mrl (self->totem->playlist, mrl, title, FALSE, NULL, NULL, NULL);
++				mrl_list = g_list_prepend (mrl_list, totem_playlist_mrl_data_new (mrl, title));
+ 
+ 			g_free (title);
+ 			g_free (mrl);
+ 		}
++
++		/* Add the MRLs to the playlist asynchronously and in order */
++		if (mrl_list != NULL)
++			totem_playlist_add_mrls (self->priv->totem->playlist, g_list_reverse (mrl_list), FALSE, NULL, NULL, NULL);
+ 	}
+ 
+ out:
+diff --git a/src/totem-object.c b/src/totem-object.c
+index badf169..dc17a45 100644
+--- a/src/totem-object.c
++++ b/src/totem-object.c
+@@ -2136,31 +2136,20 @@ totem_action_show_help (Totem *totem)
+ 	}
+ }
+ 
+-typedef struct {
+-	gint add_mrl_complete;
+-	Totem *totem;
+-} DropFilesData;
+-
+ /* This is called in the main thread */
+ static void
+-totem_action_drop_files_finished (TotemPlaylist *playlist, GAsyncResult *result, DropFilesData *data)
++totem_action_drop_files_finished (TotemPlaylist *playlist, GAsyncResult *result, TotemObject *totem)
+ {
+-	/* When add_mrl_complete reaches 0, this is the last callback to occur and we can safely reconnect the playlist's changed signal (which was
+-	 * disconnected below in totem_action_drop_files(). We can also free the data struct and generally clean up. */
+-	if (g_atomic_int_dec_and_test (&(data->add_mrl_complete)) == TRUE) {
+-		char *mrl, *subtitle;
++	char *mrl, *subtitle;
+ 
+-		/* Reconnect the signal */
+-		g_signal_connect (G_OBJECT (playlist), "changed", G_CALLBACK (playlist_changed_cb), data->totem);
+-		mrl = totem_playlist_get_current_mrl (playlist, &subtitle);
+-		totem_action_set_mrl_and_play (data->totem, mrl, subtitle);
+-		g_free (mrl);
+-		g_free (subtitle);
++	/* Reconnect the playlist's changed signal (which was disconnected below in totem_action_drop_files(). */
++	g_signal_connect (G_OBJECT (playlist), "changed", G_CALLBACK (playlist_changed_cb), totem);
++	mrl = totem_playlist_get_current_mrl (playlist, &subtitle);
++	totem_action_set_mrl_and_play (totem, mrl, subtitle);
++	g_free (mrl);
++	g_free (subtitle);
+ 
+-		/* Free the data struct */
+-		g_object_unref (data->totem);
+-		g_slice_free (DropFilesData, data);
+-	}
++	g_object_unref (totem);
+ }
+ 
+ static gboolean
+@@ -2169,8 +2158,7 @@ totem_action_drop_files (Totem *totem, GtkSelectionData *data,
+ {
+ 	char **list;
+ 	guint i, len;
+-	DropFilesData *drop_files_data = NULL /* shut up gcc */;
+-	GList *p, *file_list;
++	GList *p, *file_list, *mrl_list = NULL;
+ 	gboolean cleared = FALSE;
+ 
+ 	list = g_uri_list_extract_uris ((const char *) gtk_selection_data_get_data (data));
+@@ -2210,18 +2198,11 @@ totem_action_drop_files (Totem *totem, GtkSelectionData *data,
+ 		g_signal_handlers_disconnect_by_func (G_OBJECT (totem->playlist), playlist_changed_cb, totem);
+ 		totem_playlist_clear (totem->playlist);
+ 		cleared = TRUE;
+-
+-		/* Allocate some shared memory to count how many add_mrl operations have completed (see the comment below).
+-		 * It's freed in totem_action_drop_files_cb() once all add_mrl operations have finished. */
+-		drop_files_data = g_slice_new (DropFilesData);
+-		drop_files_data->add_mrl_complete = len;
+-		drop_files_data->totem = g_object_ref (totem);
+ 	}
+ 
+ 	/* Add each MRL to the playlist asynchronously */
+ 	for (p = file_list; p != NULL; p = p->next) {
+-		const char *filename;
+-		char *title;
++		const char *filename, *title;
+ 
+ 		filename = p->data;
+ 		title = NULL;
+@@ -2237,15 +2218,17 @@ totem_action_drop_files (Totem *totem, GtkSelectionData *data,
+ 			}
+ 		}
+ 
+-		/* Add the MRL to the playlist. We need to reconnect playlist's "changed" signal once all of the add_mrl operations have completed,
+-		 * so we use a piece of allocated memory shared between the async operations to count how many have completed.
+-		 * If we haven't cleared the playlist, there's no need to do this. */
+-		if (cleared == TRUE) {
+-			totem_playlist_add_mrl (totem->playlist, filename, title, TRUE, NULL,
+-			                        (GAsyncReadyCallback) totem_action_drop_files_finished, drop_files_data);
+-		} else {
+-			totem_playlist_add_mrl (totem->playlist, filename, title, TRUE, NULL, NULL, NULL);
+-		}
++		/* Add the MRL data to the list of MRLs to add to the playlist */
++		mrl_list = g_list_prepend (mrl_list, totem_playlist_mrl_data_new (filename, title));
++	}
++
++	/* Add the MRLs to the playlist asynchronously and in order. We need to reconnect playlist's "changed" signal once all of the add-MRL
++	 * operations have completed. If we haven't cleared the playlist, there's no need to do this. */
++	if (mrl_list != NULL && cleared == TRUE) {
++		totem_playlist_add_mrls (totem->playlist, g_list_reverse (mrl_list), TRUE, NULL,
++		                         (GAsyncReadyCallback) totem_action_drop_files_finished, g_object_ref (totem));
++	} else if (mrl_list != NULL) {
++		totem_playlist_add_mrls (totem->playlist, g_list_reverse (mrl_list), TRUE, NULL, NULL, NULL);
+ 	}
+ 
+ bail:
+@@ -2736,6 +2719,7 @@ static gboolean
+ totem_action_open_files_list (Totem *totem, GSList *list)
+ {
+ 	GSList *l;
++	GList *mrl_list = NULL;
+ 	gboolean changed;
+ 	gboolean cleared;
+ 
+@@ -2789,10 +2773,10 @@ totem_action_open_files_list (Totem *totem, GSList *list)
+ 				totem_action_load_media_device (totem, data);
+ 				changed = TRUE;
+ 			} else if (g_str_has_prefix (filename, "dvb:/") != FALSE) {
+-				totem_playlist_add_mrl (totem->playlist, data, NULL, FALSE, NULL, NULL, NULL);
++				mrl_list = g_list_prepend (mrl_list, totem_playlist_mrl_data_new (data, NULL));
+ 				changed = TRUE;
+ 			} else {
+-				totem_playlist_add_mrl (totem->playlist, filename, NULL, FALSE, NULL, NULL, NULL);
++				mrl_list = g_list_prepend (mrl_list, totem_playlist_mrl_data_new (filename, NULL));
+ 				changed = TRUE;
+ 			}
+ 		}
+@@ -2800,6 +2784,10 @@ totem_action_open_files_list (Totem *totem, GSList *list)
+ 		g_free (filename);
+ 	}
+ 
++	/* Add the MRLs to the playlist asynchronously and in order */
++	if (mrl_list != NULL)
++		totem_playlist_add_mrls (totem->playlist, g_list_reverse (mrl_list), FALSE, NULL, NULL, NULL);
++
+ 	gdk_window_set_cursor (gtk_widget_get_window (totem->win), NULL);
+ 
+ 	/* ... and reconnect because we're nice people */
+diff --git a/src/totem-playlist.c b/src/totem-playlist.c
+index eac7ced..f893575 100644
+--- a/src/totem-playlist.c
++++ b/src/totem-playlist.c
+@@ -489,6 +489,8 @@ gtk_tree_selection_has_selected (GtkTreeSelection *selection)
+ static void
+ drop_finished_cb (TotemPlaylist *playlist, GAsyncResult *result, gpointer user_data)
+ {
++	totem_playlist_add_mrls_finish (playlist, result, NULL);
++
+ 	/* Emit the "changed" signal once the last dropped MRL has been added to the playlist */
+ 	g_signal_emit (G_OBJECT (playlist),
+ 	               totem_playlist_table_signals[CHANGED], 0,
+@@ -506,7 +508,7 @@ drop_cb (GtkWidget        *widget,
+ 	 TotemPlaylist    *playlist)
+ {
+ 	char **list;
+-	GList *p, *file_list;
++	GList *p, *file_list, *mrl_list = NULL;
+ 	guint i;
+ 	GdkDragAction action;
+ 
+@@ -570,16 +572,16 @@ drop_cb (GtkWidget        *widget,
+ 			}
+ 		}
+ 
+-		/* Add the MRL to the playlist asynchronously. If it's the last MRL, emit the "changed"
+-		 * signal once we're done adding it */
+-		if (p->next == NULL)
+-			totem_playlist_add_mrl (playlist, filename, title, TRUE, NULL, (GAsyncReadyCallback) drop_finished_cb, NULL);
+-		else
+-			totem_playlist_add_mrl (playlist, filename, title, TRUE, NULL, NULL, NULL);
+-
++		/* Add the MRL to the list of MRLs to be added to the playlist */
++		mrl_list = g_list_prepend (mrl_list, totem_playlist_mrl_data_new (filename, title));
+ 		g_free (filename);
+ 	}
+ 
++	/* Add all the MRLs to the playlist asynchronously, emitting the "changed" signal once we're done.
++	 * Note that this takes ownership of @mrl_list. */
++	if (mrl_list != NULL)
++		totem_playlist_add_mrls (playlist, g_list_reverse (mrl_list), TRUE, NULL, (GAsyncReadyCallback) drop_finished_cb, NULL);
++
+ 	g_strfreev (list);
+ 	g_list_free (file_list);
+ 	gtk_drag_finish (context, TRUE, FALSE, _time);
+@@ -853,20 +855,22 @@ void
+ totem_playlist_add_files (GtkWidget *widget, TotemPlaylist *playlist)
+ {
+ 	GSList *filenames, *l;
++	GList *mrl_list = NULL;
+ 
+ 	filenames = totem_add_files (totem_playlist_get_toplevel (playlist), NULL);
+ 	if (filenames == NULL)
+ 		return;
+ 
+ 	for (l = filenames; l != NULL; l = l->next) {
+-		char *mrl;
+-
+-		mrl = l->data;
+-		totem_playlist_add_mrl (playlist, mrl, NULL, TRUE, NULL, NULL, NULL);
++		char *mrl = l->data;
++		mrl_list = g_list_prepend (mrl_list, totem_playlist_mrl_data_new (mrl, NULL));
+ 		g_free (mrl);
+ 	}
+ 
+ 	g_slist_free (filenames);
++
++	if (mrl_list != NULL)
++		totem_playlist_add_mrls (playlist, g_list_reverse (mrl_list), TRUE, NULL, NULL, NULL);
+ }
+ 
+ static void
+diff --git a/src/totem-video-list.c b/src/totem-video-list.c
+index f6fc828..bb01931 100644
+--- a/src/totem-video-list.c
++++ b/src/totem-video-list.c
+@@ -461,6 +461,7 @@ add_to_playlist_action_callback (GtkAction *action, TotemVideoList *self)
+ 	GtkTreePath *path;
+ 	GtkTreeIter iter;
+ 	gchar *mrl, *display_name;
++	GList *mrl_list = NULL;
+ 	GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self));
+ 	GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (self));
+ 	GList *l = gtk_tree_selection_get_selected_rows (selection, NULL);
+@@ -482,7 +483,7 @@ add_to_playlist_action_callback (GtkAction *action, TotemVideoList *self)
+ 			continue;
+ 		}
+ 
+-		totem_playlist_add_mrl (playlist, mrl, display_name, TRUE, NULL, NULL, NULL);
++		mrl_list = g_list_prepend (mrl_list, totem_playlist_mrl_data_new (mrl, display_name));
+ 
+ 		g_free (mrl);
+ 		g_free (display_name);
+@@ -490,6 +491,10 @@ add_to_playlist_action_callback (GtkAction *action, TotemVideoList *self)
+ 
+ 	g_list_foreach (l, (GFunc) gtk_tree_path_free, NULL);
+ 	g_list_free (l);
++
++	/* Asynchronously add all the MRLs to the playlist in order */
++	if (mrl_list != NULL)
++		totem_playlist_add_mrls (playlist, g_list_reverse (mrl_list), TRUE, NULL, NULL, NULL);
+ }
+ 
+ void
+--
+cgit v0.8.3.4

=== added file 'debian/patches/75_fix_screenshotting_of_interlaced_videos.patch'
--- debian/patches/75_fix_screenshotting_of_interlaced_videos.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/75_fix_screenshotting_of_interlaced_videos.patch	2011-03-15 12:48:47 +0000
@@ -0,0 +1,35 @@
+From: Omer Akram <[e-mail]>
+Author: Tim-Philipp Müller <[e-mail]>
+Subject: Fix screenshotting of interlaced videos.
+Origin: http://git.gnome.org/browse/totem/commit/?id=b427beeab1d41154b4243d51b500839db543deea
+Bug: https://bugs.gnome.org/640933
+Bug-Ubuntu: https://launchpad.net/bugs/705361
+
+--- a/src/backend/bacon-video-widget-gst-0.10.c
++++ b/src/backend/bacon-video-widget-gst-0.10.c
+@@ -6427,7 +6427,10 @@ bacon_video_widget_get_current_frame (BaconVideoWidget * bvw)
+       "depth", G_TYPE_INT, 24,
+       /* Note: we don't ask for a specific width/height here, so that
+        * videoscale can adjust dimensions from a non-1/1 pixel aspect
+-       * ratio to a 1/1 pixel-aspect-ratio */
++       * ratio to a 1/1 pixel-aspect-ratio. We also don't ask for a
++       * specific framerate, because the input framerate won't
++       * necessarily match the output framerate if there's a deinterlacer
++       * in the pipeline. */
+       "pixel-aspect-ratio", GST_TYPE_FRACTION, 1, 1,
+       "endianness", G_TYPE_INT, G_BIG_ENDIAN,
+       "red_mask", G_TYPE_INT, 0xff0000,
+@@ -6435,11 +6438,6 @@ bacon_video_widget_get_current_frame (BaconVideoWidget * bvw)
+       "blue_mask", G_TYPE_INT, 0x0000ff,
+       NULL);
+ 
+-  if (bvw->priv->video_fps_n > 0 && bvw->priv->video_fps_d > 0) {
+-    gst_caps_set_simple (to_caps, "framerate", GST_TYPE_FRACTION, 
+-      bvw->priv->video_fps_n, bvw->priv->video_fps_d, NULL);
+-  }
+-
+   GST_DEBUG ("frame caps: %" GST_PTR_FORMAT, GST_BUFFER_CAPS (buf));
+   GST_DEBUG ("pixbuf caps: %" GST_PTR_FORMAT, to_caps);
+ 
+--
+cgit v0.8.3.4

=== modified file 'debian/patches/series'
--- debian/patches/series	2011-01-29 14:57:16 +0000
+++ debian/patches/series	2011-03-15 12:48:47 +0000
@@ -6,3 +6,7 @@
 71_add_show_tooltip_uri_property.patch
 72_dont_display_URIs_in_youtube_tooltips.patch
 73_show_video_title.patch
+74_add_new_playlist_api.patch
+74_use_new_playlist_api.patch
+74_fix_compile.patch
+75_fix_screenshotting_of_interlaced_videos.patch