[ghostscript/f13/master] Apply some fixes from upstream to avoid gdevcups segfaults (bug #639593).
Tim Waugh
twaugh at fedoraproject.org
Thu Oct 14 16:08:54 UTC 2010
commit 213d41aedc110b32131b42d05a2fa24a00286c8b
Author: Tim Waugh <twaugh at redhat.com>
Date: Thu Oct 14 17:07:59 2010 +0100
Apply some fixes from upstream to avoid gdevcups segfaults (bug #639593).
ghostscript-gdevcups-segfaults.patch | 1812 ++++++++++++++++++++++++++++++++++
ghostscript.spec | 6 +
2 files changed, 1818 insertions(+), 0 deletions(-)
---
diff --git a/ghostscript-gdevcups-segfaults.patch b/ghostscript-gdevcups-segfaults.patch
new file mode 100644
index 0000000..53602d8
--- /dev/null
+++ b/ghostscript-gdevcups-segfaults.patch
@@ -0,0 +1,1812 @@
+diff -up ghostscript-8.71/cups/gdevcups.c.gdevcups-segfaults ghostscript-8.71/cups/gdevcups.c
+--- ghostscript-8.71/cups/gdevcups.c.gdevcups-segfaults 2010-10-14 17:05:32.266994174 +0100
++++ ghostscript-8.71/cups/gdevcups.c 2010-10-14 17:05:32.281994345 +0100
+@@ -1,5 +1,5 @@
+ /*
+- * "$Id: gdevcups.c 10631 2010-01-22 17:46:02Z till $"
++ * "$Id$"
+ *
+ * GNU Ghostscript raster output driver for the Common UNIX Printing
+ * System (CUPS).
+@@ -34,6 +34,8 @@
+ * cups_close() - Close the output file.
+ * cups_decode_color() - Decode a color value.
+ * cups_encode_color() - Encode a color value.
++ * cups_get_color_comp_index()
++ * - Color component to index
+ * cups_get_color_mapping_procs()
+ * - Get the list of color mapping procedures.
+ * cups_get_matrix() - Generate the default page matrix.
+@@ -66,7 +68,6 @@
+ #include "std.h" /* to stop stdlib.h redefining types */
+ #include "gdevprn.h"
+ #include "gsparam.h"
+-#include "gsexit.h"
+ #include "arch.h"
+
+ #include <stdlib.h>
+@@ -78,6 +79,12 @@
+ #undef private
+ #define private
+
++/* This should go into gdevprn.h, or, better yet, gdevprn should
++ acquire an API for changing resolution. */
++int gdev_prn_maybe_realloc_memory(gx_device_printer *pdev,
++ gdev_prn_space_params *old_space,
++ int old_width, int old_height,
++ bool old_page_uses_transparency);
+
+ /*
+ * Check if we are compiling against CUPS 1.2. If so, enable
+@@ -95,16 +102,6 @@
+
+
+ /*
+- * Newer versions of Ghostscript don't provide gs_exit() function anymore.
+- * It has been renamed to gs_to_exit()...
+- */
+-
+-#ifdef dev_t_proc_encode_color
+-# define gs_exit gs_to_exit
+-#endif /* dev_t_proc_encode_color */
+-
+-
+-/*
+ * CIE XYZ color constants...
+ */
+
+@@ -177,6 +174,7 @@ private cm_map_proc_rgb(cups_map_rgb);
+ private cm_map_proc_cmyk(cups_map_cmyk);
+ private dev_proc_decode_color(cups_decode_color);
+ private dev_proc_encode_color(cups_encode_color);
++private dev_proc_get_color_comp_index(cups_get_color_comp_index);
+ private dev_proc_get_color_mapping_procs(cups_get_color_mapping_procs);
+
+ static const gx_cm_color_map_procs cups_color_mapping_procs =
+@@ -204,6 +202,24 @@ typedef struct gx_device_cups_s
+ cups_raster_t *stream; /* Raster stream */
+ cups_page_header_t header; /* PostScript page device info */
+ int landscape; /* Non-zero if this is landscape */
++ int lastpage;
++ int HaveProfile; /* Has a color profile been defined? */
++ char *Profile; /* Current simple color profile string */
++ ppd_file_t *PPD; /* PPD file for this device */
++ unsigned char RevLower1[16]; /* Lower 1-bit reversal table */
++ unsigned char RevUpper1[16]; /* Upper 1-bit reversal table */
++ unsigned char RevLower2[16]; /* Lower 2-bit reversal table */
++ unsigned char RevUpper2[16]; /* Upper 2-bit reversal table */
++#ifdef GX_COLOR_INDEX_TYPE
++ gx_color_value DecodeLUT[65536];/* Output color to RGB value LUT */
++#else
++ gx_color_value DecodeLUT[256]; /* Output color to RGB value LUT */
++#endif /* GX_COLOR_INDEX_TYPE */
++ unsigned short EncodeLUT[gx_max_color_value + 1];/* RGB value to output color LUT */
++ int Density[CUPS_MAX_VALUE + 1];/* Density LUT */
++ int Matrix[3][3][CUPS_MAX_VALUE + 1];/* Color transform matrix LUT */
++
++ /* Used by cups_put_params(): */
+ } gx_device_cups;
+
+ private gx_device_procs cups_procs =
+@@ -268,7 +284,7 @@ private gx_device_procs cups_procs =
+ NULL, /* discard_transparency_layer */
+ #ifdef dev_t_proc_encode_color
+ cups_get_color_mapping_procs,
+- gx_error_get_color_comp_index, /* Dummy to avoid segfault */
++ cups_get_color_comp_index,
+ cups_encode_color,
+ cups_decode_color,
+ #else
+@@ -285,7 +301,9 @@ private gx_device_procs cups_procs =
+ NULL, /* fill_linear_color_triangle */
+ NULL, /* update_spot_equivalent_colors */
+ NULL, /* ret_devn_params */
+- NULL /* fillpage */
++ NULL, /* fillpage */
++ NULL, /* push_transparency_state */
++ NULL /* pop_transparency_state */
+ };
+
+ #define prn_device_body_copies(dtype, procs, dname, w10, h10, xdpi, ydpi, lo, to, lm, bm, rm, tm, ncomp, depth, mg, mc, dg, dc, print_pages)\
+@@ -381,63 +399,35 @@ gx_device_cups gs_cups_device =
+ "" /* cupsPageSizeName */
+ #endif /* CUPS_RASTER_SYNCv1 */
+ },
+- 0 /* landscape */
++ 0, /* landscape */
++ 0, /* lastpage */
++ 0, /* HaveProfile */
++ NULL, /* Profile */
++ NULL, /* PPD */
++ { 0x00, 0x08, 0x04, 0x0c, 0x02, 0x0a, 0x06, 0x0e,
++ 0x01, 0x09, 0x05, 0x0d, 0x03, 0x0b, 0x07, 0x0f },/* RevLower1 */
++ { 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
++ 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0 },/* RevUpper1 */
++ { 0x00, 0x04, 0x08, 0x0c, 0x01, 0x05, 0x09, 0x0d,
++ 0x02, 0x06, 0x0a, 0x0e, 0x03, 0x07, 0x0b, 0x0f },/* RevLower2 */
++ { 0x00, 0x40, 0x80, 0xc0, 0x10, 0x50, 0x90, 0xd0,
++ 0x20, 0x60, 0xa0, 0xe0, 0x30, 0x70, 0xb0, 0xf0 },/* RevUpper2 */
++ { }, /* DecodeLUT */
++ { }, /* EncodeLUT */
++ { }, /* Density */
++ { } /* Matrix */
+ };
+
+ /*
+- * Globals...
+- */
+-
+-#ifdef GX_COLOR_INDEX_TYPE
+-static gx_color_value cupsDecodeLUT[65536];
+- /* Output color to RGB value LUT */
+-#else
+-static gx_color_value cupsDecodeLUT[256];
+- /* Output color to RGB value LUT */
+-#endif /* GX_COLOR_INDEX_TYPE */
+-static unsigned short cupsEncodeLUT[gx_max_color_value + 1];
+- /* RGB value to output color LUT */
+-
+-static ppd_file_t *cupsPPD = 0; /* PPD file for this device */
+-static char *cupsProfile = NULL;
+- /* Current simple color profile string */
+-static int cupsHaveProfile = 0;
+- /* Has a color profile been defined? */
+-static int cupsMatrix[3][3][CUPS_MAX_VALUE + 1];
+- /* Color transform matrix LUT */
+-static int cupsDensity[CUPS_MAX_VALUE + 1];
+- /* Density LUT */
+-static unsigned char cupsRevLower1[16] =
+- { /* Lower 1-bit reversal table */
+- 0x00, 0x08, 0x04, 0x0c, 0x02, 0x0a, 0x06, 0x0e,
+- 0x01, 0x09, 0x05, 0x0d, 0x03, 0x0b, 0x07, 0x0f
+- },
+- cupsRevUpper1[16] =
+- { /* Upper 1-bit reversal table */
+- 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
+- 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0
+- },
+- cupsRevLower2[16] =
+- { /* Lower 2-bit reversal table */
+- 0x00, 0x04, 0x08, 0x0c, 0x01, 0x05, 0x09, 0x0d,
+- 0x02, 0x06, 0x0a, 0x0e, 0x03, 0x07, 0x0b, 0x0f
+- },
+- cupsRevUpper2[16] =
+- { /* Upper 2-bit reversal table */
+- 0x00, 0x40, 0x80, 0xc0, 0x10, 0x50, 0x90, 0xd0,
+- 0x20, 0x60, 0xa0, 0xe0, 0x30, 0x70, 0xb0, 0xf0
+- };
+-
+-/*
+ * Local functions...
+ */
+
+ static double cups_map_cielab(double, double);
+-static void cups_print_chunked(gx_device_printer *, unsigned char *,
++static int cups_print_chunked(gx_device_printer *, unsigned char *,
+ unsigned char *, int);
+-static void cups_print_banded(gx_device_printer *, unsigned char *,
++static int cups_print_banded(gx_device_printer *, unsigned char *,
+ unsigned char *, int);
+-static void cups_print_planar(gx_device_printer *, unsigned char *,
++static int cups_print_planar(gx_device_printer *, unsigned char *,
+ unsigned char *, int);
+
+ /*static void cups_set_margins(gx_device *);*/
+@@ -459,16 +449,16 @@ cups_close(gx_device *pdev) /* I - Devi
+ }
+
+ #if 0 /* Can't do this here because put_params() might close the device */
+- if (cupsPPD != NULL)
++ if (cups->PPD != NULL)
+ {
+- ppdClose(cupsPPD);
+- cupsPPD = NULL;
++ ppdClose(cups->PPD);
++ cups->PPD = NULL;
+ }
+
+- if (cupsProfile != NULL)
++ if (cups->Profile != NULL)
+ {
+- free(cupsProfile);
+- cupsProfile = NULL;
++ free(cups->Profile);
++ cups->Profile = NULL;
+ }
+ #endif /* 0 */
+
+@@ -509,9 +499,9 @@ cups_decode_color(gx_device *pdev,
+ mask = (1 << shift) - 1;
+
+ for (i = cups->color_info.num_components - 1; i > 0; i --, ci >>= shift)
+- cv[i] = cupsDecodeLUT[ci & mask];
++ cv[i] = cups->DecodeLUT[ci & mask];
+
+- cv[0] = cupsDecodeLUT[ci & mask];
++ cv[0] = cups->DecodeLUT[ci & mask];
+ }
+
+ return (0);
+@@ -539,10 +529,10 @@ cups_encode_color(gx_device *
+
+ shift = cups->header.cupsBitsPerColor;
+
+- for (ci = cupsEncodeLUT[cv[0]], i = 1;
++ for (ci = cups->EncodeLUT[cv[0]], i = 1;
+ i < cups->color_info.num_components;
+ i ++)
+- ci = (ci << shift) | cupsEncodeLUT[cv[i]];
++ ci = (ci << shift) | cups->EncodeLUT[cv[i]];
+
+ #ifdef DEBUG
+ dprintf2("DEBUG2: cv[0]=%d -> %llx\n", cv[0], ci);
+@@ -583,6 +573,145 @@ cups_encode_color(gx_device *
+ return (ci);
+ }
+
++/*
++ * 'cups_get_color_comp_index()' - Color component to index
++ */
++
++#define compare_color_names(pname, name_size, name_str) \
++ (name_size == (int)strlen(name_str) && strncasecmp(pname, name_str, name_size) == 0)
++
++int /* O - Index of the named color in
++ the color space */
++cups_get_color_comp_index(gx_device * pdev, const char * pname,
++ int name_size, int component_type)
++{
++ switch (cups->header.cupsColorSpace)
++ {
++ case CUPS_CSPACE_K :
++ if (compare_color_names(pname, name_size, "Black") ||
++ compare_color_names(pname, name_size, "Gray") ||
++ compare_color_names(pname, name_size, "Grey"))
++ return 0;
++ else
++ return -1; /* Indicate that the component name is "unknown" */
++ break;
++ case CUPS_CSPACE_W :
++ case CUPS_CSPACE_WHITE :
++ if (compare_color_names(pname, name_size, "White") ||
++ compare_color_names(pname, name_size, "Luminance") ||
++ compare_color_names(pname, name_size, "Gray") ||
++ compare_color_names(pname, name_size, "Grey"))
++ return 0;
++ else
++ return -1;
++ break;
++ case CUPS_CSPACE_RGBA :
++ if (compare_color_names(pname, name_size, "Alpha") ||
++ compare_color_names(pname, name_size, "Transparent") ||
++ compare_color_names(pname, name_size, "Transparency"))
++ return 3;
++ case CUPS_CSPACE_RGBW :
++ if (compare_color_names(pname, name_size, "White"))
++ return 3;
++ case CUPS_CSPACE_RGB :
++ if (compare_color_names(pname, name_size, "Red"))
++ return 0;
++ if (compare_color_names(pname, name_size, "Green"))
++ return 1;
++ if (compare_color_names(pname, name_size, "Blue"))
++ return 2;
++ else
++ return -1;
++ break;
++ case CUPS_CSPACE_CMYK :
++# ifdef CUPS_RASTER_HAVE_COLORIMETRIC
++ case CUPS_CSPACE_CIEXYZ :
++ case CUPS_CSPACE_CIELab :
++ case CUPS_CSPACE_ICC1 :
++ case CUPS_CSPACE_ICC2 :
++ case CUPS_CSPACE_ICC3 :
++ case CUPS_CSPACE_ICC4 :
++ case CUPS_CSPACE_ICC5 :
++ case CUPS_CSPACE_ICC6 :
++ case CUPS_CSPACE_ICC7 :
++ case CUPS_CSPACE_ICC8 :
++ case CUPS_CSPACE_ICC9 :
++ case CUPS_CSPACE_ICCA :
++ case CUPS_CSPACE_ICCB :
++ case CUPS_CSPACE_ICCC :
++ case CUPS_CSPACE_ICCD :
++ case CUPS_CSPACE_ICCE :
++ case CUPS_CSPACE_ICCF :
++# endif /* CUPS_RASTER_HAVE_COLORIMETRIC */
++ if (compare_color_names(pname, name_size, "Black"))
++ return 3;
++ case CUPS_CSPACE_CMY :
++ if (compare_color_names(pname, name_size, "Cyan"))
++ return 0;
++ if (compare_color_names(pname, name_size, "Magenta"))
++ return 1;
++ if (compare_color_names(pname, name_size, "Yellow"))
++ return 2;
++ else
++ return -1;
++ break;
++ case CUPS_CSPACE_GMCS :
++ if (compare_color_names(pname, name_size, "Silver") ||
++ compare_color_names(pname, name_size, "Silver Foil"))
++ return 3;
++ case CUPS_CSPACE_GMCK :
++ if (compare_color_names(pname, name_size, "Gold") ||
++ compare_color_names(pname, name_size, "Gold Foil"))
++ return 0;
++ case CUPS_CSPACE_YMCK :
++ if (compare_color_names(pname, name_size, "Black"))
++ return 3;
++ case CUPS_CSPACE_YMC :
++ if (compare_color_names(pname, name_size, "Yellow"))
++ return 0;
++ if (compare_color_names(pname, name_size, "Magenta"))
++ return 1;
++ if (compare_color_names(pname, name_size, "Cyan"))
++ return 2;
++ else
++ return -1;
++ break;
++ case CUPS_CSPACE_KCMYcm :
++ if (compare_color_names(pname, name_size, "Light Cyan") ||
++ compare_color_names(pname, name_size, "Photo Cyan"))
++ return 4;
++ if (compare_color_names(pname, name_size, "Light Magenta") ||
++ compare_color_names(pname, name_size, "Photo Magenta"))
++ return 5;
++ case CUPS_CSPACE_KCMY :
++ if (compare_color_names(pname, name_size, "Black"))
++ return 0;
++ if (compare_color_names(pname, name_size, "Cyan"))
++ return 1;
++ if (compare_color_names(pname, name_size, "Magenta"))
++ return 2;
++ if (compare_color_names(pname, name_size, "Yellow"))
++ return 3;
++ else
++ return -1;
++ break;
++ case CUPS_CSPACE_GOLD :
++ if (compare_color_names(pname, name_size, "Gold") ||
++ compare_color_names(pname, name_size, "Gold Foil"))
++ return 0;
++ else
++ return -1;
++ break;
++ case CUPS_CSPACE_SILVER :
++ if (compare_color_names(pname, name_size, "Silver") ||
++ compare_color_names(pname, name_size, "Silver Foil"))
++ return 0;
++ else
++ return -1;
++ break;
++ }
++ return -1;
++}
+
+ /*
+ * 'cups_get_color_mapping_procs()' - Get the list of color mapping procedures.
+@@ -658,8 +787,8 @@ cups_get_matrix(gx_device *pdev, /* I -
+ }
+ #endif /* CUPS_RASTER_SYNCv1 */
+
+- dprintf2("DEBUG2: width = %d, height = %d\n", cups->width,
+- cups->height);
++ dprintf2("DEBUG2: width = %d, height = %d\n", cups->header.cupsWidth,
++ cups->header.cupsHeight);
+ dprintf4("DEBUG2: PageSize = [ %d %d ], HWResolution = [ %d %d ]\n",
+ cups->header.PageSize[0], cups->header.PageSize[1],
+ cups->header.HWResolution[0], cups->header.HWResolution[1]);
+@@ -915,7 +1044,8 @@ cups_get_space_params(const gx_device_pr
+ switch (sscanf(cache_env, "%f%254s", &cache_size, cache_units))
+ {
+ case 0 :
+- return;
++ cache_size = 8 * 1024 * 1024;
++ break;
+ case 1 :
+ cache_size *= 4 * CUPS_TILE_SIZE * CUPS_TILE_SIZE;
+ break;
+@@ -932,15 +1062,12 @@ cups_get_space_params(const gx_device_pr
+ }
+ }
+ else
+- return;
+-
+- if (cache_size == 0)
+- return;
++ cache_size = 8 * 1024 * 1024;
+
+ dprintf1("DEBUG2: cache_size = %.0f\n", cache_size);
+
+- space_params->MaxBitmap = (int)cache_size;
+- space_params->BufferSpace = (int)cache_size;
++ space_params->MaxBitmap = (long)cache_size;
++ space_params->BufferSpace = (long)cache_size / 10;
+ }
+
+
+@@ -1003,7 +1130,7 @@ cups_map_cmyk(gx_device *pdev, /* I - D
+ c0 = 0;
+ else if (c0 > frac_1)
+ c0 = frac_1;
+- out[0] = frac_1 - (frac)cupsDensity[c0];
++ out[0] = frac_1 - (frac)cups->Density[c0];
+ break;
+
+ case CUPS_CSPACE_RGBA :
+@@ -1026,26 +1153,26 @@ cups_map_cmyk(gx_device *pdev, /* I - D
+ c0 = 0;
+ else if (c0 > frac_1)
+ c0 = frac_1;
+- out[0] = frac_1 - (frac)cupsDensity[c0];
++ out[0] = frac_1 - (frac)cups->Density[c0];
+
+ if (c1 < 0)
+ c1 = 0;
+ else if (c1 > frac_1)
+ c1 = frac_1;
+- out[1] = frac_1 - (frac)cupsDensity[c1];
++ out[1] = frac_1 - (frac)cups->Density[c1];
+
+ if (c2 < 0)
+ c2 = 0;
+ else if (c2 > frac_1)
+ c2 = frac_1;
+- out[2] = frac_1 - (frac)cupsDensity[c2];
++ out[2] = frac_1 - (frac)cups->Density[c2];
+
+ if (cups->header.cupsColorSpace == CUPS_CSPACE_RGBW) {
+ if (c3 < 0)
+ c3 = 0;
+ else if (c3 > frac_1)
+ c3 = frac_1;
+- out[3] = frac_1 - (frac)cupsDensity[c3];
++ out[3] = frac_1 - (frac)cups->Density[c3];
+ }
+ break;
+
+@@ -1056,9 +1183,9 @@ cups_map_cmyk(gx_device *pdev, /* I - D
+ if (c0 < 0)
+ out[0] = 0;
+ else if (c0 > frac_1)
+- out[0] = (frac)cupsDensity[frac_1];
++ out[0] = (frac)cups->Density[frac_1];
+ else
+- out[0] = (frac)cupsDensity[c0];
++ out[0] = (frac)cups->Density[c0];
+ break;
+
+ case CUPS_CSPACE_CMY :
+@@ -1069,23 +1196,23 @@ cups_map_cmyk(gx_device *pdev, /* I - D
+ if (c0 < 0)
+ out[0] = 0;
+ else if (c0 > frac_1)
+- out[0] = (frac)cupsDensity[frac_1];
++ out[0] = (frac)cups->Density[frac_1];
+ else
+- out[0] = (frac)cupsDensity[c0];
++ out[0] = (frac)cups->Density[c0];
+
+ if (c1 < 0)
+ out[1] = 0;
+ else if (c1 > frac_1)
+- out[1] = (frac)cupsDensity[frac_1];
++ out[1] = (frac)cups->Density[frac_1];
+ else
+- out[1] = (frac)cupsDensity[c1];
++ out[1] = (frac)cups->Density[c1];
+
+ if (c2 < 0)
+ out[2] = 0;
+ else if (c2 > frac_1)
+- out[2] = (frac)cupsDensity[frac_1];
++ out[2] = (frac)cups->Density[frac_1];
+ else
+- out[2] = (frac)cupsDensity[c2];
++ out[2] = (frac)cups->Density[c2];
+ break;
+
+ case CUPS_CSPACE_YMC :
+@@ -1096,53 +1223,53 @@ cups_map_cmyk(gx_device *pdev, /* I - D
+ if (c0 < 0)
+ out[0] = 0;
+ else if (c0 > frac_1)
+- out[0] = (frac)cupsDensity[frac_1];
++ out[0] = (frac)cups->Density[frac_1];
+ else
+- out[0] = (frac)cupsDensity[c0];
++ out[0] = (frac)cups->Density[c0];
+
+ if (c1 < 0)
+ out[1] = 0;
+ else if (c1 > frac_1)
+- out[1] = (frac)cupsDensity[frac_1];
++ out[1] = (frac)cups->Density[frac_1];
+ else
+- out[1] = (frac)cupsDensity[c1];
++ out[1] = (frac)cups->Density[c1];
+
+ if (c2 < 0)
+ out[2] = 0;
+ else if (c2 > frac_1)
+- out[2] = (frac)cupsDensity[frac_1];
++ out[2] = (frac)cups->Density[frac_1];
+ else
+- out[2] = (frac)cupsDensity[c2];
++ out[2] = (frac)cups->Density[c2];
+ break;
+
+ case CUPS_CSPACE_CMYK :
+ if (c < 0)
+ out[0] = 0;
+ else if (c > frac_1)
+- out[0] = (frac)cupsDensity[frac_1];
++ out[0] = (frac)cups->Density[frac_1];
+ else
+- out[0] = (frac)cupsDensity[c];
++ out[0] = (frac)cups->Density[c];
+
+ if (m < 0)
+ out[1] = 0;
+ else if (m > frac_1)
+- out[1] = (frac)cupsDensity[frac_1];
++ out[1] = (frac)cups->Density[frac_1];
+ else
+- out[1] = (frac)cupsDensity[m];
++ out[1] = (frac)cups->Density[m];
+
+ if (y < 0)
+ out[2] = 0;
+ else if (y > frac_1)
+- out[2] = (frac)cupsDensity[frac_1];
++ out[2] = (frac)cups->Density[frac_1];
+ else
+- out[2] = (frac)cupsDensity[y];
++ out[2] = (frac)cups->Density[y];
+
+ if (k < 0)
+ out[3] = 0;
+ else if (k > frac_1)
+- out[3] = (frac)cupsDensity[frac_1];
++ out[3] = (frac)cups->Density[frac_1];
+ else
+- out[3] = (frac)cupsDensity[k];
++ out[3] = (frac)cups->Density[k];
+ break;
+
+ case CUPS_CSPACE_YMCK :
+@@ -1151,30 +1278,30 @@ cups_map_cmyk(gx_device *pdev, /* I - D
+ if (y < 0)
+ out[0] = 0;
+ else if (y > frac_1)
+- out[0] = (frac)cupsDensity[frac_1];
++ out[0] = (frac)cups->Density[frac_1];
+ else
+- out[0] = (frac)cupsDensity[y];
++ out[0] = (frac)cups->Density[y];
+
+ if (m < 0)
+ out[1] = 0;
+ else if (m > frac_1)
+- out[1] = (frac)cupsDensity[frac_1];
++ out[1] = (frac)cups->Density[frac_1];
+ else
+- out[1] = (frac)cupsDensity[m];
++ out[1] = (frac)cups->Density[m];
+
+ if (c < 0)
+ out[2] = 0;
+ else if (c > frac_1)
+- out[2] = (frac)cupsDensity[frac_1];
++ out[2] = (frac)cups->Density[frac_1];
+ else
+- out[2] = (frac)cupsDensity[c];
++ out[2] = (frac)cups->Density[c];
+
+ if (k < 0)
+ out[3] = 0;
+ else if (k > frac_1)
+- out[3] = (frac)cupsDensity[frac_1];
++ out[3] = (frac)cups->Density[frac_1];
+ else
+- out[3] = (frac)cupsDensity[k];
++ out[3] = (frac)cups->Density[k];
+ break;
+
+ case CUPS_CSPACE_KCMYcm :
+@@ -1182,30 +1309,30 @@ cups_map_cmyk(gx_device *pdev, /* I - D
+ if (k < 0)
+ out[0] = 0;
+ else if (k > frac_1)
+- out[0] = (frac)cupsDensity[frac_1];
++ out[0] = (frac)cups->Density[frac_1];
+ else
+- out[0] = (frac)cupsDensity[k];
++ out[0] = (frac)cups->Density[k];
+
+ if (c < 0)
+ out[1] = 0;
+ else if (c > frac_1)
+- out[1] = (frac)cupsDensity[frac_1];
++ out[1] = (frac)cups->Density[frac_1];
+ else
+- out[1] = (frac)cupsDensity[c];
++ out[1] = (frac)cups->Density[c];
+
+ if (m < 0)
+ out[2] = 0;
+ else if (m > frac_1)
+- out[2] = (frac)cupsDensity[frac_1];
++ out[2] = (frac)cups->Density[frac_1];
+ else
+- out[2] = (frac)cupsDensity[m];
++ out[2] = (frac)cups->Density[m];
+
+ if (y < 0)
+ out[3] = 0;
+ else if (y > frac_1)
+- out[3] = (frac)cupsDensity[frac_1];
++ out[3] = (frac)cups->Density[frac_1];
+ else
+- out[3] = (frac)cupsDensity[y];
++ out[3] = (frac)cups->Density[y];
+ break;
+
+ # ifdef CUPS_RASTER_HAVE_COLORIMETRIC
+@@ -1400,9 +1527,9 @@ cups_map_cmyk(gx_device *pdev, /* I - D
+ }
+ }
+
+- out[0] = cupsDecodeLUT[c0];
+- out[1] = cupsDecodeLUT[c1];
+- out[2] = cupsDecodeLUT[c2];
++ out[0] = cups->DecodeLUT[c0];
++ out[1] = cups->DecodeLUT[c1];
++ out[2] = cups->DecodeLUT[c2];
+ break;
+ # endif /* CUPS_RASTER_HAVE_COLORIMETRIC */
+ }
+@@ -1494,21 +1621,21 @@ cups_map_rgb(gx_device *pdev
+ * Do color correction as needed...
+ */
+
+- if (cupsHaveProfile)
++ if (cups->HaveProfile)
+ {
+ /*
+ * Color correct CMY...
+ */
+
+- tc = cupsMatrix[0][0][c] +
+- cupsMatrix[0][1][m] +
+- cupsMatrix[0][2][y];
+- tm = cupsMatrix[1][0][c] +
+- cupsMatrix[1][1][m] +
+- cupsMatrix[1][2][y];
+- ty = cupsMatrix[2][0][c] +
+- cupsMatrix[2][1][m] +
+- cupsMatrix[2][2][y];
++ tc = cups->Matrix[0][0][c] +
++ cups->Matrix[0][1][m] +
++ cups->Matrix[0][2][y];
++ tm = cups->Matrix[1][0][c] +
++ cups->Matrix[1][1][m] +
++ cups->Matrix[1][2][y];
++ ty = cups->Matrix[2][0][c] +
++ cups->Matrix[2][1][m] +
++ cups->Matrix[2][2][y];
+
+ if (tc < 0)
+ c = 0;
+@@ -1577,18 +1704,18 @@ cups_map_cmyk_color(gx_device *pdev
+ * Density correct...
+ */
+
+- if (cupsHaveProfile)
++ if (cups->HaveProfile)
+ {
+- c = cupsDensity[c];
+- m = cupsDensity[m];
+- y = cupsDensity[y];
+- k = cupsDensity[k];
++ c = cups->Density[c];
++ m = cups->Density[m];
++ y = cups->Density[y];
++ k = cups->Density[k];
+ }
+
+- ic = cupsEncodeLUT[c];
+- im = cupsEncodeLUT[m];
+- iy = cupsEncodeLUT[y];
+- ik = cupsEncodeLUT[k];
++ ic = cups->EncodeLUT[c];
++ im = cups->EncodeLUT[m];
++ iy = cups->EncodeLUT[y];
++ ik = cups->EncodeLUT[k];
+
+ /*
+ * Convert the CMYK color to a color index...
+@@ -1804,42 +1931,42 @@ cups_map_color_rgb(gx_device *pdev,
+ case CUPS_CSPACE_SILVER :
+ prgb[0] =
+ prgb[1] =
+- prgb[2] = cupsDecodeLUT[c3];
++ prgb[2] = cups->DecodeLUT[c3];
+ break;
+
+ case CUPS_CSPACE_W :
+ prgb[0] =
+ prgb[1] =
+- prgb[2] = cupsDecodeLUT[c3];
++ prgb[2] = cups->DecodeLUT[c3];
+ break;
+
+ case CUPS_CSPACE_RGB :
+- prgb[0] = cupsDecodeLUT[c1];
+- prgb[1] = cupsDecodeLUT[c2];
+- prgb[2] = cupsDecodeLUT[c3];
++ prgb[0] = cups->DecodeLUT[c1];
++ prgb[1] = cups->DecodeLUT[c2];
++ prgb[2] = cups->DecodeLUT[c3];
+ break;
+
+ case CUPS_CSPACE_RGBA :
+- prgb[0] = cupsDecodeLUT[c0];
+- prgb[1] = cupsDecodeLUT[c1];
+- prgb[2] = cupsDecodeLUT[c2];
++ prgb[0] = cups->DecodeLUT[c0];
++ prgb[1] = cups->DecodeLUT[c1];
++ prgb[2] = cups->DecodeLUT[c2];
+ break;
+
+ case CUPS_CSPACE_CMY :
+- prgb[0] = cupsDecodeLUT[c1];
+- prgb[1] = cupsDecodeLUT[c2];
+- prgb[2] = cupsDecodeLUT[c3];
++ prgb[0] = cups->DecodeLUT[c1];
++ prgb[1] = cups->DecodeLUT[c2];
++ prgb[2] = cups->DecodeLUT[c3];
+ break;
+
+ case CUPS_CSPACE_YMC :
+- prgb[0] = cupsDecodeLUT[c3];
+- prgb[1] = cupsDecodeLUT[c2];
+- prgb[2] = cupsDecodeLUT[c1];
++ prgb[0] = cups->DecodeLUT[c3];
++ prgb[1] = cups->DecodeLUT[c2];
++ prgb[2] = cups->DecodeLUT[c1];
+ break;
+
+ case CUPS_CSPACE_KCMY :
+ case CUPS_CSPACE_KCMYcm :
+- k = cupsDecodeLUT[c0];
++ k = cups->DecodeLUT[c0];
+ divk = gx_max_color_value - k;
+ if (divk == 0)
+ {
+@@ -1860,13 +1987,13 @@ cups_map_color_rgb(gx_device *pdev,
+
+ case CUPS_CSPACE_RGBW :
+ /*
+- * cupsDecodeLUT actually maps to RGBW, not CMYK...
++ * cups->DecodeLUT actually maps to RGBW, not CMYK...
+ */
+
+- k = cupsDecodeLUT[c3];
+- c = cupsDecodeLUT[c0] + k;
+- m = cupsDecodeLUT[c1] + k;
+- y = cupsDecodeLUT[c2] + k;
++ k = cups->DecodeLUT[c3];
++ c = cups->DecodeLUT[c0] + k;
++ m = cups->DecodeLUT[c1] + k;
++ y = cups->DecodeLUT[c2] + k;
+
+ if (c > gx_max_color_value)
+ prgb[0] = gx_max_color_value;
+@@ -1885,7 +2012,7 @@ cups_map_color_rgb(gx_device *pdev,
+ break;
+
+ case CUPS_CSPACE_CMYK :
+- k = cupsDecodeLUT[c3];
++ k = cups->DecodeLUT[c3];
+ divk = gx_max_color_value - k;
+ if (divk == 0)
+ {
+@@ -1907,7 +2034,7 @@ cups_map_color_rgb(gx_device *pdev,
+ case CUPS_CSPACE_YMCK :
+ case CUPS_CSPACE_GMCK :
+ case CUPS_CSPACE_GMCS :
+- k = cupsDecodeLUT[c3];
++ k = cups->DecodeLUT[c3];
+ divk = gx_max_color_value - k;
+ if (divk == 0)
+ {
+@@ -1995,7 +2122,7 @@ cups_map_rgb_color(gx_device *pdev,
+ * Do color correction as needed...
+ */
+
+- if (cupsHaveProfile)
++ if (cups->HaveProfile)
+ {
+ /*
+ * Compute CMYK values...
+@@ -2017,17 +2144,17 @@ cups_map_rgb_color(gx_device *pdev,
+ * Color correct CMY...
+ */
+
+- tc = cupsMatrix[0][0][ic] +
+- cupsMatrix[0][1][im] +
+- cupsMatrix[0][2][iy] +
++ tc = cups->Matrix[0][0][ic] +
++ cups->Matrix[0][1][im] +
++ cups->Matrix[0][2][iy] +
+ ik;
+- tm = cupsMatrix[1][0][ic] +
+- cupsMatrix[1][1][im] +
+- cupsMatrix[1][2][iy] +
++ tm = cups->Matrix[1][0][ic] +
++ cups->Matrix[1][1][im] +
++ cups->Matrix[1][2][iy] +
+ ik;
+- ty = cupsMatrix[2][0][ic] +
+- cupsMatrix[2][1][im] +
+- cupsMatrix[2][2][iy] +
++ ty = cups->Matrix[2][0][ic] +
++ cups->Matrix[2][1][im] +
++ cups->Matrix[2][2][iy] +
+ ik;
+
+ /*
+@@ -2037,23 +2164,23 @@ cups_map_rgb_color(gx_device *pdev,
+ if (tc < 0)
+ r = gx_max_color_value;
+ else if (tc > gx_max_color_value)
+- r = gx_max_color_value - cupsDensity[gx_max_color_value];
++ r = gx_max_color_value - cups->Density[gx_max_color_value];
+ else
+- r = gx_max_color_value - cupsDensity[tc];
++ r = gx_max_color_value - cups->Density[tc];
+
+ if (tm < 0)
+ g = gx_max_color_value;
+ else if (tm > gx_max_color_value)
+- g = gx_max_color_value - cupsDensity[gx_max_color_value];
++ g = gx_max_color_value - cups->Density[gx_max_color_value];
+ else
+- g = gx_max_color_value - cupsDensity[tm];
++ g = gx_max_color_value - cups->Density[tm];
+
+ if (ty < 0)
+ b = gx_max_color_value;
+ else if (ty > gx_max_color_value)
+- b = gx_max_color_value - cupsDensity[gx_max_color_value];
++ b = gx_max_color_value - cups->Density[gx_max_color_value];
+ else
+- b = gx_max_color_value - cupsDensity[ty];
++ b = gx_max_color_value - cups->Density[ty];
+ }
+
+ /*
+@@ -2063,13 +2190,13 @@ cups_map_rgb_color(gx_device *pdev,
+ switch (cups->header.cupsColorSpace)
+ {
+ case CUPS_CSPACE_W :
+- i = cupsEncodeLUT[(r * 31 + g * 61 + b * 8) / 100];
++ i = cups->EncodeLUT[(r * 31 + g * 61 + b * 8) / 100];
+ break;
+
+ case CUPS_CSPACE_RGB :
+- ic = cupsEncodeLUT[r];
+- im = cupsEncodeLUT[g];
+- iy = cupsEncodeLUT[b];
++ ic = cups->EncodeLUT[r];
++ im = cups->EncodeLUT[g];
++ iy = cups->EncodeLUT[b];
+
+ switch (cups->header.cupsBitsPerColor)
+ {
+@@ -2124,9 +2251,9 @@ cups_map_rgb_color(gx_device *pdev,
+ }
+
+ case CUPS_CSPACE_RGBA :
+- ic = cupsEncodeLUT[r];
+- im = cupsEncodeLUT[g];
+- iy = cupsEncodeLUT[b];
++ ic = cups->EncodeLUT[r];
++ im = cups->EncodeLUT[g];
++ iy = cups->EncodeLUT[b];
+
+ switch (cups->header.cupsBitsPerColor)
+ {
+@@ -2151,13 +2278,13 @@ cups_map_rgb_color(gx_device *pdev,
+ break;
+
+ default :
+- i = cupsEncodeLUT[gx_max_color_value - (r * 31 + g * 61 + b * 8) / 100];
++ i = cups->EncodeLUT[gx_max_color_value - (r * 31 + g * 61 + b * 8) / 100];
+ break;
+
+ case CUPS_CSPACE_CMY :
+- ic = cupsEncodeLUT[gx_max_color_value - r];
+- im = cupsEncodeLUT[gx_max_color_value - g];
+- iy = cupsEncodeLUT[gx_max_color_value - b];
++ ic = cups->EncodeLUT[gx_max_color_value - r];
++ im = cups->EncodeLUT[gx_max_color_value - g];
++ iy = cups->EncodeLUT[gx_max_color_value - b];
+
+ switch (cups->header.cupsBitsPerColor)
+ {
+@@ -2182,9 +2309,9 @@ cups_map_rgb_color(gx_device *pdev,
+ break;
+
+ case CUPS_CSPACE_YMC :
+- ic = cupsEncodeLUT[gx_max_color_value - r];
+- im = cupsEncodeLUT[gx_max_color_value - g];
+- iy = cupsEncodeLUT[gx_max_color_value - b];
++ ic = cups->EncodeLUT[gx_max_color_value - r];
++ im = cups->EncodeLUT[gx_max_color_value - g];
++ iy = cups->EncodeLUT[gx_max_color_value - b];
+
+ switch (cups->header.cupsBitsPerColor)
+ {
+@@ -2213,10 +2340,10 @@ cups_map_rgb_color(gx_device *pdev,
+ ik = (int)((float)ik * (float)ik * (float)ik /
+ ((float)mk * (float)mk));
+
+- ic = cupsEncodeLUT[ic - ik];
+- im = cupsEncodeLUT[im - ik];
+- iy = cupsEncodeLUT[iy - ik];
+- ik = cupsEncodeLUT[ik];
++ ic = cups->EncodeLUT[ic - ik];
++ im = cups->EncodeLUT[im - ik];
++ iy = cups->EncodeLUT[iy - ik];
++ ik = cups->EncodeLUT[ik];
+
+ switch (cups->header.cupsBitsPerColor)
+ {
+@@ -2257,10 +2384,10 @@ cups_map_rgb_color(gx_device *pdev,
+ ik = (int)((float)ik * (float)ik * (float)ik /
+ ((float)mk * (float)mk));
+
+- ic = cupsEncodeLUT[ic - ik];
+- im = cupsEncodeLUT[im - ik];
+- iy = cupsEncodeLUT[iy - ik];
+- ik = cupsEncodeLUT[ik];
++ ic = cups->EncodeLUT[ic - ik];
++ im = cups->EncodeLUT[im - ik];
++ iy = cups->EncodeLUT[iy - ik];
++ ik = cups->EncodeLUT[ik];
+
+ switch (cups->header.cupsBitsPerColor)
+ {
+@@ -2296,10 +2423,10 @@ cups_map_rgb_color(gx_device *pdev,
+ ik = (int)((float)ik * (float)ik * (float)ik /
+ ((float)mk * (float)mk));
+
+- ic = cupsEncodeLUT[ic - ik];
+- im = cupsEncodeLUT[im - ik];
+- iy = cupsEncodeLUT[iy - ik];
+- ik = cupsEncodeLUT[ik];
++ ic = cups->EncodeLUT[ic - ik];
++ im = cups->EncodeLUT[im - ik];
++ iy = cups->EncodeLUT[iy - ik];
++ ik = cups->EncodeLUT[ik];
+ if (ik)
+ i = 32;
+ else if (ic && im)
+@@ -2329,10 +2456,10 @@ cups_map_rgb_color(gx_device *pdev,
+ ik = (int)((float)ik * (float)ik * (float)ik /
+ ((float)mk * (float)mk));
+
+- ic = cupsEncodeLUT[ic - ik];
+- im = cupsEncodeLUT[im - ik];
+- iy = cupsEncodeLUT[iy - ik];
+- ik = cupsEncodeLUT[ik];
++ ic = cups->EncodeLUT[ic - ik];
++ im = cups->EncodeLUT[im - ik];
++ iy = cups->EncodeLUT[iy - ik];
++ ik = cups->EncodeLUT[ik];
+
+ switch (cups->header.cupsBitsPerColor)
+ {
+@@ -2532,8 +2659,8 @@ cups_open(gx_device *pdev) /* I - Devic
+ if ((code = gdev_prn_open(pdev)) != 0)
+ return (code);
+
+- if (cupsPPD == NULL)
+- cupsPPD = ppdOpenFile(getenv("PPD"));
++ if (cups->PPD == NULL)
++ cups->PPD = ppdOpenFile(getenv("PPD"));
+
+ return (0);
+ }
+@@ -2550,6 +2677,7 @@ cups_print_pages(gx_device_printer *pdev
+ int num_copies)
+ /* I - Number of copies */
+ {
++ int code = 0; /* Error code */
+ int copy; /* Copy number */
+ int srcbytes; /* Byte width of scanline */
+ unsigned char *src, /* Scanline data */
+@@ -2604,6 +2732,8 @@ cups_print_pages(gx_device_printer *pdev
+ if (src == NULL) /* can't allocate input buffer */
+ return_error(gs_error_VMerror);
+
++ memset(src, 0, srcbytes);
++
+ /*
+ * Need an output buffer, too...
+ */
+@@ -2614,6 +2744,8 @@ cups_print_pages(gx_device_printer *pdev
+ if (dst == NULL) /* can't allocate working area */
+ return_error(gs_error_VMerror);
+
++ memset(dst, 0, 2 * cups->header.cupsBytesPerLine);
++
+ /*
+ * See if the stream has been initialized yet...
+ */
+@@ -2624,7 +2756,7 @@ cups_print_pages(gx_device_printer *pdev
+ CUPS_RASTER_WRITE)) == NULL)
+ {
+ perror("ERROR: Unable to open raster stream - ");
+- gs_exit(gs_lib_ctx_get_non_gc_memory_t(), 0);
++ return_error(gs_error_ioerror);
+ }
+ }
+
+@@ -2635,7 +2767,7 @@ cups_print_pages(gx_device_printer *pdev
+ if (num_copies < 1)
+ num_copies = 1;
+
+- if (cupsPPD != NULL && !cupsPPD->manual_copies)
++ if (cups->PPD != NULL && !cups->PPD->manual_copies)
+ {
+ cups->header.NumCopies = num_copies;
+ num_copies = 1;
+@@ -2650,20 +2782,22 @@ cups_print_pages(gx_device_printer *pdev
+ cupsRasterWriteHeader(cups->stream, &(cups->header));
+
+ if (pdev->color_info.num_components == 1)
+- cups_print_chunked(pdev, src, dst, srcbytes);
++ code = cups_print_chunked(pdev, src, dst, srcbytes);
+ else
+ switch (cups->header.cupsColorOrder)
+ {
+ case CUPS_ORDER_CHUNKED :
+- cups_print_chunked(pdev, src, dst, srcbytes);
++ code = cups_print_chunked(pdev, src, dst, srcbytes);
+ break;
+ case CUPS_ORDER_BANDED :
+- cups_print_banded(pdev, src, dst, srcbytes);
++ code = cups_print_banded(pdev, src, dst, srcbytes);
+ break;
+ case CUPS_ORDER_PLANAR :
+- cups_print_planar(pdev, src, dst, srcbytes);
++ code = cups_print_planar(pdev, src, dst, srcbytes);
+ break;
+ }
++ if (code < 0)
++ break;
+ }
+
+ /*
+@@ -2673,6 +2807,9 @@ cups_print_pages(gx_device_printer *pdev
+ gs_free(gs_lib_ctx_get_non_gc_memory_t(), (char *)src, srcbytes, 1, "cups_print_pages");
+ gs_free(gs_lib_ctx_get_non_gc_memory_t(), (char *)dst, cups->header.cupsBytesPerLine, 1, "cups_print_pages");
+
++ if (code < 0)
++ return (code);
++
+ cups->page ++;
+ dprintf1("INFO: Processing page %d...\n", cups->page);
+
+@@ -2707,19 +2844,14 @@ cups_put_params(gx_device *pdev, /*
+ gdev_prn_space_params sp; /* Space parameter data */
+ int width, /* New width of page */
+ height, /* New height of page */
+- colorspace, /* New color space */
+- bitspercolor; /* New bits per color */
+- static int width_old = 0, /* Previous width */
+- height_old = 0, /* Previous height */
+- colorspace_old = 0,/* Previous color space */
+- bitspercolor_old = 0;/* Previous bits per color */
++ width_old = 0, /* Previous width of page */
++ height_old = 0; /* Previous height of page */
+ ppd_attr_t *backside = NULL,
+ *backsiderequiresflippedmargins = NULL;
+ float swap;
+ int xflip = 0,
+ yflip = 0;
+ int found = 0;
+- static int lastpage = 0;
+
+ dprintf2("DEBUG2: cups_put_params(%p, %p)\n", pdev, plist);
+
+@@ -2731,17 +2863,17 @@ cups_put_params(gx_device *pdev, /*
+ if ((code = param_read_string(plist, sname, &stringval)) < 0) \
+ { \
+ dprintf2("ERROR: Error setting %s to \"%s\"...\n", sname, \
+- (char *)stringval.data); \
++ (char *)(stringval.data)); \
+ param_signal_error(plist, sname, code); \
+ return (code); \
+ } \
+ else if (code == 0) \
+ { \
+- strncpy(cups->header.name, (const char *)stringval.data, \
++ dprintf2("DEBUG: Setting %s to \"%s\"...\n", sname, \
++ (char *)(stringval.data)); \
++ strncpy(cups->header.name, (const char *)(stringval.data), \
+ stringval.size); \
+ cups->header.name[stringval.size] = '\0'; \
+- dprintf2("DEBUG: Setting %s to \"%s\"...\n", sname, \
+- cups->header.name); \
+ }
+
+ #define intoption(name, sname, type) \
+@@ -2821,11 +2953,11 @@ cups_put_params(gx_device *pdev, /*
+ param_read_int(plist, "cupsBitsPerColor", &intval) == 0;
+ /* We also recompute page size and margins if we simply get onto a new
+ page without necessarily having a page size change in the PostScript
+- code, as for some printers margins have to flipped on the back sides of
++ code, as for some printers margins have to be flipped on the back sides of
+ the sheets (even pages) when printing duplex */
+- if (cups->page != lastpage) {
++ if (cups->page != cups->lastpage) {
+ size_set = 1;
+- lastpage = cups->page;
++ cups->lastpage = cups->page;
+ }
+
+ stringoption(MediaClass, "MediaClass")
+@@ -2899,17 +3031,17 @@ cups_put_params(gx_device *pdev, /*
+ stringoption(cupsPageSizeName, "cupsPageSizeName");
+ #endif /* CUPS_RASTER_SYNCv1 */
+
+- if ((code = param_read_string(plist, "cupsProfile", &stringval)) < 0)
++ if ((code = param_read_string(plist, "cups->Profile", &stringval)) < 0)
+ {
+- param_signal_error(plist, "cupsProfile", code);
++ param_signal_error(plist, "cups->Profile", code);
+ return (code);
+ }
+ else if (code == 0)
+ {
+- if (cupsProfile != NULL)
+- free(cupsProfile);
++ if (cups->Profile != NULL)
++ free(cups->Profile);
+
+- cupsProfile = strdup((char *)stringval.data);
++ cups->Profile = strdup((char *)stringval.data);
+ }
+
+ cups_set_color_info(pdev);
+@@ -2938,22 +3070,22 @@ cups_put_params(gx_device *pdev, /*
+
+ cups->landscape = 0;
+
+- if (cupsPPD != NULL)
++ if (cups->PPD != NULL)
+ {
+ dprintf1("DEBUG2: cups->header.Duplex = %d\n", cups->header.Duplex);
+ dprintf1("DEBUG2: cups->header.Tumble = %d\n", cups->header.Tumble);
+ dprintf1("DEBUG2: cups->page = %d\n", cups->page);
+- dprintf1("DEBUG2: cupsPPD = %p\n", cupsPPD);
++ dprintf1("DEBUG2: cups->PPD = %p\n", cups->PPD);
+
+- backside = ppdFindAttr(cupsPPD, "cupsBackSide", NULL);
++ backside = ppdFindAttr(cups->PPD, "cupsBackSide", NULL);
+ if (backside) {
+ dprintf1("DEBUG2: cupsBackSide = %s\n", backside->value);
+- cupsPPD->flip_duplex = 0;
++ cups->PPD->flip_duplex = 0;
+ }
+- dprintf1("DEBUG2: cupsPPD->flip_duplex = %d\n", cupsPPD->flip_duplex);
++ dprintf1("DEBUG2: cups->PPD->flip_duplex = %d\n", cups->PPD->flip_duplex);
+
+ backsiderequiresflippedmargins =
+- ppdFindAttr(cupsPPD, "APDuplexRequiresFlippedMargin", NULL);
++ ppdFindAttr(cups->PPD, "APDuplexRequiresFlippedMargin", NULL);
+ if (backsiderequiresflippedmargins)
+ dprintf1("DEBUG2: APDuplexRequiresFlippedMargin = %s\n",
+ backsiderequiresflippedmargins->value);
+@@ -2990,7 +3122,7 @@ cups_put_params(gx_device *pdev, /*
+ }
+ else if (cups->header.Duplex &&
+ ((!cups->header.Tumble &&
+- (cupsPPD->flip_duplex ||
++ (cups->PPD->flip_duplex ||
+ (backside && !strcasecmp(backside->value, "Rotated")))) ||
+ (cups->header.Tumble &&
+ (backside && !strcasecmp(backside->value, "ManualTumble")))) &&
+@@ -3020,7 +3152,7 @@ cups_put_params(gx_device *pdev, /*
+
+ if (strlen(cups->header.cupsPageSizeName) != 0) {
+ found = 0;
+- for (i = cupsPPD->num_sizes, size = cupsPPD->sizes;
++ for (i = cups->PPD->num_sizes, size = cups->PPD->sizes;
+ i > 0;
+ i --, size ++)
+ if (strcasecmp(cups->header.cupsPageSizeName, size->name) == 0) {
+@@ -3036,7 +3168,7 @@ cups_put_params(gx_device *pdev, /*
+ * Find the matching page size...
+ */
+
+- for (i = cupsPPD->num_sizes, size = cupsPPD->sizes;
++ for (i = cups->PPD->num_sizes, size = cups->PPD->sizes;
+ i > 0;
+ i --, size ++)
+ if (fabs(cups->MediaSize[1] - size->length) < 5.0 &&
+@@ -3071,6 +3203,8 @@ cups_put_params(gx_device *pdev, /*
+
+ gx_device_set_media_size(pdev, size->width, size->length);
+
++ cups->landscape = 0;
++
+ margins[0] = size->left / 72.0;
+ margins[1] = size->bottom / 72.0;
+ margins[2] = (size->width - size->right) / 72.0;
+@@ -3091,7 +3225,7 @@ cups_put_params(gx_device *pdev, /*
+ * landscape orientation...
+ */
+
+- for (i = cupsPPD->num_sizes, size = cupsPPD->sizes;
++ for (i = cups->PPD->num_sizes, size = cups->PPD->sizes;
+ i > 0;
+ i --, size ++)
+ if (fabs(cups->MediaSize[0] - size->length) < 5.0 &&
+@@ -3149,8 +3283,10 @@ cups_put_params(gx_device *pdev, /*
+
+ dprintf("DEBUG: size = Custom\n");
+
++ cups->landscape = 0;
++
+ for (i = 0; i < 4; i ++)
+- margins[i] = cupsPPD->custom_margins[i] / 72.0;
++ margins[i] = cups->PPD->custom_margins[i] / 72.0;
+ if (xflip == 1)
+ {
+ swap = margins[0]; margins[0] = margins[2]; margins[2] = swap;
+@@ -3174,50 +3310,6 @@ cups_put_params(gx_device *pdev, /*
+ }
+
+ /*
+- * Set CUPS raster header values...
+- */
+-
+- cups->header.HWResolution[0] = pdev->HWResolution[0];
+- cups->header.HWResolution[1] = pdev->HWResolution[1];
+-
+-#ifdef CUPS_RASTER_SYNCv1
+- cups->header.cupsPageSize[0] = pdev->MediaSize[0];
+- cups->header.cupsPageSize[1] = pdev->MediaSize[1];
+-
+- cups->header.cupsImagingBBox[0] = pdev->HWMargins[0];
+- cups->header.cupsImagingBBox[1] = pdev->HWMargins[1];
+- cups->header.cupsImagingBBox[2] = pdev->MediaSize[0] - pdev->HWMargins[2];
+- cups->header.cupsImagingBBox[3] = pdev->MediaSize[1] - pdev->HWMargins[3];
+-
+- if ((sf = cups->header.cupsBorderlessScalingFactor) < 1.0)
+- sf = 1.0;
+-
+- cups->header.Margins[0] = pdev->HWMargins[0] * sf;
+- cups->header.Margins[1] = pdev->HWMargins[1] * sf;
+-
+- cups->header.PageSize[0] = pdev->MediaSize[0] * sf;
+- cups->header.PageSize[1] = pdev->MediaSize[1] * sf;
+-
+- cups->header.ImagingBoundingBox[0] = pdev->HWMargins[0] * sf;
+- cups->header.ImagingBoundingBox[1] = pdev->HWMargins[1] * sf;
+- cups->header.ImagingBoundingBox[2] = (pdev->MediaSize[0] -
+- pdev->HWMargins[2]) * sf;
+- cups->header.ImagingBoundingBox[3] = (pdev->MediaSize[1] -
+- pdev->HWMargins[3]) * sf;
+-#else
+- cups->header.Margins[0] = pdev->HWMargins[0];
+- cups->header.Margins[1] = pdev->HWMargins[1];
+-
+- cups->header.PageSize[0] = pdev->MediaSize[0];
+- cups->header.PageSize[1] = pdev->MediaSize[1];
+-
+- cups->header.ImagingBoundingBox[0] = pdev->HWMargins[0];
+- cups->header.ImagingBoundingBox[1] = pdev->HWMargins[3];
+- cups->header.ImagingBoundingBox[2] = pdev->MediaSize[0] - pdev->HWMargins[2];
+- cups->header.ImagingBoundingBox[3] = pdev->MediaSize[1] - pdev->HWMargins[1];
+-#endif /* CUPS_RASTER_SYNCv1 */
+-
+- /*
+ * Reallocate memory if the size or color depth was changed...
+ */
+
+@@ -3228,6 +3320,8 @@ cups_put_params(gx_device *pdev, /*
+ * does not keep track of the margins in the bitmap size...
+ */
+
++ width_old = pdev->width;
++ height_old = pdev->height;
+ if (cups->landscape)
+ {
+ width = (pdev->MediaSize[1] - pdev->HWMargins[1] - pdev->HWMargins[3]) *
+@@ -3250,37 +3344,33 @@ cups_put_params(gx_device *pdev, /*
+ height *= cups->header.cupsBorderlessScalingFactor;
+ }
+ #endif /* CUPS_RASTER_SYNCv1 */
+-
+- colorspace = cups->header.cupsColorSpace;
+- bitspercolor = cups->header.cupsBitsPerColor;
++ pdev->width = width;
++ pdev->height = height;
+
+ /*
+ * Don't reallocate memory unless the device has been opened...
+ * Also reallocate only if the size has actually changed...
+ */
+
+- if (pdev->is_open &&
+- (width != width_old || height != height_old ||
+- colorspace != colorspace_old || bitspercolor != bitspercolor_old))
++ if (pdev->is_open)
+ {
+
+- width_old = width;
+- height_old = height;
+- colorspace_old = colorspace;
+- bitspercolor_old = bitspercolor;
+-
+ /*
+ * Device is open and size has changed, so reallocate...
+ */
+
+- dprintf6("DEBUG2: Reallocating memory, [%.0f %.0f] = %dx%d pixels, color space: %d, bits per color: %d...\n",
+- pdev->MediaSize[0], pdev->MediaSize[1], width, height,
+- colorspace, bitspercolor);
++ dprintf4("DEBUG2: Reallocating memory, [%.0f %.0f] = %dx%d pixels...\n",
++ pdev->MediaSize[0], pdev->MediaSize[1], width, height);
+
+ sp = ((gx_device_printer *)pdev)->space_params;
+
+- if ((code = gdev_prn_reallocate_memory(pdev, &sp, width, height)) < 0)
++ if ((code = gdev_prn_maybe_realloc_memory((gx_device_printer *)pdev, &sp,
++ width_old, height_old,
++ cups->page_uses_transparency))
++ < 0)
+ return (code);
++ dprintf4("DEBUG2: Reallocated memory, [%.0f %.0f] = %dx%d pixels...\n",
++ pdev->MediaSize[0], pdev->MediaSize[1], width, height);
+ }
+ else
+ {
+@@ -3296,12 +3386,110 @@ cups_put_params(gx_device *pdev, /*
+ }
+ }
+
+- dprintf1("DEBUG2: ppd = %p\n", cupsPPD);
++ /*
++ * Set CUPS raster header values...
++ */
++
++ cups->header.HWResolution[0] = pdev->HWResolution[0];
++ cups->header.HWResolution[1] = pdev->HWResolution[1];
++
++#ifdef CUPS_RASTER_SYNCv1
++
++ if (cups->landscape)
++ {
++ cups->header.cupsPageSize[0] = pdev->MediaSize[1];
++ cups->header.cupsPageSize[1] = pdev->MediaSize[0];
++
++ cups->header.cupsImagingBBox[0] = pdev->HWMargins[1];
++ cups->header.cupsImagingBBox[1] = pdev->HWMargins[2];
++ cups->header.cupsImagingBBox[2] = pdev->MediaSize[1] - pdev->HWMargins[3];
++ cups->header.cupsImagingBBox[3] = pdev->MediaSize[0] - pdev->HWMargins[0];
++
++ if ((sf = cups->header.cupsBorderlessScalingFactor) < 1.0)
++ sf = 1.0;
++
++ cups->header.Margins[0] = pdev->HWMargins[1] * sf;
++ cups->header.Margins[1] = pdev->HWMargins[2] * sf;
++
++ cups->header.PageSize[0] = pdev->MediaSize[1] * sf;
++ cups->header.PageSize[1] = pdev->MediaSize[0] * sf;
++
++ cups->header.ImagingBoundingBox[0] = pdev->HWMargins[1] * sf;
++ cups->header.ImagingBoundingBox[1] = pdev->HWMargins[2] * sf;
++ cups->header.ImagingBoundingBox[2] = (pdev->MediaSize[1] -
++ pdev->HWMargins[3]) * sf;
++ cups->header.ImagingBoundingBox[3] = (pdev->MediaSize[0] -
++ pdev->HWMargins[0]) * sf;
++ }
++ else
++ {
++ cups->header.cupsPageSize[0] = pdev->MediaSize[0];
++ cups->header.cupsPageSize[1] = pdev->MediaSize[1];
++
++ cups->header.cupsImagingBBox[0] = pdev->HWMargins[0];
++ cups->header.cupsImagingBBox[1] = pdev->HWMargins[1];
++ cups->header.cupsImagingBBox[2] = pdev->MediaSize[0] - pdev->HWMargins[2];
++ cups->header.cupsImagingBBox[3] = pdev->MediaSize[1] - pdev->HWMargins[3];
++
++ if ((sf = cups->header.cupsBorderlessScalingFactor) < 1.0)
++ sf = 1.0;
++
++ cups->header.Margins[0] = pdev->HWMargins[0] * sf;
++ cups->header.Margins[1] = pdev->HWMargins[1] * sf;
++
++ cups->header.PageSize[0] = pdev->MediaSize[0] * sf;
++ cups->header.PageSize[1] = pdev->MediaSize[1] * sf;
++
++ cups->header.ImagingBoundingBox[0] = pdev->HWMargins[0] * sf;
++ cups->header.ImagingBoundingBox[1] = pdev->HWMargins[1] * sf;
++ cups->header.ImagingBoundingBox[2] = (pdev->MediaSize[0] -
++ pdev->HWMargins[2]) * sf;
++ cups->header.ImagingBoundingBox[3] = (pdev->MediaSize[1] -
++ pdev->HWMargins[3]) * sf;
++ }
++
++#else
++
++ if (cups->landscape)
++ {
++ cups->header.Margins[0] = pdev->HWMargins[1];
++ cups->header.Margins[1] = pdev->HWMargins[2];
++
++ cups->header.PageSize[0] = pdev->MediaSize[1];
++ cups->header.PageSize[1] = pdev->MediaSize[0];
++
++ cups->header.ImagingBoundingBox[0] = pdev->HWMargins[1];
++ cups->header.ImagingBoundingBox[1] = pdev->HWMargins[0];
++ cups->header.ImagingBoundingBox[2] = pdev->MediaSize[1] -
++ pdev->HWMargins[3];
++ cups->header.ImagingBoundingBox[3] = pdev->MediaSize[0] -
++ pdev->HWMargins[2];
++ }
++ else
++ {
++ cups->header.Margins[0] = pdev->HWMargins[0];
++ cups->header.Margins[1] = pdev->HWMargins[1];
++
++ cups->header.PageSize[0] = pdev->MediaSize[0];
++ cups->header.PageSize[1] = pdev->MediaSize[1];
++
++ cups->header.ImagingBoundingBox[0] = pdev->HWMargins[0];
++ cups->header.ImagingBoundingBox[1] = pdev->HWMargins[3];
++ cups->header.ImagingBoundingBox[2] = pdev->MediaSize[0] -
++ pdev->HWMargins[2];
++ cups->header.ImagingBoundingBox[3] = pdev->MediaSize[1] -
++ pdev->HWMargins[1];
++ }
++
++#endif /* CUPS_RASTER_SYNCv1 */
++ cups->header.cupsWidth = cups->width;
++ cups->header.cupsHeight = cups->height;
++
++ dprintf1("DEBUG2: ppd = %p\n", cups->PPD);
+ dprintf2("DEBUG2: PageSize = [ %.3f %.3f ]\n",
+ pdev->MediaSize[0], pdev->MediaSize[1]);
+- if (size_set)
+- dprintf4("DEBUG2: margins = [ %.3f %.3f %.3f %.3f ]\n",
+- margins[0], margins[1], margins[2], margins[3]);
++ dprintf4("DEBUG2: margins = [ %.3f %.3f %.3f %.3f ]\n",
++ margins[0], margins[1], margins[2], margins[3]);
+ dprintf2("DEBUG2: HWResolution = [ %.3f %.3f ]\n",
+ pdev->HWResolution[0], pdev->HWResolution[1]);
+ dprintf2("DEBUG2: width = %d, height = %d\n",
+@@ -3579,20 +3767,20 @@ cups_set_color_info(gx_device *pdev) /*
+ j = ((j & 255) << 8) | ((j >> 8) & 255);
+ #endif /* !ARCH_IS_BIG_ENDIAN */
+
+- cupsEncodeLUT[i] = j;
++ cups->EncodeLUT[i] = j;
+
+ #ifdef DEBUG
+- if (i == 0 || cupsEncodeLUT[i] != cupsEncodeLUT[i - 1])
+- dprintf2("DEBUG2: cupsEncodeLUT[%d] = %d\n", i, (int)cupsEncodeLUT[i]);
++ if (i == 0 || cups->EncodeLUT[i] != cups->EncodeLUT[i - 1])
++ dprintf2("DEBUG2: cups->EncodeLUT[%d] = %d\n", i, (int)cups->EncodeLUT[i]);
+ #endif /* DEBUG */
+ }
+
+- dprintf1("DEBUG2: cupsEncodeLUT[0] = %d\n", (int)cupsEncodeLUT[0]);
+- dprintf2("DEBUG2: cupsEncodeLUT[%d] = %d\n", gx_max_color_value,
+- (int)cupsEncodeLUT[gx_max_color_value]);
++ dprintf1("DEBUG2: cups->EncodeLUT[0] = %d\n", (int)cups->EncodeLUT[0]);
++ dprintf2("DEBUG2: cups->EncodeLUT[%d] = %d\n", gx_max_color_value,
++ (int)cups->EncodeLUT[gx_max_color_value]);
+
+ for (i = 0; i < cups->color_info.dither_grays; i ++)
+- cupsDecodeLUT[i] = gx_max_color_value * i / max_lut;
++ cups->DecodeLUT[i] = gx_max_color_value * i / max_lut;
+
+ dprintf2("DEBUG: num_components = %d, depth = %d\n",
+ cups->color_info.num_components, cups->color_info.depth);
+@@ -3609,24 +3797,24 @@ cups_set_color_info(gx_device *pdev) /*
+ * Set the color profile as needed...
+ */
+
+- cupsHaveProfile = 0;
++ cups->HaveProfile = 0;
+
+ #ifdef dev_t_proc_encode_color
+- if (cupsProfile)
++ if (cups->Profile)
+ #else
+- if (cupsProfile && cups->header.cupsBitsPerColor == 8)
++ if (cups->Profile && cups->header.cupsBitsPerColor == 8)
+ #endif /* dev_t_proc_encode_color */
+ {
+- dprintf1("DEBUG: Using user-defined profile \"%s\"...\n", cupsProfile);
++ dprintf1("DEBUG: Using user-defined profile \"%s\"...\n", cups->Profile);
+
+- if (sscanf(cupsProfile, "%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f", &d, &g,
++ if (sscanf(cups->Profile, "%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f", &d, &g,
+ m[0] + 0, m[0] + 1, m[0] + 2,
+ m[1] + 0, m[1] + 1, m[1] + 2,
+ m[2] + 0, m[2] + 1, m[2] + 2) != 11)
+ dprintf("ERROR: User-defined profile does not contain 11 integers!\n");
+ else
+ {
+- cupsHaveProfile = 1;
++ cups->HaveProfile = 1;
+
+ d *= 0.001f;
+ g *= 0.001f;
+@@ -3642,9 +3830,9 @@ cups_set_color_info(gx_device *pdev) /*
+ }
+ }
+ #ifdef dev_t_proc_encode_color
+- else if (cupsPPD)
++ else if (cups->PPD)
+ #else
+- else if (cupsPPD && cups->header.cupsBitsPerColor == 8)
++ else if (cups->PPD && cups->header.cupsBitsPerColor == 8)
+ #endif /* dev_t_proc_encode_color */
+ {
+ /*
+@@ -3657,8 +3845,8 @@ cups_set_color_info(gx_device *pdev) /*
+ else
+ sprintf(resolution, "%.0fdpi", pdev->HWResolution[0]);
+
+- for (i = 0, profile = cupsPPD->profiles;
+- i < cupsPPD->num_profiles;
++ for (i = 0, profile = cups->PPD->profiles;
++ i < cups->PPD->num_profiles;
+ i ++, profile ++)
+ if ((strcmp(profile->resolution, resolution) == 0 ||
+ profile->resolution[0] == '-') &&
+@@ -3670,11 +3858,11 @@ cups_set_color_info(gx_device *pdev) /*
+ * If we found a color profile, use it!
+ */
+
+- if (i < cupsPPD->num_profiles)
++ if (i < cups->PPD->num_profiles)
+ {
+ dprintf("DEBUG: Using color profile in PPD file!\n");
+
+- cupsHaveProfile = 1;
++ cups->HaveProfile = 1;
+
+ d = profile->density;
+ g = profile->gamma;
+@@ -3683,34 +3871,34 @@ cups_set_color_info(gx_device *pdev) /*
+ }
+ }
+
+- if (cupsHaveProfile)
++ if (cups->HaveProfile)
+ {
+ for (i = 0; i < 3; i ++)
+ for (j = 0; j < 3; j ++)
+ for (k = 0; k <= CUPS_MAX_VALUE; k ++)
+ {
+- cupsMatrix[i][j][k] = (int)((float)k * m[i][j] + 0.5);
++ cups->Matrix[i][j][k] = (int)((float)k * m[i][j] + 0.5);
+
+ if ((k & 4095) == 0)
+- dprintf4("DEBUG2: cupsMatrix[%d][%d][%d] = %d\n",
+- i, j, k, cupsMatrix[i][j][k]);
++ dprintf4("DEBUG2: cups->Matrix[%d][%d][%d] = %d\n",
++ i, j, k, cups->Matrix[i][j][k]);
+ }
+
+
+ for (k = 0; k <= CUPS_MAX_VALUE; k ++)
+ {
+- cupsDensity[k] = (int)((float)CUPS_MAX_VALUE * d *
++ cups->Density[k] = (int)((float)CUPS_MAX_VALUE * d *
+ pow((float)k / (float)CUPS_MAX_VALUE, g) +
+ 0.5);
+
+ if ((k & 4095) == 0)
+- dprintf2("DEBUG2: cupsDensity[%d] = %d\n", k, cupsDensity[k]);
++ dprintf2("DEBUG2: cups->Density[%d] = %d\n", k, cups->Density[k]);
+ }
+ }
+ else
+ {
+ for (k = 0; k <= CUPS_MAX_VALUE; k ++)
+- cupsDensity[k] = k;
++ cups->Density[k] = k;
+ }
+ }
+
+@@ -3732,7 +3920,7 @@ cups_sync_output(gx_device *pdev) /* I -
+ * 'cups_print_chunked()' - Print a page of chunked pixels.
+ */
+
+-static void
++static int
+ cups_print_chunked(gx_device_printer *pdev,
+ /* I - Printer device */
+ unsigned char *src,
+@@ -3754,18 +3942,18 @@ cups_print_chunked(gx_device_printer *pd
+ dprintf1("DEBUG2: cups->header.Duplex = %d\n", cups->header.Duplex);
+ dprintf1("DEBUG2: cups->header.Tumble = %d\n", cups->header.Tumble);
+ dprintf1("DEBUG2: cups->page = %d\n", cups->page);
+- dprintf1("DEBUG2: cupsPPD = %p\n", cupsPPD);
++ dprintf1("DEBUG2: cups->PPD = %p\n", cups->PPD);
+
+- if (cupsPPD) {
+- backside = ppdFindAttr(cupsPPD, "cupsBackSide", NULL);
++ if (cups->PPD) {
++ backside = ppdFindAttr(cups->PPD, "cupsBackSide", NULL);
+ if (backside) {
+ dprintf1("DEBUG2: cupsBackSide = %s\n", backside->value);
+- cupsPPD->flip_duplex = 0;
++ cups->PPD->flip_duplex = 0;
+ }
+ }
+- if (cups->header.Duplex && cupsPPD &&
++ if (cups->header.Duplex && cups->PPD &&
+ ((!cups->header.Tumble &&
+- (cupsPPD->flip_duplex ||
++ (cups->PPD->flip_duplex ||
+ (backside && !strcasecmp(backside->value, "Rotated")))) ||
+ (cups->header.Tumble &&
+ (backside && (!strcasecmp(backside->value, "Flipped") ||
+@@ -3774,9 +3962,9 @@ cups_print_chunked(gx_device_printer *pd
+ xflip = 1;
+ else
+ xflip = 0;
+- if (cups->header.Duplex && cupsPPD &&
++ if (cups->header.Duplex && cups->PPD &&
+ ((!cups->header.Tumble &&
+- (cupsPPD->flip_duplex ||
++ (cups->PPD->flip_duplex ||
+ (backside && (!strcasecmp(backside->value, "Flipped") ||
+ !strcasecmp(backside->value, "Rotated"))))) ||
+ (cups->header.Tumble &&
+@@ -3809,7 +3997,7 @@ cups_print_chunked(gx_device_printer *pd
+ if (gdev_prn_get_bits((gx_device_printer *)pdev, y, src, &srcptr) < 0)
+ {
+ dprintf1("ERROR: Unable to get scanline %d!\n", y);
+- gs_exit(gs_lib_ctx_get_non_gc_memory_t(), 1);
++ return_error(gs_error_unknownerror);
+ }
+
+ if (xflip)
+@@ -3832,8 +4020,8 @@ cups_print_chunked(gx_device_printer *pd
+ count > 0;
+ count --, srcptr --, dstptr ++)
+ {
+- *dstptr = cupsRevUpper1[*srcptr & 15] |
+- cupsRevLower1[*srcptr >> 4];
++ *dstptr = cups->RevUpper1[*srcptr & 15] |
++ cups->RevLower1[*srcptr >> 4];
+ }
+ break;
+
+@@ -3842,8 +4030,8 @@ cups_print_chunked(gx_device_printer *pd
+ count > 0;
+ count --, srcptr --, dstptr ++)
+ {
+- *dstptr = cupsRevUpper2[*srcptr & 15] |
+- cupsRevLower2[*srcptr >> 4];
++ *dstptr = cups->RevUpper2[*srcptr & 15] |
++ cups->RevLower2[*srcptr >> 4];
+ }
+ break;
+
+@@ -3941,6 +4129,7 @@ cups_print_chunked(gx_device_printer *pd
+ cupsRasterWritePixels(cups->stream, srcptr, cups->header.cupsBytesPerLine);
+ }
+ }
++ return (0);
+ }
+
+
+@@ -3948,7 +4137,7 @@ cups_print_chunked(gx_device_printer *pd
+ * 'cups_print_banded()' - Print a page of banded pixels.
+ */
+
+-static void
++static int
+ cups_print_banded(gx_device_printer *pdev,
+ /* I - Printer device */
+ unsigned char *src,
+@@ -3974,18 +4163,18 @@ cups_print_banded(gx_device_printer *pde
+ dprintf1("DEBUG2: cups->header.Duplex = %d\n", cups->header.Duplex);
+ dprintf1("DEBUG2: cups->header.Tumble = %d\n", cups->header.Tumble);
+ dprintf1("DEBUG2: cups->page = %d\n", cups->page);
+- dprintf1("DEBUG2: cupsPPD = %p\n", cupsPPD);
++ dprintf1("DEBUG2: cups->PPD = %p\n", cups->PPD);
+
+- if (cupsPPD) {
+- backside = ppdFindAttr(cupsPPD, "cupsBackSide", NULL);
++ if (cups->PPD) {
++ backside = ppdFindAttr(cups->PPD, "cupsBackSide", NULL);
+ if (backside) {
+ dprintf1("DEBUG2: cupsBackSide = %s\n", backside->value);
+- cupsPPD->flip_duplex = 0;
++ cups->PPD->flip_duplex = 0;
+ }
+ }
+- if (cups->header.Duplex && cupsPPD &&
++ if (cups->header.Duplex && cups->PPD &&
+ ((!cups->header.Tumble &&
+- (cupsPPD->flip_duplex ||
++ (cups->PPD->flip_duplex ||
+ (backside && !strcasecmp(backside->value, "Rotated")))) ||
+ (cups->header.Tumble &&
+ (backside && (!strcasecmp(backside->value, "Flipped") ||
+@@ -3994,9 +4183,9 @@ cups_print_banded(gx_device_printer *pde
+ xflip = 1;
+ else
+ xflip = 0;
+- if (cups->header.Duplex && cupsPPD &&
++ if (cups->header.Duplex && cups->PPD &&
+ ((!cups->header.Tumble &&
+- (cupsPPD->flip_duplex ||
++ (cups->PPD->flip_duplex ||
+ (backside && (!strcasecmp(backside->value, "Flipped") ||
+ !strcasecmp(backside->value, "Rotated"))))) ||
+ (cups->header.Tumble &&
+@@ -4040,7 +4229,7 @@ cups_print_banded(gx_device_printer *pde
+ if (gdev_prn_get_bits((gx_device_printer *)pdev, y, src, &srcptr) < 0)
+ {
+ dprintf1("ERROR: Unable to get scanline %d!\n", y);
+- gs_exit(gs_lib_ctx_get_non_gc_memory_t(), 1);
++ return_error(gs_error_unknownerror);
+ }
+
+ /*
+@@ -4646,6 +4835,7 @@ cups_print_banded(gx_device_printer *pde
+
+ cupsRasterWritePixels(cups->stream, dst, cups->header.cupsBytesPerLine);
+ }
++ return (0);
+ }
+
+
+@@ -4653,7 +4843,7 @@ cups_print_banded(gx_device_printer *pde
+ * 'cups_print_planar()' - Print a page of planar pixels.
+ */
+
+-static void
++static int
+ cups_print_planar(gx_device_printer *pdev,
+ /* I - Printer device */
+ unsigned char *src,
+@@ -4690,7 +4880,7 @@ cups_print_planar(gx_device_printer *pde
+ if (gdev_prn_get_bits((gx_device_printer *)pdev, y, src, &srcptr) < 0)
+ {
+ dprintf1("ERROR: Unable to get scanline %d!\n", y);
+- gs_exit(gs_lib_ctx_get_non_gc_memory_t(), 1);
++ return_error(gs_error_unknownerror);
+ }
+
+ /*
+@@ -5017,9 +5207,10 @@ cups_print_planar(gx_device_printer *pde
+
+ cupsRasterWritePixels(cups->stream, dst, cups->header.cupsBytesPerLine);
+ }
++ return (0);
+ }
+
+
+ /*
+- * End of "$Id: gdevcups.c 10631 2010-01-22 17:46:02Z till $".
++ * End of "$Id$".
+ */
diff --git a/ghostscript.spec b/ghostscript.spec
index 3de353c..075d05d 100644
--- a/ghostscript.spec
+++ b/ghostscript.spec
@@ -44,6 +44,7 @@ Patch25: ghostscript-bbox-close.patch
Patch26: ghostscript-gdevcups-ripcache.patch
Patch27: ghostscript-Fontmap.local.patch
Patch28: ghostscript-gdevcups-debug-uninit.patch
+Patch29: ghostscript-gdevcups-segfaults.patch
Requires: urw-fonts >= 1.1, ghostscript-fonts
BuildRequires: xz
@@ -208,6 +209,9 @@ rm -rf libpng zlib jpeg jasper
# gdevcups: don't use uninitialized variables in debugging output.
%patch28 -p1 -b .gdevcups-debug-uninit
+# Apply some fixes from upstream to avoid gdevcups segfaults (bug #639593).
+%patch29 -p1 -b .gdevcups-segfaults
+
# Convert manual pages to UTF-8
from8859_1() {
iconv -f iso-8859-1 -t utf-8 < "$1" > "${1}_"
@@ -390,6 +394,8 @@ rm -rf $RPM_BUILD_ROOT
%changelog
* Thu Oct 14 2010 Tim Waugh <twaugh at redhat.com> 8.71-19
+- Apply some fixes from upstream to avoid gdevcups
+ segfaults (bug #639593).
- gdevcups: don't use uninitialized variables in debugging output
(Ghostscript bug #691683).
More information about the scm-commits
mailing list