Author: ken
Date: 2011-12-05 13:24:53 -0700 (Mon, 05 Dec 2011)
New Revision: 2343
Added:
trunk/gimp/gimp-2.6.11-libpng_fix-1.patch
trunk/gimp/gimp-2.6.11-poppler_fix-1.patch
trunk/gimp/gimp-2.6.11-security_fix-1.patch
Log:
Fixes for current stable gimp.
Added: trunk/gimp/gimp-2.6.11-libpng_fix-1.patch
===================================================================
--- trunk/gimp/gimp-2.6.11-libpng_fix-1.patch (rev 0)
+++ trunk/gimp/gimp-2.6.11-libpng_fix-1.patch 2011-12-05 20:24:53 UTC (rev
2343)
@@ -0,0 +1,661 @@
+Submitted By: Ken Moffat <ken at linuxfromscratch dot org>
+Date: 2011-12-05
+Initial Package Version: 2.6.11
+Upstream Status: Applied
+Origin: Upstream
+Description: Fixes building with libpng-1.5.
+
+From a succession of fixes up to e7469007cea6e0e8c0432c172323a2200ee8beda
+by Mukund Sivaraman, cherry-picked into the 2.6 branch.
+
+
+diff -Naur gimp-2.6.11.orig/plug-ins/common/file-png.c
gimp-2.6.11/plug-ins/common/file-png.c
+--- gimp-2.6.11.orig/plug-ins/common/file-png.c 2010-07-13
21:22:27.000000000 +0100
++++ gimp-2.6.11/plug-ins/common/file-png.c 2011-12-05 19:25:45.647816531
+0000
+@@ -106,6 +106,17 @@
+ }
+ PngSaveGui;
+
++/* These are not saved or restored. */
++typedef struct
++{
++ gboolean has_trns;
++ png_bytep trans;
++ int num_trans;
++ gboolean has_plte;
++ png_colorp palette;
++ int num_palette;
++}
++PngGlobals;
+
+ /*
+ * Local functions...
+@@ -127,7 +138,7 @@
+ gint32 orig_image_ID,
+ GError **error);
+
+-static void respin_cmap (png_structp pp,
++static int respin_cmap (png_structp pp,
+ png_infop info,
+ guchar *remap,
+ gint32 image_ID,
+@@ -175,6 +186,7 @@
+ };
+
+ static PngSaveVals pngvals;
++static PngGlobals pngg;
+
+
+ /*
+@@ -653,13 +665,25 @@
+ error_data->drawable->width, num);
+ }
+
+- longjmp (png_ptr->jmpbuf, 1);
++ longjmp (png_jmpbuf (png_ptr), 1);
++}
++
++static int
++get_bit_depth_for_palette (int num_palette)
++{
++ if (num_palette <= 2)
++ return 1;
++ else if (num_palette <= 4)
++ return 2;
++ else if (num_palette <= 16)
++ return 4;
++ else
++ return 8;
+ }
+
+ /*
+ * 'load_image()' - Load a PNG image into a new image window.
+ */
+-
+ static gint32
+ load_image (const gchar *filename,
+ gboolean interactive,
+@@ -695,9 +719,20 @@
+ gint num_texts;
+
+ pp = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
++ if (!pp)
++ {
++ /* this could happen if the compile time and run-time libpng
++ versions do not match. */
++
++ g_set_error (error, 0, 0,
++ _("Error creating PNG read struct while saving '%s'."),
++ gimp_filename_to_utf8 (filename));
++ return -1;
++ }
++
+ info = png_create_info_struct (pp);
+
+- if (setjmp (pp->jmpbuf))
++ if (setjmp (png_jmpbuf (pp)))
+ {
+ g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
+ _("Error while reading '%s'. File corrupted?"),
+@@ -705,10 +740,6 @@
+ return image;
+ }
+
+- /* initialise image here, thus avoiding compiler warnings */
+-
+- image = -1;
+-
+ /*
+ * Open the file and initialize the PNG read "engine"...
+ */
+@@ -738,17 +769,19 @@
+ * Latest attempt, this should be my best yet :)
+ */
+
+- if (info->bit_depth == 16)
++ if (png_get_bit_depth (pp, info) == 16)
+ {
+ png_set_strip_16 (pp);
+ }
+
+- if (info->color_type == PNG_COLOR_TYPE_GRAY && info->bit_depth < 8)
++ if (png_get_color_type (pp, info) == PNG_COLOR_TYPE_GRAY &&
++ png_get_bit_depth (pp, info) < 8)
+ {
+ png_set_expand (pp);
+ }
+
+- if (info->color_type == PNG_COLOR_TYPE_PALETTE && info->bit_depth < 8)
++ if (png_get_color_type (pp, info) == PNG_COLOR_TYPE_PALETTE &&
++ png_get_bit_depth (pp, info) < 8)
+ {
+ png_set_packing (pp);
+ }
+@@ -757,8 +790,8 @@
+ * Expand G+tRNS to GA, RGB+tRNS to RGBA
+ */
+
+- if (info->color_type != PNG_COLOR_TYPE_PALETTE &&
+- (info->valid & PNG_INFO_tRNS))
++ if (png_get_color_type (pp, info) != PNG_COLOR_TYPE_PALETTE &&
++ png_get_valid (pp, info, PNG_INFO_tRNS))
+ {
+ png_set_expand (pp);
+ }
+@@ -775,7 +808,7 @@
+ */
+
+ if (png_get_valid (pp, info, PNG_INFO_tRNS) &&
+- info->color_type == PNG_COLOR_TYPE_PALETTE)
++ png_get_color_type (pp, info) == PNG_COLOR_TYPE_PALETTE)
+ {
+ png_get_tRNS (pp, info, &alpha_ptr, &num, NULL);
+ /* Copy the existing alpha values from the tRNS chunk */
+@@ -797,7 +830,7 @@
+
+ png_read_update_info (pp, info);
+
+- switch (info->color_type)
++ switch (png_get_color_type (pp, info))
+ {
+ case PNG_COLOR_TYPE_RGB: /* RGB */
+ bpp = 3;
+@@ -836,7 +869,9 @@
+ return -1;
+ }
+
+- image = gimp_image_new (info->width, info->height, image_type);
++ image = gimp_image_new (png_get_image_width (pp, info),
++ png_get_image_height (pp, info),
++ image_type);
+ if (image == -1)
+ {
+ g_set_error (error, 0, 0,
+@@ -849,7 +884,9 @@
+ * Create the "background" layer to hold the image...
+ */
+
+- layer = gimp_layer_new (image, _("Background"), info->width, info->height,
++ layer = gimp_layer_new (image, _("Background"),
++ png_get_image_width (pp, info),
++ png_get_image_height (pp, info),
+ layer_type, 100, GIMP_NORMAL_MODE);
+ gimp_image_add_layer (image, layer, 0);
+
+@@ -883,7 +920,8 @@
+
+ gimp_layer_set_offsets (layer, offset_x, offset_y);
+
+- if ((abs (offset_x) > info->width) || (abs (offset_y) > info->height))
++ if ((abs (offset_x) > png_get_image_width (pp, info)) ||
++ (abs (offset_y) > png_get_image_height (pp, info)))
+ {
+ if (interactive)
+ g_message (_("The PNG file specifies an offset that caused "
+@@ -938,23 +976,27 @@
+
+ empty = 0; /* by default assume no full transparent palette entries */
+
+- if (info->color_type & PNG_COLOR_MASK_PALETTE)
++ if (png_get_color_type (pp, info) & PNG_COLOR_MASK_PALETTE)
+ {
++ png_colorp palette;
++ int num_palette;
++
++ png_get_PLTE (pp, info, &palette, &num_palette);
+ if (png_get_valid (pp, info, PNG_INFO_tRNS))
+ {
+ for (empty = 0; empty < 256 && alpha[empty] == 0; ++empty)
+ /* Calculates number of fully transparent "empty" entries */;
+
+ /* keep at least one entry */
+- empty = MIN (empty, info->num_palette - 1);
++ empty = MIN (empty, num_palette - 1);
+
+- gimp_image_set_colormap (image, (guchar *) (info->palette + empty),
+- info->num_palette - empty);
++ gimp_image_set_colormap (image, (guchar *) (palette + empty),
++ num_palette - empty);
+ }
+ else
+ {
+- gimp_image_set_colormap (image, (guchar *) info->palette,
+- info->num_palette);
++ gimp_image_set_colormap (image, (guchar *) palette,
++ num_palette);
+ }
+ }
+
+@@ -972,18 +1014,19 @@
+ */
+
+ tile_height = gimp_tile_height ();
+- pixel = g_new0 (guchar, tile_height * info->width * bpp);
++ pixel = g_new0 (guchar, tile_height * png_get_image_width (pp, info) * bpp);
+ pixels = g_new (guchar *, tile_height);
+
+ for (i = 0; i < tile_height; i++)
+- pixels[i] = pixel + info->width * info->channels * i;
++ pixels[i] = pixel + png_get_image_width (pp, info) *
++ png_get_channels (pp, info) * i;
+
+ /* Install our own error handler to handle incomplete PNG files better */
+ error_data.drawable = drawable;
+ error_data.pixel = pixel;
+ error_data.tile_height = tile_height;
+- error_data.width = info->width;
+- error_data.height = info->height;
++ error_data.width = png_get_image_width (pp, info);
++ error_data.height = png_get_image_height (pp, info);
+ error_data.bpp = bpp;
+ error_data.pixel_rgn = &pixel_rgn;
+
+@@ -996,10 +1039,11 @@
+ */
+
+ for (begin = 0, end = tile_height;
+- begin < info->height; begin += tile_height, end += tile_height)
++ begin < png_get_image_height (pp, info);
++ begin += tile_height, end += tile_height)
+ {
+- if (end > info->height)
+- end = info->height;
++ if (end > png_get_image_height (pp, info))
++ end = png_get_image_height (pp, info);
+
+ num = end - begin;
+
+@@ -1016,11 +1060,13 @@
+ gimp_pixel_rgn_set_rect (&pixel_rgn, pixel, 0, begin,
+ drawable->width, num);
+
+- memset (pixel, 0, tile_height * info->width * bpp);
++ memset (pixel, 0,
++ tile_height * png_get_image_width (pp, info) * bpp);
+
+- gimp_progress_update (((gdouble) pass +
+- (gdouble) end / (gdouble) info->height) /
+- (gdouble) num_passes);
++ gimp_progress_update
++ (((gdouble) pass +
++ (gdouble) end / (gdouble) png_get_image_height (pp, info)) /
++ (gdouble) num_passes);
+ }
+ }
+
+@@ -1189,7 +1235,6 @@
+ GimpPixelRgn pixel_rgn; /* Pixel region for layer */
+ png_structp pp; /* PNG read pointer */
+ png_infop info; /* PNG info pointer */
+- gint num_colors; /* Number of colors in colormap */
+ gint offx, offy; /* Drawable offsets from origin */
+ guchar **pixels, /* Pixel rows */
+ *fixed, /* Fixed-up pixel data */
+@@ -1200,56 +1245,28 @@
+ guchar red, green, blue; /* Used for palette background */
+ time_t cutime; /* Time since epoch */
+ struct tm *gmt; /* GMT broken down */
++ int color_type;
++ int bit_depth;
+
+ guchar remap[256]; /* Re-mapping for the palette */
+
+ png_textp text = NULL;
+
+- if (pngvals.comment)
++ pp = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
++ if (!pp)
+ {
+- GimpParasite *parasite;
+- gsize text_length = 0;
+-
+- parasite = gimp_image_parasite_find (orig_image_ID, "gimp-comment");
+- if (parasite)
+- {
+- gchar *comment = g_strndup (gimp_parasite_data (parasite),
+- gimp_parasite_data_size (parasite));
+-
+- gimp_parasite_free (parasite);
+-
+- text = g_new0 (png_text, 1);
+- text->key = "Comment";
++ /* this could happen if the compile time and run-time libpng
++ versions do not match. */
+
+-#ifdef PNG_iTXt_SUPPORTED
+-
+- text->compression = PNG_ITXT_COMPRESSION_NONE;
+- text->text = comment;
+- text->itxt_length = strlen (comment);
+-
+-#else
+-
+- text->compression = PNG_TEXT_COMPRESSION_NONE;
+- text->text = g_convert (comment, -1,
+- "ISO-8859-1", "UTF-8",
+- NULL, &text_length,
+- NULL);
+- text->text_length = text_length;
+-
+-#endif
+-
+- if (!text->text)
+- {
+- g_free (text);
+- text = NULL;
+- }
+- }
++ g_set_error (error, 0, 0,
++ _("Error creating PNG write struct while saving '%s'."),
++ gimp_filename_to_utf8 (filename));
++ return FALSE;
+ }
+
+- pp = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+ info = png_create_info_struct (pp);
+
+- if (setjmp (pp->jmpbuf))
++ if (setjmp (png_jmpbuf (pp)))
+ {
+ g_set_error (error, 0, 0,
+ _("Error while saving '%s'. Could not save image."),
+@@ -1257,9 +1274,6 @@
+ return FALSE;
+ }
+
+- if (text)
+- png_set_text (pp, info, text, 1);
+-
+ /*
+ * Open the file and initialize the PNG write "engine"...
+ */
+@@ -1286,17 +1300,6 @@
+ type = gimp_drawable_type (drawable_ID);
+
+ /*
+- * Set the image dimensions, bit depth, interlacing and compression
+- */
+-
+- png_set_compression_level (pp, pngvals.compression_level);
+-
+- info->width = drawable->width;
+- info->height = drawable->height;
+- info->bit_depth = 8;
+- info->interlace_type = pngvals.interlaced;
+-
+- /*
+ * Initialise remap[]
+ */
+ for (i = 0; i < 256; i++)
+@@ -1306,42 +1309,44 @@
+ * Set color type and remember bytes per pixel count
+ */
+
++ bit_depth = 8;
++
+ switch (type)
+ {
+ case GIMP_RGB_IMAGE:
+- info->color_type = PNG_COLOR_TYPE_RGB;
++ color_type = PNG_COLOR_TYPE_RGB;
+ bpp = 3;
+ break;
+
+ case GIMP_RGBA_IMAGE:
+- info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
++ color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+ bpp = 4;
+ break;
+
+ case GIMP_GRAY_IMAGE:
+- info->color_type = PNG_COLOR_TYPE_GRAY;
++ color_type = PNG_COLOR_TYPE_GRAY;
+ bpp = 1;
+ break;
+
+ case GIMP_GRAYA_IMAGE:
+- info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
++ color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+ bpp = 2;
+ break;
+
+ case GIMP_INDEXED_IMAGE:
+ bpp = 1;
+- info->color_type = PNG_COLOR_TYPE_PALETTE;
+- info->valid |= PNG_INFO_PLTE;
+- info->palette =
+- (png_colorp) gimp_image_get_colormap (image_ID, &num_colors);
+- info->num_palette = num_colors;
++ color_type = PNG_COLOR_TYPE_PALETTE;
++ pngg.has_plte = TRUE;
++ pngg.palette = (png_colorp) gimp_image_get_colormap (image_ID,
++ &pngg.num_palette);
++ bit_depth = get_bit_depth_for_palette (pngg.num_palette);
+ break;
+
+ case GIMP_INDEXEDA_IMAGE:
+ bpp = 2;
+- info->color_type = PNG_COLOR_TYPE_PALETTE;
++ color_type = PNG_COLOR_TYPE_PALETTE;
+ /* fix up transparency */
+- respin_cmap (pp, info, remap, image_ID, drawable);
++ bit_depth = respin_cmap (pp, info, remap, image_ID, drawable);
+ break;
+
+ default:
+@@ -1349,21 +1354,29 @@
+ return FALSE;
+ }
+
+- /*
+- * Fix bit depths for (possibly) smaller colormap images
+- */
++ /* Note: png_set_IHDR() must be called before any other png_set_*()
++ functions. */
++ png_set_IHDR (pp, info, drawable->width, drawable->height,
++ bit_depth,
++ color_type,
++ pngvals.interlaced ? PNG_INTERLACE_ADAM7 : PNG_INTERLACE_NONE,
++ PNG_COMPRESSION_TYPE_BASE,
++ PNG_FILTER_TYPE_BASE);
+
+- if (info->valid & PNG_INFO_PLTE)
++ if (pngg.has_trns)
+ {
+- if (info->num_palette <= 2)
+- info->bit_depth = 1;
+- else if (info->num_palette <= 4)
+- info->bit_depth = 2;
+- else if (info->num_palette <= 16)
+- info->bit_depth = 4;
+- /* otherwise the default is fine */
++ png_set_tRNS (pp, info, pngg.trans, pngg.num_trans, NULL);
+ }
+
++ if (pngg.has_plte)
++ {
++ png_set_PLTE (pp, info, pngg.palette, pngg.num_palette);
++ }
++
++ /* Set the compression level */
++
++ png_set_compression_level (pp, pngvals.compression_level);
++
+ /* All this stuff is optional extras, if the user is aiming for smallest
+ possible file size she can turn them all off */
+
+@@ -1462,6 +1475,52 @@
+ }
+ #endif
+
++ if (pngvals.comment)
++ {
++ GimpParasite *parasite;
++#ifndef PNG_iTXt_SUPPORTED
++ gsize text_length = 0;
++#endif /* PNG_iTXt_SUPPORTED */
++
++ parasite = gimp_image_parasite_find (orig_image_ID, "gimp-comment");
++ if (parasite)
++ {
++ gchar *comment = g_strndup (gimp_parasite_data (parasite),
++ gimp_parasite_data_size (parasite));
++
++ gimp_parasite_free (parasite);
++
++ text = g_new0 (png_text, 1);
++ text->key = "Comment";
++
++#ifdef PNG_iTXt_SUPPORTED
++
++ text->compression = PNG_ITXT_COMPRESSION_NONE;
++ text->text = comment;
++ text->itxt_length = strlen (comment);
++
++#else
++
++ text->compression = PNG_TEXT_COMPRESSION_NONE;
++ text->text = g_convert (comment, -1,
++ "ISO-8859-1", "UTF-8",
++ NULL, &text_length,
++ NULL);
++ text->text_length = text_length;
++
++#endif
++
++ if (!text->text)
++ {
++ g_free (text);
++ text = NULL;
++ }
++ }
++ }
++
++ if (text)
++ png_set_text (pp, info, text, 1);
++
+ png_write_info (pp, info);
+
+ /*
+@@ -1477,7 +1536,8 @@
+ * Convert unpacked pixels to packed if necessary
+ */
+
+- if (info->color_type == PNG_COLOR_TYPE_PALETTE && info->bit_depth < 8)
++ if (color_type == PNG_COLOR_TYPE_PALETTE &&
++ bit_depth < 8)
+ png_set_packing (pp);
+
+ /*
+@@ -1507,7 +1567,9 @@
+
+ gimp_pixel_rgn_get_rect (&pixel_rgn, pixel, 0, begin,
+ drawable->width, num);
+- /*if we are with a RGBA image and have to pre-multiply the alpha
channel */
++
++ /* If we are with a RGBA image and have to pre-multiply the
++ alpha channel */
+ if (bpp == 4 && ! pngvals.save_transp_pixels)
+ {
+ for (i = 0; i < num; ++i)
+@@ -1529,7 +1591,7 @@
+
+ /* If we're dealing with a paletted image with
+ * transparency set, write out the remapped palette */
+- if (info->valid & PNG_INFO_tRNS)
++ if (png_get_valid (pp, info, PNG_INFO_tRNS))
+ {
+ guchar inverse_remap[256];
+
+@@ -1547,9 +1609,11 @@
+ }
+ }
+ }
++
+ /* Otherwise if we have a paletted image and transparency
+ * couldn't be set, we ignore the alpha channel */
+- else if (info->valid & PNG_INFO_PLTE && bpp == 2)
++ else if (png_get_valid (pp, info, PNG_INFO_PLTE) &&
++ bpp == 2)
+ {
+ for (i = 0; i < num; ++i)
+ {
+@@ -1564,7 +1628,7 @@
+ png_write_rows (pp, pixels, num);
+
+ gimp_progress_update (((double) pass + (double) end /
+- (double) info->height) /
++ (double) drawable->height) /
+ (double) num_passes);
+ }
+ }
+@@ -1694,14 +1758,14 @@
+ }
+
+
+-static void
++static int
+ respin_cmap (png_structp pp,
+ png_infop info,
+ guchar *remap,
+ gint32 image_ID,
+ GimpDrawable *drawable)
+ {
+- static const guchar trans[] = { 0 };
++ static guchar trans[] = { 0 };
+
+ gint colors;
+ guchar *before;
+@@ -1728,10 +1792,13 @@
+ * index - do like gif2png and swap
+ * index 0 and index transparent */
+ {
+- png_color palette[256];
++ static png_color palette[256];
+ gint i;
+
+- png_set_tRNS (pp, info, (png_bytep) trans, 1, NULL);
++ /* Set tRNS chunk values for writing later. */
++ pngg.has_trns = TRUE;
++ pngg.trans = trans;
++ pngg.num_trans = 1;
+
+ /* Transform all pixels with a value = transparent to
+ * 0 and vice versa to compensate for re-ordering in palette
+@@ -1752,7 +1819,10 @@
+ palette[i].blue = before[3 * remap[i] + 2];
+ }
+
+- png_set_PLTE (pp, info, palette, colors);
++ /* Set PLTE chunk values for writing later. */
++ pngg.has_plte = TRUE;
++ pngg.palette = palette;
++ pngg.num_palette = colors;
+ }
+ else
+ {
+@@ -1760,14 +1830,22 @@
+ * transparency & just use the full palette */
+ g_message (_("Couldn't losslessly save transparency, "
+ "saving opacity instead."));
+- png_set_PLTE (pp, info, (png_colorp) before, colors);
++
++ /* Set PLTE chunk values for writing later. */
++ pngg.has_plte = TRUE;
++ pngg.palette = (png_colorp) before;
++ pngg.num_palette = colors;
+ }
+ }
+ else
+ {
+- png_set_PLTE (pp, info, (png_colorp) before, colors);
++ /* Set PLTE chunk values for writing later. */
++ pngg.has_plte = TRUE;
++ pngg.palette = (png_colorp) before;
++ pngg.num_palette = colors;
+ }
+
++ return get_bit_depth_for_palette (colors);
+ }
+
+ static gboolean
Added: trunk/gimp/gimp-2.6.11-poppler_fix-1.patch
===================================================================
--- trunk/gimp/gimp-2.6.11-poppler_fix-1.patch (rev 0)
+++ trunk/gimp/gimp-2.6.11-poppler_fix-1.patch 2011-12-05 20:24:53 UTC (rev
2343)
@@ -0,0 +1,486 @@
+Submitted By: Ken Moffat <ken at linuxfromscratch dot org>
+Date: 2011-12-05
+Initial Package Version: 2.6.11
+Upstream Status: Applied
+Origin: Upstream
+Description: Fixes compilation with poppler-0.1{7,8}
+
+ Found at PLD.
+
+From 69f69eed816b89be9a01a48a1f0643d1fd496118 Mon Sep 17 00:00:00 2001
+From: Nils Philippsen <[email protected]>
+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 <[email protected]>
+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 <[email protected]>
+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 <[email protected]>
+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 <[email protected]>
+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
+
Added: trunk/gimp/gimp-2.6.11-security_fix-1.patch
===================================================================
--- trunk/gimp/gimp-2.6.11-security_fix-1.patch (rev 0)
+++ trunk/gimp/gimp-2.6.11-security_fix-1.patch 2011-12-05 20:24:53 UTC (rev
2343)
@@ -0,0 +1,66 @@
+Submitted By: Ken Moffat <ken at linuxfromscratch dot org>
+Date: 2011-12-05
+Initial Package Version: 2.6.11
+Upstream Status: Applied
+Origin: Fedora
+Description: Fix CVE-2011-2896
+
+From 376ad788c1a1c31d40f18494889c383f6909ebfc Mon Sep 17 00:00:00 2001
+From: Nils Philippsen <[email protected]>
+Date: Thu, 04 Aug 2011 10:51:42 +0000
+Subject: file-gif-load: fix heap corruption and buffer overflow (CVE-2011-2896)
+
+---
+diff --git a/plug-ins/common/file-gif-load.c b/plug-ins/common/file-gif-load.c
+index 81f3bd0..c91e7aa 100644
+--- a/plug-ins/common/file-gif-load.c
++++ b/plug-ins/common/file-gif-load.c
+@@ -713,7 +713,8 @@ LZWReadByte (FILE *fd,
+ static gint firstcode, oldcode;
+ static gint clear_code, end_code;
+ static gint table[2][(1 << MAX_LZW_BITS)];
+- static gint stack[(1 << (MAX_LZW_BITS)) * 2], *sp;
++#define STACK_SIZE ((1 << (MAX_LZW_BITS)) * 2)
++ static gint stack[STACK_SIZE], *sp;
+ gint i;
+
+ if (just_reset_LZW)
+@@ -788,7 +789,7 @@ LZWReadByte (FILE *fd,
+
+ return firstcode & 255;
+ }
+- else if (code == end_code)
++ else if (code == end_code || code > max_code)
+ {
+ gint count;
+ guchar buf[260];
+@@ -807,13 +808,14 @@ LZWReadByte (FILE *fd,
+
+ incode = code;
+
+- if (code >= max_code)
++ if (code == max_code)
+ {
+- *sp++ = firstcode;
++ if (sp < &(stack[STACK_SIZE]))
++ *sp++ = firstcode;
+ code = oldcode;
+ }
+
+- while (code >= clear_code)
++ while (code >= clear_code && sp < &(stack[STACK_SIZE]))
+ {
+ *sp++ = table[1][code];
+ if (code == table[0][code])
+@@ -824,7 +826,8 @@ LZWReadByte (FILE *fd,
+ code = table[0][code];
+ }
+
+- *sp++ = firstcode = table[1][code];
++ if (sp < &(stack[STACK_SIZE]))
++ *sp++ = firstcode = table[1][code];
+
+ if ((code = max_code) < (1 << MAX_LZW_BITS))
+ {
+--
+cgit v0.9.0.2
--
http://linuxfromscratch.org/mailman/listinfo/patches
FAQ: http://www.linuxfromscratch.org/faq/
Unsubscribe: See the above information page
