/*

 *

 *   GNU Ghostscript raster output driver for the Common UNIX Printing

 *   System (CUPS).

 *

 *   Copyright 1993-2006 by Easy Software Products.

 *

 *   These coded instructions, statements, and computer programs are the

 *   property of Easy Software Products and are protected by Federal

 *   copyright law.  Distribution and use rights are outlined in the file

 *   "LICENSE.txt" which should have been included with this file.  If this

 *   file is missing or damaged please contact Easy Software Products

 *   at:

 *

 *       Attn: CUPS Licensing Information

 *       Easy Software Products

 *       44141 Airport View Drive, Suite 204

 *       Hollywood, Maryland 20636 USA

 *

 *       Voice: (301) 373-9600

 *       EMail: cups-info@cups.org

 *         WWW: http://www.cups.org/

 *

 *   This code and any derivative of it may be used and distributed

 *   freely under the terms of the GNU General Public License when

 *   used with GNU Ghostscript or its derivatives.  Use of the code

 *   (or any derivative of it) with software other than GNU

 *   GhostScript (or its derivatives) is governed by the CUPS license

 *   agreement.

 *

 * Contents:

 *

 *   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.

 *   cups_get_params()       - Get pagedevice parameters.

 *   cups_get_space_params() - Get space parameters from the RIP_CACHE env var.

 *   cups_map_cielab()       - Map CIE Lab transformation...

 *   cups_map_cmyk()         - Map a CMYK color value to device colors.

 *   cups_map_gray()         - Map a grayscale value to device colors.

 *   cups_map_rgb()          - Map a RGB color value to device colors.

 *   cups_map_cmyk_color()   - Map a CMYK color to a color index.

 *   cups_map_color_rgb()    - Map a color index to an RGB color.

 *   cups_map_rgb_color()    - Map an RGB color to a color index.  We map the

 *                             RGB color to the output colorspace & bits (we

 *                             figure out the format when we output a page).

 *   cups_open()             - Open the output file and initialize things.

 *   cups_print_pages()      - Send one or more pages to the output file.

 *   cups_put_params()       - Set pagedevice parameters.

 *   cups_set_color_info()   - Set the color information structure based on

 *                             the required output.

 *   cups_sync_output()      - Keep the user informed of our status...

 *   cups_print_chunked()    - Print a page of chunked pixels.

 *   cups_print_banded()     - Print a page of banded pixels.

 *   cups_print_planar()     - Print a page of planar pixels.

 */

/* prevent gp.h redefining fopen */

#define sprintf sprintf

/*

 * Include necessary headers...

 */

#include "std.h"                /* to stop stdlib.h redefining types */

#include "gdevprn.h"

#include "gsparam.h"

#include "gxdevsop.h"

#include "arch.h"

#include "gsicc_manage.h"

#include <stdlib.h>

#include <ctype.h>

#ifdef __GNUC__

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

#endif

/* Recent cups releases on OSX pull in printf in a header file

   so we need to allow it. This may well end up being required

   on other platforms, too.

 */

#ifdef __APPLE__

#undef printf

#define printf printf

#endif

#include <cups/raster.h>

#include <cups/ppd.h>

#include <math.h>

/* the extremely noisy DEBUG2 messages are now dependent on CUPS_DEBUG2 */

/* this can be enabled during the 'make' or by uncommenting the following */

/* #define CUPS_DEBUG2 */

#undef private

#define private

#ifdef WIN32

#define cbrt(arg) pow(arg, 1.0/3)

#define strcasecmp _stricmp

#define strncasecmp _strnicmp

#endif

/* 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_space_params *old_space,

                                  int old_width, int old_height,

                                  bool old_page_uses_transparency);

/* Strings for cups_put/get_params */

static const char * const cups_Integer_strings[] =

{

  "cupsInteger0",

  "cupsInteger1",

  "cupsInteger2",

  "cupsInteger3",

  "cupsInteger4",

  "cupsInteger5",

  "cupsInteger6",

  "cupsInteger7",

  "cupsInteger8",

  "cupsInteger9",

  "cupsInteger10",

  "cupsInteger11",

  "cupsInteger12",

  "cupsInteger13",

  "cupsInteger14",

  "cupsInteger15",

  NULL

};

static const char * const cups_Real_strings[] =

{

  "cupsReal0",

  "cupsReal1",

  "cupsReal2",

  "cupsReal3",

  "cupsReal4",

  "cupsReal5",

  "cupsReal6",

  "cupsReal7",

  "cupsReal8",

  "cupsReal9",

  "cupsReal10",

  "cupsReal11",

  "cupsReal12",

  "cupsReal13",

  "cupsReal14",

  "cupsReal15",

  NULL

};

static const char * const cups_String_strings[] =

{

  "cupsString0",

  "cupsString1",

  "cupsString2",

  "cupsString3",

  "cupsString4",

  "cupsString5",

  "cupsString6",

  "cupsString7",

  "cupsString8",

  "cupsString9",

  "cupsString10",

  "cupsString11",

  "cupsString12",

  "cupsString13",

  "cupsString14",

  "cupsString15",

  NULL

};

/*

 * Check if we are compiling against CUPS 1.2.  If so, enable

 * certain extended attributes and use a different page header

 * structure and write function...

 */

#ifdef CUPS_RASTER_SYNCv1

#  define cups_page_header_t cups_page_header2_t

#  define cupsRasterWriteHeader cupsRasterWriteHeader2

#else

/* The RGBW, SW, SRGB, and ADOBERGB colorspaces is not defined until

   CUPS 1.2... */

#  define CUPS_CSPACE_RGBW 17

#  define CUPS_CSPACE_SW 18

#  define CUPS_CSPACE_SRGB 19

#  define CUPS_CSPACE_ADOBERGB 20

#endif /* CUPS_RASTER_SYNCv1 */

#if !defined(CUPS_RASTER_WRITE_PWG)

    #define CUPS_RASTER_WRITE_PWG 3

#endif

/*

 * CIE XYZ color constants...

 */

#define D65_X (0.412453 + 0.357580 + 0.180423)

#define D65_Y (0.212671 + 0.715160 + 0.072169)

#define D65_Z (0.019334 + 0.119193 + 0.950227)

/*

 * Size of a tile in pixels...

 */

#define CUPS_TILE_SIZE  256

/*

 * Size of profile LUTs...

 */

#ifdef dev_t_proc_encode_color

#  define CUPS_MAX_VALUE  frac_1

#else

#  define CUPS_MAX_VALUE  gx_max_color_value

#endif /* dev_t_proc_encode_color */

/*

 * Macros...

 */

#define x_dpi   (pdev->HWResolution[0])

#define y_dpi   (pdev->HWResolution[1])

#define cups    ((gx_device_cups *)pdev)

/*

 * Macros from <macros.h>; we can't include <macros.h> because it also

 * defines DEBUG, one of our flags to insert various debugging code.

 */

#ifndef max

#  define max(a,b)  ((a)<(b) ? (b) : (a))

#endif /* !max */

#ifndef min

#  define min(a,b)  ((a)>(b) ? (b) : (a))

#endif /* !min */

#ifndef abs

#  define abs(x)  ((x)>=0 ? (x) : -(x))

#endif /* !abs */

/*

 * Procedures

 */

private dev_proc_close_device(cups_close);

private dev_proc_get_initial_matrix(cups_get_matrix);

private int cups_get_params(gx_device *, gs_param_list *);

private dev_proc_open_device(cups_open);

private dev_proc_output_page(cups_output_page);

private int cups_print_pages(gx_device_printer *, gp_file *, int);

private int cups_put_params(gx_device *, gs_param_list *);

private int cups_set_color_info(gx_device *);

private dev_proc_sync_output(cups_sync_output);

private prn_dev_proc_get_space_params(cups_get_space_params);

private int cups_spec_op(gx_device *dev_, int op, void *data, int datasize);

#ifdef dev_t_proc_encode_color

private cm_map_proc_gray(cups_map_gray);

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 =

{

  cups_map_gray,

  cups_map_rgb,

  cups_map_cmyk

};

#else

private dev_proc_map_cmyk_color(cups_map_cmyk_color);

private dev_proc_map_color_rgb(cups_map_color_rgb);

private dev_proc_map_rgb_color(cups_map_rgb_color);

#endif /* dev_t_proc_encode_color */

/*

 * The device descriptors...

 */

typedef struct gx_device_cups_s

{

  gx_device_common;     /* Standard GhostScript device stuff */

  gx_prn_device_common;     /* Standard printer device stuff */

  int     page;   /* Page number */

  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 */

  int                   user_icc;

  int                   cupsRasterVersion;

  char                  cupsBackSideOrientation[64];

  int                   cupsBackSideFlipMargins;

  int                   cupsManualCopies;

  char                  pageSizeRequested[64];

  /* Used by cups_put_params(): */

} gx_device_cups;

static void

cups_initialize_device_procs(gx_device *dev)

{

    set_dev_proc(dev, open_device, cups_open);

    set_dev_proc(dev, get_initial_matrix, cups_get_matrix);

    set_dev_proc(dev, sync_output, cups_sync_output);

    set_dev_proc(dev, output_page, cups_output_page);

    set_dev_proc(dev, close_device, cups_close);

#ifdef dev_t_proc_encode_color

    set_dev_proc(dev, get_color_mapping_procs, cups_get_color_mapping_procs);

    set_dev_proc(dev, get_color_comp_index, cups_get_color_comp_index);

    set_dev_proc(dev, encode_color, cups_encode_color);

    set_dev_proc(dev, decode_color, cups_decode_color);

#else

    set_dev_proc(dev, map_rgb_color, cups_map_rgb_color);

    set_dev_proc(dev, map_color_rgb, cups_map_color_rgb);

    set_dev_proc(dev, map_cmyk_color, cups_map_cmyk_color);

#endif

    set_dev_proc(dev, get_params, cups_get_params);

    set_dev_proc(dev, put_params, cups_put_params);

    set_dev_proc(dev, get_page_device, gx_page_device_get_page_device);

    set_dev_proc(dev, dev_spec_op, cups_spec_op);

}

#define prn_device_body_copies(dtype, init, dname, w10, h10, xdpi, ydpi, lo, to, lm, bm, rm, tm, ncomp, depth, mg, mc, dg, dc, print_pages)\

  std_device_full_body_type(dtype, init, dname, &st_device_printer,\

    (int)((long)(w10) * (xdpi) / 10),\

    (int)((long)(h10) * (ydpi) / 10),\

    xdpi, ydpi,\

    ncomp, depth, mg, mc, dg, dc,\

    -(lo) * (xdpi), -(to) * (ydpi),\

    (lm) * 72.0, (bm) * 72.0,\

    (rm) * 72.0, (tm) * 72.0\

  ),\

  prn_device_body_copies_rest_(print_pages)

#ifdef CUPS_RASTER_SYNCv1

#define RASTER_SYNCv1_ENTRIES \

    ,\

    1,                                  /* cupsNumColors */\

    1.0,                                /* cupsBorderlessScalingFactor */\

    { 612.0, 792.0 },                   /* cupsPageSize */\

    { 0.0, 0.0, 612.0, 792.0 },         /* cupsImagingBBox */\

    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, /* cupsInteger */\

    { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,\

      0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 }, /* cupsReal */\

    { "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "" },\

                                        /* cupsString */\

    "",                                 /* cupsMarkerType */\

    "",                                 /* cupsRenderingIntent */\

    ""                                  /* cupsPageSizeName */

#else

#define RASTER_SYNCv1_ENTRIES

#endif /* CUPS_RASTER_SYNCv1 */

#define gs_xxx_device(dname, mediaclass)\

  prn_device_body_copies(gx_device_cups,/* type */\

                         cups_initialize_device_procs,/* init */\

       dname,   /* device name */\

       85,    /* initial width */\

       110,   /* initial height */\

       100,   /* initial x resolution */\

       100,   /* initial y resolution */\

                         0,   /* initial left offset */\

       0,   /* initial top offset */\

       0,   /* initial left margin */\

       0,   /* initial bottom margin */\

       0,   /* initial right margin */\

       0,   /* initial top margin */\

       1,   /* number of color components */\

       1,   /* number of color bits */\

       1,   /* maximum gray value */\

       0,   /* maximum color value */\

       2,   /* number of gray values */\

       0,   /* number of color values */\

       cups_print_pages),\

          /* print procedure */\

  0,          /* page */\

  NULL,         /* stream */\

  {         /* header */\

    mediaclass,       /* MediaClass */\

    "",         /* MediaColor */\

    "",         /* MediaType */\

    "",         /* OutputType */\

    0,          /* AdvanceDistance */\

    CUPS_ADVANCE_NONE,      /* AdvanceMedia */\

    CUPS_FALSE,       /* Collate */\

    CUPS_CUT_NONE,      /* CutMedia */\

    CUPS_FALSE,       /* Duplex */\

    { 100, 100 },     /* HWResolution */\

    { 0, 0, 612, 792 },     /* ImagingBoundingBox */\

    CUPS_FALSE,       /* InsertSheet */\

    CUPS_JOG_NONE,      /* Jog */\

    CUPS_EDGE_TOP,      /* LeadingEdge */\

    { 0, 0 },       /* Margins */\

    CUPS_FALSE,       /* ManualFeed */\

    0,          /* MediaPosition */\

    0,          /* MediaWeight */\

    CUPS_FALSE,       /* MirrorPrint */\

    CUPS_FALSE,       /* NegativePrint */\

    1,          /* NumCopies */\

    CUPS_ORIENT_0,      /* Orientation */\

    CUPS_FALSE,       /* OutputFaceUp */\

    { 612, 792 },     /* PageSize */\

    CUPS_FALSE,       /* Separations */\

    CUPS_FALSE,       /* TraySwitch */\

    CUPS_FALSE,       /* Tumble */\

    850,        /* cupsWidth */\

    1100,       /* cupsHeight */\

    0,          /* cupsMediaType */\

    1,          /* cupsBitsPerColor */\

    1,          /* cupsBitsPerPixel */\

    107,        /* cupsBytesPerLine */\

    CUPS_ORDER_CHUNKED,     /* cupsColorOrder */\

    CUPS_CSPACE_K,      /* cupsColorSpace */\

    0,          /* cupsCompression */\

    0,          /* cupsRowCount */\

    0,          /* cupsRowFeed */\

    0         /* cupsRowStep */\

    RASTER_SYNCv1_ENTRIES, /* See above */\

  },\

  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 */\

  {0x00},                                  /* DecodeLUT */\

  {0x00},                                  /* EncodeLUT */\

  {0x00},                                  /* Density */\

  {{{0x00},{0x00},{0x00}},\

   {{0x00},{0x00},{0x00}},\

   {{0x00},{0x00},{0x00}}},                /* Matrix */\

  0,                                       /* user_icc */\

  3,                                     /* cupsRasterVersion */\

  "Normal",                                /* cupsBackSideOrientation */\

  0,                                       /* cupsBackSideFlipMargins */\

  0,                                       /* cupsManualCopies */\

  ""                                     /* pageSizeRequested */

gx_device_cups  gs_cups_device = { gs_xxx_device("cups", "") };

gx_device_cups  gs_pwgraster_device = { gs_xxx_device("pwgraster",

                  "PwgRaster") };

#if defined(CUPS_RASTER_HAVE_APPLERASTER)

gx_device_cups  gs_appleraster_device = { gs_xxx_device("appleraster",

              "PwgRaster") };

gx_device_cups  gs_urf_device = { gs_xxx_device("urf",

            "PwgRaster") };

#endif

/*

 * Local functions...

 */

static double cups_map_cielab(double, double);

static int  cups_print_chunked(gx_device_printer *, unsigned char *,

                       unsigned char *, int);

static int  cups_print_banded(gx_device_printer *, unsigned char *,

                      unsigned char *, int);

static int  cups_print_planar(gx_device_printer *, unsigned char *,

                      unsigned char *, int);

/*static void cups_set_margins(gx_device *);*/

/*

 * 'cups_close()' - Close the output file.

 */

private int

cups_close(gx_device *pdev)   /* I - Device info */

{

#ifdef CUPS_DEBUG2

  dmprintf1(pdev->memory, "DEBUG2: cups_close(%p)\n", pdev);

#endif /* CUPS_DEBUG2 */

  dmprintf(pdev->memory, "INFO: Rendering completed\n");

  if (cups->stream != NULL)

  {

    cupsRasterClose(cups->stream);

    cups->stream = NULL;

  }

#if 0 /* Can't do this here because put_params() might close the device */

  if (cups->PPD != NULL)

  {

    ppdClose(cups->PPD);

    cups->PPD = NULL;

  }

  if (cups->Profile != NULL)

  {

    free(cups->Profile);

    cups->Profile = NULL;

  }

#endif /* 0 */

  return (gdev_prn_close(pdev));

}

#ifdef dev_t_proc_encode_color

/*

 * 'cups_decode_color()' - Decode a color value.

 */

private int       /* O - Status (0 = OK) */

cups_decode_color(gx_device      *pdev, /* I - Device info */

                  gx_color_index ci,  /* I - Color index */

                  gx_color_value *cv) /* O - Colors */

{

  int     i;    /* Looping var */

  int     shift;    /* Bits to shift */

  int     mask;   /* Bits to mask */

  if (cups->header.cupsColorSpace == CUPS_CSPACE_KCMYcm &&

      cups->header.cupsBitsPerColor == 1)

  {

   /*

    * KCMYcm data is represented internally by Ghostscript as CMYK...

    */

    cv[0] = (ci & 0x20) ? frac_1 : frac_0;

    cv[1] = (ci & 0x12) ? frac_1 : frac_0;

    cv[2] = (ci & 0x09) ? frac_1 : frac_0;

    cv[3] = (ci & 0x04) ? frac_1 : frac_0;

  }

  else

  {

    shift = cups->header.cupsBitsPerColor;

    mask  = (1 << shift) - 1;

    for (i = cups->color_info.num_components - 1; i > 0; i --, ci >>= shift)

      cv[i] = cups->DecodeLUT[ci & mask];

    cv[0] = cups->DecodeLUT[ci & mask];

  }

  return (0);

}

/*

 * 'cups_encode_color()' - Encode a color value.

 */

private gx_color_index      /* O - Color index */

cups_encode_color(gx_device            *pdev,

          /* I - Device info */

                  const gx_color_value *cv)

          /* I - Colors */

{

  int     i;    /* Looping var */

  gx_color_index  ci;   /* Color index */

  int     shift;    /* Bits to shift */

 /*

  * Encode the color index...

  */

  shift = cups->header.cupsBitsPerColor;

  for (ci = cups->EncodeLUT[cv[0]], i = 1;

       i < cups->color_info.num_components;

       i ++)

    ci = (ci << shift) | cups->EncodeLUT[cv[i]];

#ifdef CUPS_DEBUG2

  dmprintf2(pdev->memory, "DEBUG2: cv[0]=%d -> %llx\n", cv[0], ci);

#endif /* CUPS_DEBUG2 */

 /*

  * Handle 6-color output...

  */

  if (cups->header.cupsColorSpace == CUPS_CSPACE_KCMYcm &&

      cups->header.cupsBitsPerColor == 1)

  {

   /*

    * Welcome to hackville, where we map CMYK data to the

    * light inks in draft mode...  Map blue to light magenta and

    * cyan and green to light cyan and yellow...

    */

    ci <<= 2;       /* Leave room for light inks */

    if (ci == 0x18)      /* Blue */

      ci = 0x11;      /* == cyan + light magenta */

    else if (ci == 0x14)    /* Green */

      ci = 0x06;     /* == light cyan + yellow */

  }

  /* The entire manner that cups does its color mapping needs some serious

     rework.  In the case of the output RGBW color space, it takes a source

     CMYK value which gs maps to RGB, cups then maps the RGB to CMYK and then

     from there to RGBW and finally it does an encode.  Unfortunately, the

     number of color values for RGBW is 3 since it is using an RGB ICC profile

     this means that the W mapping value from cups is lost in cmap_rgb_direct

     So here we ensure that the W is always set to on (else we end up with a

     blue background cast).  The ideal way

     to fix this is to move some of these odd color spaces of cups to the

     separation device model ensuring that things are handled properly. */

  if (cups->header.cupsColorSpace == CUPS_CSPACE_RGBW) {

      ci = (ci << shift) | cups->EncodeLUT[gx_max_color_value];

  }

 /*

  * Range check the return value...

  */

  if (ci == gx_no_color_index)

    ci --;

 /*

  * Return the color index...

  */

  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_SW :

    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;

        /* fall through */

    case CUPS_CSPACE_RGBW :

        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;

  if (compare_color_names(pname, name_size, "White"))

            return 3;

  else

      return -1;

        break;

    case CUPS_CSPACE_RGB :

    case CUPS_CSPACE_SRGB :

    case CUPS_CSPACE_ADOBERGB :

        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;

        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;

        /* fall through */

    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;

        /* fall through */

    case CUPS_CSPACE_GMCK :

        if (compare_color_names(pname, name_size, "Gold") ||

      compare_color_names(pname, name_size, "Gold Foil"))

      return 0;

        /* fall through */

    case CUPS_CSPACE_YMCK :

        if (compare_color_names(pname, name_size, "Black"))

      return 3;

        /* fall through */

    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;

    default:

        break;

  }

  return -1;

}

/*

 * 'cups_get_color_mapping_procs()' - Get the list of color mapping procedures.

 */

private const gx_cm_color_map_procs * /* O - List of device procedures */

cups_get_color_mapping_procs(const gx_device *pdev, const gx_device **tdev)

          /* I - Device info */

{

  *tdev = pdev;

  return (&cups_color_mapping_procs);

}

#endif /* dev_t_proc_encode_color */

/*

 * 'cups_get_matrix()' - Generate the default page matrix.

 */

private void

cups_get_matrix(gx_device *pdev,  /* I - Device info */

                gs_matrix *pmat)  /* O - Physical transform matrix */

{

#ifdef CUPS_DEBUG2

  dmprintf2(pdev->memory, "DEBUG2: cups_get_matrix(%p, %p)\n", pdev, pmat);

#endif /* CUPS_DEBUG2 */

 /*

  * Set the raster width and height...

  */

  cups->header.cupsWidth  = cups->width;

  cups->header.cupsHeight = cups->height;

 /*

  * Set the transform matrix...

  */

  if (cups->landscape)

  {

   /*

    * Do landscape orientation...

    */

#ifdef CUPS_DEBUG2

    dprintf("DEBUG2: Landscape matrix: XX=0 XY=+1 YX=+1 YY=0\n");

#endif /* CUPS_DEBUG2 */

    pmat->xx = 0.0;

    pmat->xy = (float)cups->header.HWResolution[1] / 72.0;

    pmat->yx = (float)cups->header.HWResolution[0] / 72.0;

    pmat->yy = 0.0;

    pmat->tx = -(float)cups->header.HWResolution[0] * pdev->HWMargins[1] / 72.0;

    pmat->ty = -(float)cups->header.HWResolution[1] * pdev->HWMargins[0] / 72.0;

  }

  else

  {

   /*

    * Do portrait orientation...

    */

#ifdef CUPS_DEBUG2

    dmprintf(pdev->memory, "DEBUG2: Portrait matrix: XX=+1 XY=0 YX=0 YY=-1\n");

#endif /* CUPS_DEBUG2 */

    pmat->xx = (float)cups->header.HWResolution[0] / 72.0;

    pmat->xy = 0.0;

    pmat->yx = 0.0;

    pmat->yy = -(float)cups->header.HWResolution[1] / 72.0;

    pmat->tx = -(float)cups->header.HWResolution[0] * pdev->HWMargins[0] / 72.0;

    pmat->ty = (float)cups->header.HWResolution[1] *

               ((float)cups->header.PageSize[1] - pdev->HWMargins[3]) / 72.0;

  }

#ifdef CUPS_RASTER_SYNCv1

  if (cups->header.cupsBorderlessScalingFactor > 1.0)

  {

    pmat->xx *= cups->header.cupsBorderlessScalingFactor;

    pmat->xy *= cups->header.cupsBorderlessScalingFactor;

    pmat->yx *= cups->header.cupsBorderlessScalingFactor;

    pmat->yy *= cups->header.cupsBorderlessScalingFactor;

    pmat->tx *= cups->header.cupsBorderlessScalingFactor;

    pmat->ty *= cups->header.cupsBorderlessScalingFactor;

  }

#endif /* CUPS_RASTER_SYNCv1 */

#ifdef CUPS_DEBUG2

  dmprintf2(pdev->memory, "DEBUG2: width = %d, height = %d\n", cups->header.cupsWidth,

            cups->header.cupsHeight);

  dmprintf4(pdev->memory, "DEBUG2: PageSize = [ %d %d ], HWResolution = [ %d %d ]\n",

            cups->header.PageSize[0], cups->header.PageSize[1],

            cups->header.HWResolution[0], cups->header.HWResolution[1]);

  dmprintf4(pdev->memory, "DEBUG2: HWMargins = [ %.3f %.3f %.3f %.3f ]\n",

            pdev->HWMargins[0], pdev->HWMargins[1], pdev->HWMargins[2],

            pdev->HWMargins[3]);

  dmprintf6(pdev->memory, "DEBUG2: matrix = [ %.3f %.3f %.3f %.3f %.3f %.3f ]\n",

            pmat->xx, pmat->xy, pmat->yx, pmat->yy, pmat->tx, pmat->ty);

#endif /* CUPS_DEBUG2 */

}

/*

 * 'cups_get_params()' - Get pagedevice parameters.

 */

private int       /* O - Error status */

cups_get_params(gx_device     *pdev,  /* I - Device info */

                gs_param_list *plist) /* I - Parameter list */

{

  int     code;   /* Return code */

  gs_param_string s;    /* Temporary string value */

  bool      b;    /* Temporary boolean value */

#ifdef CUPS_RASTER_SYNCv1

  int     i;    /* Looping var */

#endif /* CUPS_RASTER_SYNCv1 */

#ifdef CUPS_DEBUG2

  dmprintf2(pdev->memory, "DEBUG2: cups_get_params(%p, %p)\n", pdev, plist);

#endif /* CUPS_DEBUG2 */

 /*

  * First process the "standard" page device parameters...

  */

#ifdef CUPS_DEBUG2

  dmprintf(pdev->memory, "DEBUG2: before gdev_prn_get_params()\n");

#endif /* CUPS_DEBUG2 */

  if ((code = gdev_prn_get_params(pdev, plist)) < 0)

    goto done;

#ifdef CUPS_DEBUG2

  dmprintf(pdev->memory, "DEBUG2: after gdev_prn_get_params()\n");

#endif /* CUPS_DEBUG2 */

 /*

  * Then write the CUPS parameters...

  */

  param_string_from_transient_string(s, cups->header.MediaClass);

  if ((code = param_write_string(plist, "MediaClass", &s)) < 0)

    goto done;

  param_string_from_transient_string(s, cups->header.MediaColor);

  if ((code = param_write_string(plist, "MediaColor", &s)) < 0)

    goto done;

  param_string_from_transient_string(s, cups->header.MediaType);

  if ((code = param_write_string(plist, "MediaType", &s)) < 0)

    goto done;

  param_string_from_transient_string(s, cups->header.OutputType);

  if ((code = param_write_string(plist, "OutputType", &s)) < 0)

    goto done;

  if ((code = param_write_int(plist, "AdvanceDistance",

                              (int *)&(cups->header.AdvanceDistance))) < 0)

    goto done;

  if ((code = param_write_int(plist, "AdvanceMedia",

                              (int *)&(cups->header.AdvanceMedia))) < 0)

    goto done;

  b = cups->header.Collate;

  if ((code = param_write_bool(plist, "Collate", &b)) < 0)

    goto done;

  if ((code = param_write_int(plist, "CutMedia",

                              (int *)&(cups->header.CutMedia))) < 0)

    goto done;

  b = cups->header.Duplex;

  if ((code = param_write_bool(plist, "Duplex", &b)) < 0)

    goto done;

  b = cups->header.InsertSheet;

  if ((code = param_write_bool(plist, "InsertSheet", &b)) < 0)

    goto done;

  if ((code = param_write_int(plist, "Jog",

                              (int *)&(cups->header.Jog))) < 0)

    goto done;

  b = cups->header.ManualFeed;

  if ((code = param_write_bool(plist, "ManualFeed", &b)) < 0)

    goto done;

  if ((code = param_write_int(plist, "MediaPosition",

                              (int *)&(cups->header.MediaPosition))) < 0)

    goto done;

  if ((code = param_write_int(plist, "MediaWeight",

                              (int *)&(cups->header.MediaWeight))) < 0)

    goto done;

  b = cups->header.MirrorPrint;

  if ((code = param_write_bool(plist, "MirrorPrint", &b)) < 0)

    goto done;

  b = cups->header.NegativePrint;

  if ((code = param_write_bool(plist, "NegativePrint", &b)) < 0)

    goto done;

  b = cups->header.OutputFaceUp;

  if ((code = param_write_bool(plist, "OutputFaceUp", &b)) < 0)

    goto done;

  b = cups->header.Separations;

  if ((code = param_write_bool(plist, "Separations", &b)) < 0)

    goto done;

  b = cups->header.TraySwitch;

  if ((code = param_write_bool(plist, "TraySwitch", &b)) < 0)

    goto done;

  b = cups->header.Tumble;

  if ((code = param_write_bool(plist, "Tumble", &b)) < 0)

    goto done;

#if 0 /* Don't include read-only parameters... */

  if ((code = param_write_int(plist, "cupsWidth",

                              (int *)&(cups->header.cupsWidth))) < 0)

    goto done;

  if ((code = param_write_int(plist, "cupsHeight",

                              (int *)&(cups->header.cupsHeight))) < 0)

    goto done;

  if ((code = param_write_int(plist, "cupsBitsPerPixel",

                              (int *)&(cups->header.cupsBitsPerPixel))) < 0)

    goto done;

  if ((code = param_write_int(plist, "cupsBytesPerLine",

                              (int *)&(cups->header.cupsBytesPerLine))) < 0)

    goto done;

#endif /* 0 */

  if ((code = param_write_int(plist, "cupsMediaType",

                              (int *)&(cups->header.cupsMediaType))) < 0)

    goto done;

  if ((code = param_write_int(plist, "cupsBitsPerColor",

                              (int *)&(cups->header.cupsBitsPerColor))) < 0)

    goto done;

  if ((code = param_write_int(plist, "cupsColorOrder",

                              (int *)&(cups->header.cupsColorOrder))) < 0)

    goto done;

  if ((code = param_write_int(plist, "cupsColorSpace",

                              (int *)&(cups->header.cupsColorSpace))) < 0)

    goto done;