gimp/patches/gimp-2.6.11-poppler018.patch

From 69f69eed816b89be9a01a48a1f0643d1fd496118 Mon Sep 17 00:00:00 2001
From: Nils Philippsen <nils@redhat.com>
Date: Fri, 6 May 2011 11:58:44 +0200
Subject: [PATCH] patch: poppler-0.17

Squashed commit of the following:

commit 529d940222dfc352d41fbf72de29134421aa4002
Author: Nils Philippsen <nils@redhat.com>
Date:   Fri May 6 11:50:30 2011 +0200

    use code based on pixbufs instead of cairo surfaces

    this is done to avoid adding to libgimp, thanks to Mukund Sivaraman for
    hints how to do this

commit f8671d8767d4cdab830dc06310e96c63a88ec0fd
Author: Mukund Sivaraman <muks@banu.com>
Date:   Thu Apr 21 13:57:13 2011 +0530

    file-pdf-load: Update attribution, removing bogus copyright
    (cherry picked from commit e999122e0b20b6ccd6bde3ce039bb64068fc0019)

commit 89a78f2590d298dac2f42e6d9a3016fc5d672c70
Author: Nils Philippsen <nils@redhat.com>
Date:   Thu Apr 21 13:52:18 2011 +0200

    file-pdf-load: Use better API + cleanups

    * fixes issues with poppler 0.17 completely
    * uses new libgimp API to pass surfaces instead of pixbufs
    * uses GTK+ 3 API to convert surfaces to pixbufs where available
    (backported from commit 7bdadd80ba479d6ff904e276d805e16f6b940ee2)

commit 4e92302c4a14a961f112587a0ad86696c88da2f8
Author: Nils Philippsen <nils@redhat.com>
Date:   Thu Apr 21 13:38:08 2011 +0200

    file-pdf-load: Don't use deprecated API (bug #646947)

    (cherry picked from commit 9b3e1c91fd2eac69da6947ec9c7fbf10096ba237)

    Conflicts:

	plug-ins/common/file-pdf.c
---
 plug-ins/common/file-pdf.c |  323 ++++++++++++++++++++++++++++++++++++++------
 1 files changed, 283 insertions(+), 40 deletions(-)

diff --git a/plug-ins/common/file-pdf.c b/plug-ins/common/file-pdf.c
index a43b459..43c2b7d 100644
--- a/plug-ins/common/file-pdf.c
+++ b/plug-ins/common/file-pdf.c
@@ -4,6 +4,9 @@
  *
  * Copyright (C) 2005 Nathan Summers
  *
+ * Some code in render_page_to_surface() borrowed from
+ * poppler.git/glib/poppler-page.cc.
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
@@ -80,16 +83,20 @@ static gboolean          load_dialog       (PopplerDocument        *doc,
 static PopplerDocument * open_document     (const gchar            *filename,
                                             GError                **error);

-static GdkPixbuf *       get_thumbnail     (PopplerDocument        *doc,
+static cairo_surface_t * get_thumb_surface (PopplerDocument        *doc,
+                                            gint                    page,
+                                            gint                    preferred_size);
+
+static GdkPixbuf *       get_thumb_pixbuf  (PopplerDocument        *doc,
                                             gint                    page,
                                             gint                    preferred_size);

 static gint32            layer_from_pixbuf (gint32                  image,
-                                            const gchar            *layer_name,
-                                            gint                    position,
-                                            GdkPixbuf              *buf,
-                                            gdouble                 progress_start,
-                                            gdouble                 progress_scale);
+					                        const gchar            *layer_name,
+					                        gint                    position,
+					                        GdkPixbuf              *pixbuf,
+					                        gdouble                 progress_start,
+					                        gdouble                 progress_scale);

 /**
  ** the following was formerly part of
@@ -433,11 +440,12 @@ run (const gchar      *name,
         }
       else
         {
-          gdouble      width  = 0;
-          gdouble      height = 0;
-          gdouble      scale;
-          gint32       image  = -1;
-          GdkPixbuf   *pixbuf = NULL;
+          gdouble    width     = 0;
+          gdouble    height    = 0;
+          gdouble    scale;
+          gint32     image     = -1;
+          gint       num_pages = 0;
+          GdkPixbuf *pixbuf    = NULL;

           /* Possibly retrieve last settings */
           gimp_get_data (LOAD_PROC, &loadvals);
@@ -455,7 +463,10 @@ run (const gchar      *name,
                   g_object_unref (page);
                 }

-              pixbuf = get_thumbnail (doc, 0, param[1].data.d_int32);
+              num_pages = poppler_document_get_n_pages (doc);
+
+              pixbuf = get_thumb_pixbuf (doc, 0, param[1].data.d_int32);
+
               g_object_unref (doc);
             }

@@ -548,6 +559,187 @@ open_document (const gchar  *filename,
   return doc;
 }

+/* FIXME: Remove this someday when we depend fully on GTK+ >= 3 */
+
+#if (!GTK_CHECK_VERSION (3, 0, 0))
+
+static cairo_format_t
+gdk_cairo_format_for_content (cairo_content_t content)
+{
+  switch (content)
+    {
+    case CAIRO_CONTENT_COLOR:
+      return CAIRO_FORMAT_RGB24;
+    case CAIRO_CONTENT_ALPHA:
+      return CAIRO_FORMAT_A8;
+    case CAIRO_CONTENT_COLOR_ALPHA:
+    default:
+      return CAIRO_FORMAT_ARGB32;
+    }
+}
+
+static cairo_surface_t *
+gdk_cairo_surface_coerce_to_image (cairo_surface_t *surface,
+                                   cairo_content_t  content,
+                                   int              src_x,
+                                   int              src_y,
+                                   int              width,
+                                   int              height)
+{
+  cairo_surface_t *copy;
+  cairo_t *cr;
+
+  copy = cairo_image_surface_create (gdk_cairo_format_for_content (content),
+                                     width,
+                                     height);
+
+  cr = cairo_create (copy);
+  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+  cairo_set_source_surface (cr, surface, -src_x, -src_y);
+  cairo_paint (cr);
+  cairo_destroy (cr);
+
+  return copy;
+}
+
+static void
+convert_alpha (guchar *dest_data,
+               int     dest_stride,
+               guchar *src_data,
+               int     src_stride,
+               int     src_x,
+               int     src_y,
+               int     width,
+               int     height)
+{
+  int x, y;
+
+  src_data += src_stride * src_y + src_x * 4;
+
+  for (y = 0; y < height; y++) {
+    guint32 *src = (guint32 *) src_data;
+
+    for (x = 0; x < width; x++) {
+      guint alpha = src[x] >> 24;
+
+      if (alpha == 0)
+        {
+          dest_data[x * 4 + 0] = 0;
+          dest_data[x * 4 + 1] = 0;
+          dest_data[x * 4 + 2] = 0;
+        }
+      else
+        {
+          dest_data[x * 4 + 0] = (((src[x] & 0xff0000) >> 16) * 255 + alpha / 2) / alpha;
+          dest_data[x * 4 + 1] = (((src[x] & 0x00ff00) >>  8) * 255 + alpha / 2) / alpha;
+          dest_data[x * 4 + 2] = (((src[x] & 0x0000ff) >>  0) * 255 + alpha / 2) / alpha;
+        }
+      dest_data[x * 4 + 3] = alpha;
+    }
+
+    src_data += src_stride;
+    dest_data += dest_stride;
+  }
+}
+
+static void
+convert_no_alpha (guchar *dest_data,
+                  int     dest_stride,
+                  guchar *src_data,
+                  int     src_stride,
+                  int     src_x,
+                  int     src_y,
+                  int     width,
+                  int     height)
+{
+  int x, y;
+
+  src_data += src_stride * src_y + src_x * 4;
+
+  for (y = 0; y < height; y++) {
+    guint32 *src = (guint32 *) src_data;
+
+    for (x = 0; x < width; x++) {
+      dest_data[x * 3 + 0] = src[x] >> 16;
+      dest_data[x * 3 + 1] = src[x] >>  8;
+      dest_data[x * 3 + 2] = src[x];
+    }
+
+    src_data += src_stride;
+    dest_data += dest_stride;
+  }
+}
+
+/**
+ * gdk_pixbuf_get_from_surface:
+ * @surface: surface to copy from
+ * @src_x: Source X coordinate within @surface
+ * @src_y: Source Y coordinate within @surface
+ * @width: Width in pixels of region to get
+ * @height: Height in pixels of region to get
+ *
+ * Transfers image data from a #cairo_surface_t and converts it to an RGB(A)
+ * representation inside a #GdkPixbuf. This allows you to efficiently read
+ * individual pixels from cairo surfaces. For #GdkWindows, use
+ * gdk_pixbuf_get_from_window() instead.
+ *
+ * This function will create an RGB pixbuf with 8 bits per channel.
+ * The pixbuf will contain an alpha channel if the @surface contains one.
+ *
+ * Return value: (transfer full): A newly-created pixbuf with a reference
+ *     count of 1, or %NULL on error
+ */
+static GdkPixbuf *
+gdk_pixbuf_get_from_surface  (cairo_surface_t *surface,
+                              gint             src_x,
+                              gint             src_y,
+                              gint             width,
+                              gint             height)
+{
+  cairo_content_t content;
+  GdkPixbuf *dest;
+
+  /* General sanity checks */
+  g_return_val_if_fail (surface != NULL, NULL);
+  g_return_val_if_fail (width > 0 && height > 0, NULL);
+
+  content = cairo_surface_get_content (surface) | CAIRO_CONTENT_COLOR;
+  dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
+                         !!(content & CAIRO_CONTENT_ALPHA),
+                         8,
+                         width, height);
+
+  surface = gdk_cairo_surface_coerce_to_image (surface, content,
+                                               src_x, src_y,
+                                               width, height);
+  cairo_surface_flush (surface);
+  if (cairo_surface_status (surface) || dest == NULL)
+    {
+      cairo_surface_destroy (surface);
+      return NULL;
+    }
+
+  if (gdk_pixbuf_get_has_alpha (dest))
+    convert_alpha (gdk_pixbuf_get_pixels (dest),
+                   gdk_pixbuf_get_rowstride (dest),
+                   cairo_image_surface_get_data (surface),
+                   cairo_image_surface_get_stride (surface),
+                   0, 0,
+                   width, height);
+  else
+    convert_no_alpha (gdk_pixbuf_get_pixels (dest),
+                      gdk_pixbuf_get_rowstride (dest),
+                      cairo_image_surface_get_data (surface),
+                      cairo_image_surface_get_stride (surface),
+                      0, 0,
+                      width, height);
+
+  cairo_surface_destroy (surface);
+  return dest;
+}
+
+#endif
+
 static gint32
 layer_from_pixbuf (gint32        image,
                    const gchar  *layer_name,
@@ -566,6 +758,54 @@ layer_from_pixbuf (gint32        image,
   return layer;
 }

+static cairo_surface_t *
+render_page_to_surface (PopplerPage *page,
+                        int          width,
+                        int          height,
+                        double       scale)
+{
+  cairo_surface_t *surface;
+  cairo_t *cr;
+
+  surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
+  cr = cairo_create (surface);
+
+  cairo_save (cr);
+  cairo_translate (cr, 0.0, 0.0);
+
+  if (scale != 1.0)
+    cairo_scale (cr, scale, scale);
+
+  poppler_page_render (page, cr);
+  cairo_restore (cr);
+
+  cairo_set_operator (cr, CAIRO_OPERATOR_DEST_OVER);
+  cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
+  cairo_paint (cr);
+
+  cairo_destroy (cr);
+
+  return surface;
+}
+
+static GdkPixbuf *
+render_page_to_pixbuf (PopplerPage *page,
+                       int          width,
+                       int          height,
+                       double       scale)
+{
+  GdkPixbuf *pixbuf;
+  cairo_surface_t *surface;
+
+  surface = render_page_to_surface (page, width, height, scale);
+  pixbuf = gdk_pixbuf_get_from_surface (surface, 0, 0,
+                                        cairo_image_surface_get_width (surface),
+                                        cairo_image_surface_get_height (surface));
+  cairo_surface_destroy (surface);
+
+  return pixbuf;
+}
+
 static gint32
 load_image (PopplerDocument        *doc,
             const gchar            *filename,
@@ -597,7 +837,7 @@ load_image (PopplerDocument        *doc,
       gdouble      page_width;
       gdouble      page_height;

-      GdkPixbuf   *buf;
+      GdkPixbuf   *pixbuf;
       gint         width;
       gint         height;

@@ -627,15 +867,13 @@ load_image (PopplerDocument        *doc,
           gimp_image_set_resolution (image_ID, resolution, resolution);
         }

-      buf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, width, height);
-
-      poppler_page_render_to_pixbuf (page, 0, 0, width, height, scale, 0, buf);
+      pixbuf = render_page_to_pixbuf (page, width, height, scale);

-      layer_from_pixbuf (image_ID, page_label, i, buf,
+      layer_from_pixbuf (image_ID, page_label, i, pixbuf,
                          doc_progress, 1.0 / pages->n_pages);

       g_free (page_label);
-      g_object_unref (buf);
+      g_object_unref(pixbuf);

       doc_progress = (double) (i + 1) / pages->n_pages;
       gimp_progress_update (doc_progress);
@@ -676,30 +914,22 @@ load_image (PopplerDocument        *doc,
   return image_ID;
 }

-static GdkPixbuf *
-get_thumbnail (PopplerDocument *doc,
-               gint             page_num,
-               gint             preferred_size)
+static cairo_surface_t *
+get_thumb_surface (PopplerDocument *doc,
+                   gint             page_num,
+                   gint             preferred_size)
 {
   PopplerPage *page;
-  GdkPixbuf   *pixbuf;
+  cairo_surface_t *surface;

   page = poppler_document_get_page (doc, page_num);

   if (! page)
     return NULL;

-  /* XXX: Remove conditional when we depend on poppler 0.8.0, but also
-   * add configure check to make sure POPPLER_WITH_GDK is enabled!
-   */
-#ifdef POPPLER_WITH_GDK
-  pixbuf = poppler_page_get_thumbnail_pixbuf (page);
-#else
-  pixbuf = poppler_page_get_thumbnail (page);
-#endif
-
+  surface = poppler_page_get_thumbnail (page);

-  if (! pixbuf)
+  if (! surface)
     {
       gdouble width;
       gdouble height;
@@ -712,15 +942,28 @@ get_thumbnail (PopplerDocument *doc,
       width  *= scale;
       height *= scale;

-      pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8,
-                               width, height);
-
-      poppler_page_render_to_pixbuf (page,
-                                     0, 0, width, height, scale, 0, pixbuf);
+      surface = render_page_to_surface (page, width, height, scale);
     }

   g_object_unref (page);

+  return surface;
+}
+
+static GdkPixbuf *
+get_thumb_pixbuf (PopplerDocument *doc,
+                  gint             page_num,
+                  gint             preferred_size)
+{
+  cairo_surface_t *surface;
+  GdkPixbuf *pixbuf;
+
+  surface = get_thumb_surface (doc, page_num, preferred_size);
+  pixbuf = gdk_pixbuf_get_from_surface (surface, 0, 0,
+                                        cairo_image_surface_get_width (surface),
+                                        cairo_image_surface_get_height (surface));
+  cairo_surface_destroy (surface);
+
   return pixbuf;
 }

@@ -769,8 +1012,8 @@ thumbnail_thread (gpointer data)
       idle_data->page_no  = i;

       /* FIXME get preferred size from somewhere? */
-      idle_data->pixbuf = get_thumbnail (thread_data->document, i,
-                                         THUMBNAIL_SIZE);
+      idle_data->pixbuf = get_thumb_pixbuf (thread_data->document, i,
+                                            THUMBNAIL_SIZE);

       g_idle_add (idle_set_thumbnail, idle_data);

--
1.7.5
1	niro	1597	From 69f69eed816b89be9a01a48a1f0643d1fd496118 Mon Sep 17 00:00:00 2001
2			From: Nils Philippsen <nils@redhat.com>
3			Date: Fri, 6 May 2011 11:58:44 +0200
4			Subject: [PATCH] patch: poppler-0.17
5
6			Squashed commit of the following:
7
8			commit 529d940222dfc352d41fbf72de29134421aa4002
9			Author: Nils Philippsen <nils@redhat.com>
10			Date: Fri May 6 11:50:30 2011 +0200
11
12			use code based on pixbufs instead of cairo surfaces
13
14			this is done to avoid adding to libgimp, thanks to Mukund Sivaraman for
15			hints how to do this
16
17			commit f8671d8767d4cdab830dc06310e96c63a88ec0fd
18			Author: Mukund Sivaraman <muks@banu.com>
19			Date: Thu Apr 21 13:57:13 2011 +0530
20
21			file-pdf-load: Update attribution, removing bogus copyright
22			(cherry picked from commit e999122e0b20b6ccd6bde3ce039bb64068fc0019)
23
24			commit 89a78f2590d298dac2f42e6d9a3016fc5d672c70
25			Author: Nils Philippsen <nils@redhat.com>
26			Date: Thu Apr 21 13:52:18 2011 +0200
27
28			file-pdf-load: Use better API + cleanups
29
30			* fixes issues with poppler 0.17 completely
31			* uses new libgimp API to pass surfaces instead of pixbufs
32			* uses GTK+ 3 API to convert surfaces to pixbufs where available
33			(backported from commit 7bdadd80ba479d6ff904e276d805e16f6b940ee2)
34
35			commit 4e92302c4a14a961f112587a0ad86696c88da2f8
36			Author: Nils Philippsen <nils@redhat.com>
37			Date: Thu Apr 21 13:38:08 2011 +0200
38
39			file-pdf-load: Don't use deprecated API (bug #646947)
40
41			(cherry picked from commit 9b3e1c91fd2eac69da6947ec9c7fbf10096ba237)
42
43			Conflicts:
44
45			plug-ins/common/file-pdf.c
46			---
47			plug-ins/common/file-pdf.c \| 323 ++++++++++++++++++++++++++++++++++++++------
48			1 files changed, 283 insertions(+), 40 deletions(-)
49
50			diff --git a/plug-ins/common/file-pdf.c b/plug-ins/common/file-pdf.c
51			index a43b459..43c2b7d 100644
52			--- a/plug-ins/common/file-pdf.c
53			+++ b/plug-ins/common/file-pdf.c
54			@@ -4,6 +4,9 @@
55			*
56			* Copyright (C) 2005 Nathan Summers
57			*
58			+ * Some code in render_page_to_surface() borrowed from
59			+ * poppler.git/glib/poppler-page.cc.
60			+ *
61			* This program is free software; you can redistribute it and/or modify
62			* it under the terms of the GNU General Public License as published by
63			* the Free Software Foundation; either version 2 of the License, or
64			@@ -80,16 +83,20 @@ static gboolean load_dialog (PopplerDocument *doc,
65			static PopplerDocument * open_document (const gchar *filename,
66			GError **error);
67
68			-static GdkPixbuf * get_thumbnail (PopplerDocument *doc,
69			+static cairo_surface_t * get_thumb_surface (PopplerDocument *doc,
70			+ gint page,
71			+ gint preferred_size);
72			+
73			+static GdkPixbuf * get_thumb_pixbuf (PopplerDocument *doc,
74			gint page,
75			gint preferred_size);
76
77			static gint32 layer_from_pixbuf (gint32 image,
78			- const gchar *layer_name,
79			- gint position,
80			- GdkPixbuf *buf,
81			- gdouble progress_start,
82			- gdouble progress_scale);
83			+ const gchar *layer_name,
84			+ gint position,
85			+ GdkPixbuf *pixbuf,
86			+ gdouble progress_start,
87			+ gdouble progress_scale);
88
89			/**
90			** the following was formerly part of
91			@@ -433,11 +440,12 @@ run (const gchar *name,
92			}
93			else
94			{
95			- gdouble width = 0;
96			- gdouble height = 0;
97			- gdouble scale;
98			- gint32 image = -1;
99			- GdkPixbuf *pixbuf = NULL;
100			+ gdouble width = 0;
101			+ gdouble height = 0;
102			+ gdouble scale;
103			+ gint32 image = -1;
104			+ gint num_pages = 0;
105			+ GdkPixbuf *pixbuf = NULL;
106
107			/* Possibly retrieve last settings */
108			gimp_get_data (LOAD_PROC, &loadvals);
109			@@ -455,7 +463,10 @@ run (const gchar *name,
110			g_object_unref (page);
111			}
112
113			- pixbuf = get_thumbnail (doc, 0, param[1].data.d_int32);
114			+ num_pages = poppler_document_get_n_pages (doc);
115			+
116			+ pixbuf = get_thumb_pixbuf (doc, 0, param[1].data.d_int32);
117			+
118			g_object_unref (doc);
119			}
120
121			@@ -548,6 +559,187 @@ open_document (const gchar *filename,
122			return doc;
123			}
124
125			+/* FIXME: Remove this someday when we depend fully on GTK+ >= 3 */
126			+
127			+#if (!GTK_CHECK_VERSION (3, 0, 0))
128			+
129			+static cairo_format_t
130			+gdk_cairo_format_for_content (cairo_content_t content)
131			+{
132			+ switch (content)
133			+ {
134			+ case CAIRO_CONTENT_COLOR:
135			+ return CAIRO_FORMAT_RGB24;
136			+ case CAIRO_CONTENT_ALPHA:
137			+ return CAIRO_FORMAT_A8;
138			+ case CAIRO_CONTENT_COLOR_ALPHA:
139			+ default:
140			+ return CAIRO_FORMAT_ARGB32;
141			+ }
142			+}
143			+
144			+static cairo_surface_t *
145			+gdk_cairo_surface_coerce_to_image (cairo_surface_t *surface,
146			+ cairo_content_t content,
147			+ int src_x,
148			+ int src_y,
149			+ int width,
150			+ int height)
151			+{
152			+ cairo_surface_t *copy;
153			+ cairo_t *cr;
154			+
155			+ copy = cairo_image_surface_create (gdk_cairo_format_for_content (content),
156			+ width,
157			+ height);
158			+
159			+ cr = cairo_create (copy);
160			+ cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
161			+ cairo_set_source_surface (cr, surface, -src_x, -src_y);
162			+ cairo_paint (cr);
163			+ cairo_destroy (cr);
164			+
165			+ return copy;
166			+}
167			+
168			+static void
169			+convert_alpha (guchar *dest_data,
170			+ int dest_stride,
171			+ guchar *src_data,
172			+ int src_stride,
173			+ int src_x,
174			+ int src_y,
175			+ int width,
176			+ int height)
177			+{
178			+ int x, y;
179			+
180			+ src_data += src_stride * src_y + src_x * 4;
181			+
182			+ for (y = 0; y < height; y++) {
183			+ guint32 src = (guint32 ) src_data;
184			+
185			+ for (x = 0; x < width; x++) {
186			+ guint alpha = src[x] >> 24;
187			+
188			+ if (alpha == 0)
189			+ {
190			+ dest_data[x * 4 + 0] = 0;
191			+ dest_data[x * 4 + 1] = 0;
192			+ dest_data[x * 4 + 2] = 0;
193			+ }
194			+ else
195			+ {
196			+ dest_data[x * 4 + 0] = (((src[x] & 0xff0000) >> 16) * 255 + alpha / 2) / alpha;
197			+ dest_data[x * 4 + 1] = (((src[x] & 0x00ff00) >> 8) * 255 + alpha / 2) / alpha;
198			+ dest_data[x * 4 + 2] = (((src[x] & 0x0000ff) >> 0) * 255 + alpha / 2) / alpha;
199			+ }
200			+ dest_data[x * 4 + 3] = alpha;
201			+ }
202			+
203			+ src_data += src_stride;
204			+ dest_data += dest_stride;
205			+ }
206			+}
207			+
208			+static void
209			+convert_no_alpha (guchar *dest_data,
210			+ int dest_stride,
211			+ guchar *src_data,
212			+ int src_stride,
213			+ int src_x,
214			+ int src_y,
215			+ int width,
216			+ int height)
217			+{
218			+ int x, y;
219			+
220			+ src_data += src_stride * src_y + src_x * 4;
221			+
222			+ for (y = 0; y < height; y++) {
223			+ guint32 src = (guint32 ) src_data;
224			+
225			+ for (x = 0; x < width; x++) {
226			+ dest_data[x * 3 + 0] = src[x] >> 16;
227			+ dest_data[x * 3 + 1] = src[x] >> 8;
228			+ dest_data[x * 3 + 2] = src[x];
229			+ }
230			+
231			+ src_data += src_stride;
232			+ dest_data += dest_stride;
233			+ }
234			+}
235			+
236			+/**
237			+ * gdk_pixbuf_get_from_surface:
238			+ * @surface: surface to copy from
239			+ * @src_x: Source X coordinate within @surface
240			+ * @src_y: Source Y coordinate within @surface
241			+ * @width: Width in pixels of region to get
242			+ * @height: Height in pixels of region to get
243			+ *
244			+ * Transfers image data from a #cairo_surface_t and converts it to an RGB(A)
245			+ * representation inside a #GdkPixbuf. This allows you to efficiently read
246			+ * individual pixels from cairo surfaces. For #GdkWindows, use
247			+ * gdk_pixbuf_get_from_window() instead.
248			+ *
249			+ * This function will create an RGB pixbuf with 8 bits per channel.
250			+ * The pixbuf will contain an alpha channel if the @surface contains one.
251			+ *
252			+ * Return value: (transfer full): A newly-created pixbuf with a reference
253			+ * count of 1, or %NULL on error
254			+ */
255			+static GdkPixbuf *
256			+gdk_pixbuf_get_from_surface (cairo_surface_t *surface,
257			+ gint src_x,
258			+ gint src_y,
259			+ gint width,
260			+ gint height)
261			+{
262			+ cairo_content_t content;
263			+ GdkPixbuf *dest;
264			+
265			+ /* General sanity checks */
266			+ g_return_val_if_fail (surface != NULL, NULL);
267			+ g_return_val_if_fail (width > 0 && height > 0, NULL);
268			+
269			+ content = cairo_surface_get_content (surface) \| CAIRO_CONTENT_COLOR;
270			+ dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
271			+ !!(content & CAIRO_CONTENT_ALPHA),
272			+ 8,
273			+ width, height);
274			+
275			+ surface = gdk_cairo_surface_coerce_to_image (surface, content,
276			+ src_x, src_y,
277			+ width, height);
278			+ cairo_surface_flush (surface);
279			+ if (cairo_surface_status (surface) \|\| dest == NULL)
280			+ {
281			+ cairo_surface_destroy (surface);
282			+ return NULL;
283			+ }
284			+
285			+ if (gdk_pixbuf_get_has_alpha (dest))
286			+ convert_alpha (gdk_pixbuf_get_pixels (dest),
287			+ gdk_pixbuf_get_rowstride (dest),
288			+ cairo_image_surface_get_data (surface),
289			+ cairo_image_surface_get_stride (surface),
290			+ 0, 0,
291			+ width, height);
292			+ else
293			+ convert_no_alpha (gdk_pixbuf_get_pixels (dest),
294			+ gdk_pixbuf_get_rowstride (dest),
295			+ cairo_image_surface_get_data (surface),
296			+ cairo_image_surface_get_stride (surface),
297			+ 0, 0,
298			+ width, height);
299			+
300			+ cairo_surface_destroy (surface);
301			+ return dest;
302			+}
303			+
304			+#endif
305			+
306			static gint32
307			layer_from_pixbuf (gint32 image,
308			const gchar *layer_name,
309			@@ -566,6 +758,54 @@ layer_from_pixbuf (gint32 image,
310			return layer;
311			}
312
313			+static cairo_surface_t *
314			+render_page_to_surface (PopplerPage *page,
315			+ int width,
316			+ int height,
317			+ double scale)
318			+{
319			+ cairo_surface_t *surface;
320			+ cairo_t *cr;
321			+
322			+ surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
323			+ cr = cairo_create (surface);
324			+
325			+ cairo_save (cr);
326			+ cairo_translate (cr, 0.0, 0.0);
327			+
328			+ if (scale != 1.0)
329			+ cairo_scale (cr, scale, scale);
330			+
331			+ poppler_page_render (page, cr);
332			+ cairo_restore (cr);
333			+
334			+ cairo_set_operator (cr, CAIRO_OPERATOR_DEST_OVER);
335			+ cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
336			+ cairo_paint (cr);
337			+
338			+ cairo_destroy (cr);
339			+
340			+ return surface;
341			+}
342			+
343			+static GdkPixbuf *
344			+render_page_to_pixbuf (PopplerPage *page,
345			+ int width,
346			+ int height,
347			+ double scale)
348			+{
349			+ GdkPixbuf *pixbuf;
350			+ cairo_surface_t *surface;
351			+
352			+ surface = render_page_to_surface (page, width, height, scale);
353			+ pixbuf = gdk_pixbuf_get_from_surface (surface, 0, 0,
354			+ cairo_image_surface_get_width (surface),
355			+ cairo_image_surface_get_height (surface));
356			+ cairo_surface_destroy (surface);
357			+
358			+ return pixbuf;
359			+}
360			+
361			static gint32
362			load_image (PopplerDocument *doc,
363			const gchar *filename,
364			@@ -597,7 +837,7 @@ load_image (PopplerDocument *doc,
365			gdouble page_width;
366			gdouble page_height;
367
368			- GdkPixbuf *buf;
369			+ GdkPixbuf *pixbuf;
370			gint width;
371			gint height;
372
373			@@ -627,15 +867,13 @@ load_image (PopplerDocument *doc,
374			gimp_image_set_resolution (image_ID, resolution, resolution);
375			}
376
377			- buf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, width, height);
378			-
379			- poppler_page_render_to_pixbuf (page, 0, 0, width, height, scale, 0, buf);
380			+ pixbuf = render_page_to_pixbuf (page, width, height, scale);
381
382			- layer_from_pixbuf (image_ID, page_label, i, buf,
383			+ layer_from_pixbuf (image_ID, page_label, i, pixbuf,
384			doc_progress, 1.0 / pages->n_pages);
385
386			g_free (page_label);
387			- g_object_unref (buf);
388			+ g_object_unref(pixbuf);
389
390			doc_progress = (double) (i + 1) / pages->n_pages;
391			gimp_progress_update (doc_progress);
392			@@ -676,30 +914,22 @@ load_image (PopplerDocument *doc,
393			return image_ID;
394			}
395
396			-static GdkPixbuf *
397			-get_thumbnail (PopplerDocument *doc,
398			- gint page_num,
399			- gint preferred_size)
400			+static cairo_surface_t *
401			+get_thumb_surface (PopplerDocument *doc,
402			+ gint page_num,
403			+ gint preferred_size)
404			{
405			PopplerPage *page;
406			- GdkPixbuf *pixbuf;
407			+ cairo_surface_t *surface;
408
409			page = poppler_document_get_page (doc, page_num);
410
411			if (! page)
412			return NULL;
413
414			- /* XXX: Remove conditional when we depend on poppler 0.8.0, but also
415			- * add configure check to make sure POPPLER_WITH_GDK is enabled!
416			- */
417			-#ifdef POPPLER_WITH_GDK
418			- pixbuf = poppler_page_get_thumbnail_pixbuf (page);
419			-#else
420			- pixbuf = poppler_page_get_thumbnail (page);
421			-#endif
422			-
423			+ surface = poppler_page_get_thumbnail (page);
424
425			- if (! pixbuf)
426			+ if (! surface)
427			{
428			gdouble width;
429			gdouble height;
430			@@ -712,15 +942,28 @@ get_thumbnail (PopplerDocument *doc,
431			width *= scale;
432			height *= scale;
433
434			- pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8,
435			- width, height);
436			-
437			- poppler_page_render_to_pixbuf (page,
438			- 0, 0, width, height, scale, 0, pixbuf);
439			+ surface = render_page_to_surface (page, width, height, scale);
440			}
441
442			g_object_unref (page);
443
444			+ return surface;
445			+}
446			+
447			+static GdkPixbuf *
448			+get_thumb_pixbuf (PopplerDocument *doc,
449			+ gint page_num,
450			+ gint preferred_size)
451			+{
452			+ cairo_surface_t *surface;
453			+ GdkPixbuf *pixbuf;
454			+
455			+ surface = get_thumb_surface (doc, page_num, preferred_size);
456			+ pixbuf = gdk_pixbuf_get_from_surface (surface, 0, 0,
457			+ cairo_image_surface_get_width (surface),
458			+ cairo_image_surface_get_height (surface));
459			+ cairo_surface_destroy (surface);
460			+
461			return pixbuf;
462			}
463
464			@@ -769,8 +1012,8 @@ thumbnail_thread (gpointer data)
465			idle_data->page_no = i;
466
467			/* FIXME get preferred size from somewhere? */
468			- idle_data->pixbuf = get_thumbnail (thread_data->document, i,
469			- THUMBNAIL_SIZE);
470			+ idle_data->pixbuf = get_thumb_pixbuf (thread_data->document, i,
471			+ THUMBNAIL_SIZE);
472
473			g_idle_add (idle_set_thumbnail, idle_data);
474
475			--
476			1.7.5