/*
- * "$Id: imagetoraster.c 5191 2006-02-27 02:47:56Z mike $"
+ * "$Id: imagetoraster.c 6649 2007-07-11 21:46:42Z mike $"
*
* Image file to raster filter for the Common UNIX Printing System (CUPS).
*
- * Copyright 1993-2006 by Easy Software Products.
+ * Copyright 2007 by Apple Inc.
+ * Copyright 1993-2007 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
+ * property of Apple Inc. 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
+ * file is missing or damaged, see the license at "http://www.cups.org/".
*
* This file is subject to the Apple OS-Developed Software exception.
*
* Contents:
*
* main() - Main entry...
- * exec_code() - Execute PostScript setpagedevice commands as
- * appropriate.
+ * blank_line() - Clear a line buffer to the blank value...
* format_CMY() - Convert image data to CMY.
* format_CMYK() - Convert image data to CMYK.
* format_K() - Convert image data to black.
* format_YMC() - Convert image data to YMC.
* format_YMCK() - Convert image data to YMCK.
* make_lut() - Make a lookup table given gamma and brightness values.
+ * raster_cb() - Validate the page header.
*/
/*
#include "raster.h"
#include <unistd.h>
#include <math.h>
+#include <cups/i18n.h>
/*
YPosition = 0, /* Vertical position on page */
Collate = 0, /* Collate copies? */
Copies = 1; /* Number of copies */
-int Floyd16xc16[16][16] = /* Traditional Floyd ordered dither */
+int Floyd16x16[16][16] = /* Traditional Floyd ordered dither */
{
{ 0, 128, 32, 160, 8, 136, 40, 168,
2, 130, 34, 162, 10, 138, 42, 170 },
cups_ib_t OnPixels[256], /* On-pixel LUT */
OffPixels[256]; /* Off-pixel LUT */
-int Planes[] = /* Number of planes for each colorspace */
- {
- 1, /* CUPS_CSPACE_W */
- 3, /* CUPS_CSPACE_RGB */
- 4, /* CUPS_CSPACE_RGBA */
- 1, /* CUPS_CSPACE_K */
- 3, /* CUPS_CSPACE_CMY */
- 3, /* CUPS_CSPACE_YMC */
- 4, /* CUPS_CSPACE_CMYK */
- 4, /* CUPS_CSPACE_YMCK */
- 4, /* CUPS_CSPACE_KCMY */
- 6, /* CUPS_CSPACE_KCMYcm */
- 4, /* CUPS_CSPACE_GMCK */
- 4, /* CUPS_CSPACE_GMCS */
- 1, /* CUPS_CSPACE_WHITE */
- 1, /* CUPS_CSPACE_GOLD */
- 1, /* CUPS_CSPACE_SILVER */
- 3, /* CUPS_CSPACE_CIEXYZ */
- 3, /* CUPS_CSPACE_CIELab */
- 4, /* CUPS_CSPACE_RGBW */
- 0, /* ... reserved ... */
- 0, /* ... reserved ... */
- 0, /* ... reserved ... */
- 0, /* ... reserved ... */
- 0, /* ... reserved ... */
- 0, /* ... reserved ... */
- 0, /* ... reserved ... */
- 0, /* ... reserved ... */
- 0, /* ... reserved ... */
- 0, /* ... reserved ... */
- 0, /* ... reserved ... */
- 0, /* ... reserved ... */
- 0, /* ... reserved ... */
- 0, /* ... reserved ... */
- 3, /* CUPS_CSPACE_ICC1 */
- 3, /* CUPS_CSPACE_ICC2 */
- 3, /* CUPS_CSPACE_ICC3 */
- 3, /* CUPS_CSPACE_ICC4 */
- 3, /* CUPS_CSPACE_ICC5 */
- 3, /* CUPS_CSPACE_ICC6 */
- 3, /* CUPS_CSPACE_ICC7 */
- 3, /* CUPS_CSPACE_ICC8 */
- 3, /* CUPS_CSPACE_ICC9 */
- 3, /* CUPS_CSPACE_ICCA */
- 3, /* CUPS_CSPACE_ICCB */
- 3, /* CUPS_CSPACE_ICCC */
- 3, /* CUPS_CSPACE_ICCD */
- 3, /* CUPS_CSPACE_ICCE */
- 3 /* CUPS_CSPACE_ICCF */
- };
/*
* Local functions...
*/
-
-static void exec_code(cups_page_header2_t *header, const char *code);
+
+static void blank_line(cups_page_header2_t *header, unsigned char *row);
static void format_CMY(cups_page_header2_t *header, unsigned char *row, int y, int z, int xsize, int ysize, int yerr0, int yerr1, cups_ib_t *r0, cups_ib_t *r1);
static void format_CMYK(cups_page_header2_t *header, unsigned char *row, int y, int z, int xsize, int ysize, int yerr0, int yerr1, cups_ib_t *r0, cups_ib_t *r1);
static void format_K(cups_page_header2_t *header, unsigned char *row, int y, int z, int xsize, int ysize, int yerr0, int yerr1, cups_ib_t *r0, cups_ib_t *r1);
static void format_YMC(cups_page_header2_t *header, unsigned char *row, int y, int z, int xsize, int ysize, int yerr0, int yerr1, cups_ib_t *r0, cups_ib_t *r1);
static void format_YMCK(cups_page_header2_t *header, unsigned char *row, int y, int z, int xsize, int ysize, int yerr0, int yerr1, cups_ib_t *r0, cups_ib_t *r1);
static void make_lut(cups_ib_t *, int, float, float);
+static int raster_cb(cups_page_header2_t *header, int preferred_bits);
/*
xtemp, /* Bitmap width in pixels */
ytemp, /* Bitmap height in pixels */
page; /* Current page number */
- int xc0, yc0, /* Corners of the page in image coords */
+ int xc0, yc0, /* Corners of the page in image coords */
xc1, yc1;
ppd_file_t *ppd; /* PPD file */
- ppd_choice_t *choice, /* PPD option choice */
- **choices; /* List of marked choices */
- int count; /* Number of marked choices */
+ ppd_choice_t *choice; /* PPD option choice */
char *resolution, /* Output resolution */
*media_type; /* Media type */
ppd_profile_t *profile; /* Color profile */
iy, /* Current Y coordinate in image */
last_iy, /* Previous Y coordinate in image */
yerr0, /* Top Y error value */
- yerr1, /* Bottom Y error value */
- blank; /* Blank value */
+ yerr1; /* Bottom Y error value */
cups_ib_t lut[256]; /* Gamma/brightness LUT */
int plane, /* Current color plane */
num_planes; /* Number of color planes */
if (argc < 6 || argc > 7)
{
- fputs("ERROR: imagetoraster job-id user title copies options [file]\n", stderr);
+ fprintf(stderr, _("Usage: %s job-id user title copies options [file]\n"),
+ argv[0]);
return (1);
}
- fprintf(stderr, "INFO: %s %s %s %s %s %s %s\n", argv[0], argv[1], argv[2],
- argv[3], argv[4], argv[5], argv[6] ? argv[6] : "(null)");
-
/*
* See if we need to use the imagetops and pstoraster filters instead...
*/
if ((val = cupsGetOption("hue", num_options, options)) != NULL)
hue = atoi(val);
- if ((val = cupsGetOption("mirror", num_options, options)) != NULL &&
- strcasecmp(val, "True") == 0)
+ if ((choice = ppdFindMarkedChoice(ppd, "MirrorPrint")) != NULL)
+ {
+ val = choice->choice;
+ choice->marked = 0;
+ }
+ else
+ val = cupsGetOption("mirror", num_options, options);
+
+ if (val && (!strcasecmp(val, "true") || !strcasecmp(val, "on") ||
+ !strcasecmp(val, "yes")))
Flip = 1;
/*
* Set the needed options in the page header...
*/
- memset(&header, 0, sizeof(header));
- header.HWResolution[0] = 100;
- header.HWResolution[1] = 100;
- header.cupsBitsPerColor = 1;
- header.cupsColorOrder = CUPS_ORDER_CHUNKED;
- header.cupsColorSpace = CUPS_CSPACE_K;
-
- if (ppd && ppd->patches)
- exec_code(&header, ppd->patches);
-
- if ((count = ppdCollect(ppd, PPD_ORDER_DOCUMENT, &choices)) > 0)
- for (i = 0; i < count; i ++)
- exec_code(&header, choices[i]->code);
-
- if ((count = ppdCollect(ppd, PPD_ORDER_ANY, &choices)) > 0)
- for (i = 0; i < count; i ++)
- exec_code(&header, choices[i]->code);
-
- if ((count = ppdCollect(ppd, PPD_ORDER_PROLOG, &choices)) > 0)
- for (i = 0; i < count; i ++)
- exec_code(&header, choices[i]->code);
-
- if ((count = ppdCollect(ppd, PPD_ORDER_PAGE, &choices)) > 0)
- for (i = 0; i < count; i ++)
- exec_code(&header, choices[i]->code);
+ if (cupsRasterInterpretPPD(&header, ppd, num_options, options, raster_cb))
+ {
+ fputs(_("ERROR: Bad page setup!\n"), stderr);
+ fprintf(stderr, "DEBUG: %s\n", cupsRasterErrorString());
+ return (1);
+ }
/*
* Get the media type and resolution that have been chosen...
switch (header.cupsColorSpace)
{
case CUPS_CSPACE_W :
- primary = CUPS_IMAGE_WHITE;
- secondary = CUPS_IMAGE_WHITE;
- header.cupsBitsPerPixel = header.cupsBitsPerColor;
+ if (header.cupsBitsPerColor >= 8)
+ {
+ primary = CUPS_IMAGE_WHITE;
+ secondary = CUPS_IMAGE_WHITE;
+ }
+ else
+ {
+ primary = CUPS_IMAGE_BLACK;
+ secondary = CUPS_IMAGE_BLACK;
+ }
break;
default :
case CUPS_CSPACE_RGB :
case CUPS_CSPACE_RGBA :
case CUPS_CSPACE_RGBW :
- primary = CUPS_IMAGE_RGB;
- secondary = CUPS_IMAGE_RGB;
-
- /*
- * Ensure that colorimetric colorspaces use at least 8 bits per
- * component...
- */
-
- if (header.cupsColorSpace >= CUPS_CSPACE_CIEXYZ &&
- header.cupsBitsPerColor < 8)
- header.cupsBitsPerColor = 8;
-
- if (header.cupsColorOrder == CUPS_ORDER_CHUNKED)
+ if (header.cupsBitsPerColor >= 8)
{
- if (header.cupsBitsPerColor >= 8)
- header.cupsBitsPerPixel = header.cupsBitsPerColor * 3;
- else
- header.cupsBitsPerPixel = header.cupsBitsPerColor * 4;
- }
+ primary = CUPS_IMAGE_RGB;
+ secondary = CUPS_IMAGE_RGB;
+ }
else
- header.cupsBitsPerPixel = header.cupsBitsPerColor;
+ {
+ primary = CUPS_IMAGE_CMY;
+ secondary = CUPS_IMAGE_CMY;
+ }
break;
case CUPS_CSPACE_K :
case CUPS_CSPACE_SILVER :
primary = CUPS_IMAGE_BLACK;
secondary = CUPS_IMAGE_BLACK;
- header.cupsBitsPerPixel = header.cupsBitsPerColor;
break;
case CUPS_CSPACE_CMYK :
case CUPS_CSPACE_YMCK :
case CUPS_CSPACE_KCMY :
+ case CUPS_CSPACE_KCMYcm :
case CUPS_CSPACE_GMCK :
case CUPS_CSPACE_GMCS :
- primary = CUPS_IMAGE_CMYK;
- secondary = CUPS_IMAGE_CMYK;
-
- if (header.cupsColorOrder == CUPS_ORDER_CHUNKED)
- header.cupsBitsPerPixel = header.cupsBitsPerColor * 4;
- else
- header.cupsBitsPerPixel = header.cupsBitsPerColor;
- break;
-
- case CUPS_CSPACE_CMY :
- case CUPS_CSPACE_YMC :
- primary = CUPS_IMAGE_CMY;
- secondary = CUPS_IMAGE_CMY;
-
- if (header.cupsColorOrder == CUPS_ORDER_CHUNKED)
- {
- if (header.cupsBitsPerColor >= 8)
- header.cupsBitsPerPixel = 24;
- else
- header.cupsBitsPerPixel = header.cupsBitsPerColor * 4;
- }
- else
- header.cupsBitsPerPixel = header.cupsBitsPerColor;
- break;
-
- case CUPS_CSPACE_KCMYcm :
- if (header.cupsBitsPerPixel == 1)
+ if (header.cupsBitsPerColor == 1)
{
primary = CUPS_IMAGE_CMY;
secondary = CUPS_IMAGE_CMY;
-
- if (header.cupsColorOrder == CUPS_ORDER_CHUNKED)
- header.cupsBitsPerPixel = 8;
- else
- header.cupsBitsPerPixel = 1;
}
else
{
primary = CUPS_IMAGE_CMYK;
secondary = CUPS_IMAGE_CMYK;
-
- if (header.cupsColorOrder == CUPS_ORDER_CHUNKED)
- header.cupsBitsPerPixel = header.cupsBitsPerColor * 4;
- else
- header.cupsBitsPerPixel = header.cupsBitsPerColor;
}
break;
+
+ case CUPS_CSPACE_CMY :
+ case CUPS_CSPACE_YMC :
+ primary = CUPS_IMAGE_CMY;
+ secondary = CUPS_IMAGE_CMY;
+ break;
+ break;
}
/*
* Open the input image to print...
*/
- fputs("INFO: Loading image file...\n", stderr);
+ fputs(_("INFO: Loading image file...\n"), stderr);
- img = cupsImageOpen(filename, primary, secondary, sat, hue, lut);
+ if (header.cupsColorSpace == CUPS_CSPACE_CIEXYZ ||
+ header.cupsColorSpace == CUPS_CSPACE_CIELab ||
+ header.cupsColorSpace >= CUPS_CSPACE_ICC1)
+ img = cupsImageOpen(filename, primary, secondary, sat, hue, NULL);
+ else
+ img = cupsImageOpen(filename, primary, secondary, sat, hue, lut);
if (argc == 6)
unlink(filename);
if (img == NULL)
{
- fputs("ERROR: Unable to open image file for printing!\n", stderr);
+ fputs(_("ERROR: Unable to open image file for printing!\n"), stderr);
ppdClose(ppd);
return (1);
}
* Set the new custom size...
*/
- header.PageSize[0] = width + 0.5;
- header.PageSize[1] = length + 0.5;
+ strcpy(header.cupsPageSizeName, "Custom");
+
+ header.cupsPageSize[0] = width + 0.5;
+ header.cupsPageSize[1] = length + 0.5;
+ header.PageSize[0] = width + 0.5;
+ header.PageSize[1] = length + 0.5;
/*
* Update page variables...
header.cupsWidth = width * header.HWResolution[0] / 72.0;
header.cupsHeight = length * header.HWResolution[1] / 72.0;
- }
- else
- {
- header.cupsWidth = (PageRight - PageLeft) * header.HWResolution[0] / 72.0;
- header.cupsHeight = (PageTop - PageBottom) * header.HWResolution[1] / 72.0;
- header.PageSize[0] = PageWidth;
- header.PageSize[1] = PageLength;
+
+ header.cupsBytesPerLine = (header.cupsBitsPerPixel *
+ header.cupsWidth + 7) / 8;
+
+ if (header.cupsColorOrder == CUPS_ORDER_BANDED)
+ header.cupsBytesPerLine *= header.cupsNumColors;
}
header.Margins[0] = PageLeft;
switch (XPosition)
{
case -1 :
- header.ImagingBoundingBox[0] = PageLeft;
- header.ImagingBoundingBox[2] = PageLeft + xprint * 72;
+ header.cupsImagingBBox[0] = PageLeft;
+ header.cupsImagingBBox[2] = PageLeft + xprint * 72;
break;
default :
- header.ImagingBoundingBox[0] = (PageRight + PageLeft - xprint * 72) / 2;
- header.ImagingBoundingBox[2] = (PageRight + PageLeft + xprint * 72) / 2;
+ header.cupsImagingBBox[0] = (PageRight + PageLeft - xprint * 72) / 2;
+ header.cupsImagingBBox[2] = (PageRight + PageLeft + xprint * 72) / 2;
break;
case 1 :
- header.ImagingBoundingBox[0] = PageRight - xprint * 72;
- header.ImagingBoundingBox[2] = PageRight;
+ header.cupsImagingBBox[0] = PageRight - xprint * 72;
+ header.cupsImagingBBox[2] = PageRight;
break;
}
switch (YPosition)
{
case -1 :
- header.ImagingBoundingBox[1] = PageBottom;
- header.ImagingBoundingBox[3] = PageBottom + yprint * 72;
+ header.cupsImagingBBox[1] = PageBottom;
+ header.cupsImagingBBox[3] = PageBottom + yprint * 72;
break;
default :
- header.ImagingBoundingBox[1] = (PageTop + PageBottom - yprint * 72) / 2;
- header.ImagingBoundingBox[3] = (PageTop + PageBottom + yprint * 72) / 2;
+ header.cupsImagingBBox[1] = (PageTop + PageBottom - yprint * 72) / 2;
+ header.cupsImagingBBox[3] = (PageTop + PageBottom + yprint * 72) / 2;
break;
case 1 :
- header.ImagingBoundingBox[1] = PageTop - yprint * 72;
- header.ImagingBoundingBox[3] = PageTop;
+ header.cupsImagingBBox[1] = PageTop - yprint * 72;
+ header.cupsImagingBBox[3] = PageTop;
break;
}
break;
switch (XPosition)
{
case -1 :
- header.ImagingBoundingBox[0] = PageBottom;
- header.ImagingBoundingBox[2] = PageBottom + yprint * 72;
+ header.cupsImagingBBox[0] = PageBottom;
+ header.cupsImagingBBox[2] = PageBottom + yprint * 72;
break;
default :
- header.ImagingBoundingBox[0] = (PageTop + PageBottom - yprint * 72) / 2;
- header.ImagingBoundingBox[2] = (PageTop + PageBottom + yprint * 72) / 2;
+ header.cupsImagingBBox[0] = (PageTop + PageBottom - yprint * 72) / 2;
+ header.cupsImagingBBox[2] = (PageTop + PageBottom + yprint * 72) / 2;
break;
case 1 :
- header.ImagingBoundingBox[0] = PageTop - yprint * 72;
- header.ImagingBoundingBox[2] = PageTop;
+ header.cupsImagingBBox[0] = PageTop - yprint * 72;
+ header.cupsImagingBBox[2] = PageTop;
break;
}
switch (YPosition)
{
case -1 :
- header.ImagingBoundingBox[1] = PageLeft;
- header.ImagingBoundingBox[3] = PageLeft + xprint * 72;
+ header.cupsImagingBBox[1] = PageLeft;
+ header.cupsImagingBBox[3] = PageLeft + xprint * 72;
break;
default :
- header.ImagingBoundingBox[1] = (PageRight + PageLeft - xprint * 72) / 2;
- header.ImagingBoundingBox[3] = (PageRight + PageLeft + xprint * 72) / 2;
+ header.cupsImagingBBox[1] = (PageRight + PageLeft - xprint * 72) / 2;
+ header.cupsImagingBBox[3] = (PageRight + PageLeft + xprint * 72) / 2;
break;
case 1 :
- header.ImagingBoundingBox[1] = PageRight - xprint * 72;
- header.ImagingBoundingBox[3] = PageRight;
+ header.cupsImagingBBox[1] = PageRight - xprint * 72;
+ header.cupsImagingBBox[3] = PageRight;
break;
}
break;
switch (XPosition)
{
case 1 :
- header.ImagingBoundingBox[0] = PageLeft;
- header.ImagingBoundingBox[2] = PageLeft + xprint * 72;
+ header.cupsImagingBBox[0] = PageLeft;
+ header.cupsImagingBBox[2] = PageLeft + xprint * 72;
break;
default :
- header.ImagingBoundingBox[0] = (PageRight + PageLeft - xprint * 72) / 2;
- header.ImagingBoundingBox[2] = (PageRight + PageLeft + xprint * 72) / 2;
+ header.cupsImagingBBox[0] = (PageRight + PageLeft - xprint * 72) / 2;
+ header.cupsImagingBBox[2] = (PageRight + PageLeft + xprint * 72) / 2;
break;
case -1 :
- header.ImagingBoundingBox[0] = PageRight - xprint * 72;
- header.ImagingBoundingBox[2] = PageRight;
+ header.cupsImagingBBox[0] = PageRight - xprint * 72;
+ header.cupsImagingBBox[2] = PageRight;
break;
}
switch (YPosition)
{
case 1 :
- header.ImagingBoundingBox[1] = PageBottom;
- header.ImagingBoundingBox[3] = PageBottom + yprint * 72;
+ header.cupsImagingBBox[1] = PageBottom;
+ header.cupsImagingBBox[3] = PageBottom + yprint * 72;
break;
default :
- header.ImagingBoundingBox[1] = (PageTop + PageBottom - yprint * 72) / 2;
- header.ImagingBoundingBox[3] = (PageTop + PageBottom + yprint * 72) / 2;
+ header.cupsImagingBBox[1] = (PageTop + PageBottom - yprint * 72) / 2;
+ header.cupsImagingBBox[3] = (PageTop + PageBottom + yprint * 72) / 2;
break;
case -1 :
- header.ImagingBoundingBox[1] = PageTop - yprint * 72;
- header.ImagingBoundingBox[3] = PageTop;
+ header.cupsImagingBBox[1] = PageTop - yprint * 72;
+ header.cupsImagingBBox[3] = PageTop;
break;
}
break;
switch (XPosition)
{
case 1 :
- header.ImagingBoundingBox[0] = PageBottom;
- header.ImagingBoundingBox[2] = PageBottom + yprint * 72;
+ header.cupsImagingBBox[0] = PageBottom;
+ header.cupsImagingBBox[2] = PageBottom + yprint * 72;
break;
default :
- header.ImagingBoundingBox[0] = (PageTop + PageBottom - yprint * 72) / 2;
- header.ImagingBoundingBox[2] = (PageTop + PageBottom + yprint * 72) / 2;
+ header.cupsImagingBBox[0] = (PageTop + PageBottom - yprint * 72) / 2;
+ header.cupsImagingBBox[2] = (PageTop + PageBottom + yprint * 72) / 2;
break;
case -1 :
- header.ImagingBoundingBox[0] = PageTop - yprint * 72;
- header.ImagingBoundingBox[2] = PageTop;
+ header.cupsImagingBBox[0] = PageTop - yprint * 72;
+ header.cupsImagingBBox[2] = PageTop;
break;
}
switch (YPosition)
{
case 1 :
- header.ImagingBoundingBox[1] = PageLeft;
- header.ImagingBoundingBox[3] = PageLeft + xprint * 72;
+ header.cupsImagingBBox[1] = PageLeft;
+ header.cupsImagingBBox[3] = PageLeft + xprint * 72;
break;
default :
- header.ImagingBoundingBox[1] = (PageRight + PageLeft - xprint * 72) / 2;
- header.ImagingBoundingBox[3] = (PageRight + PageLeft + xprint * 72) / 2;
+ header.cupsImagingBBox[1] = (PageRight + PageLeft - xprint * 72) / 2;
+ header.cupsImagingBBox[3] = (PageRight + PageLeft + xprint * 72) / 2;
break;
case -1 :
- header.ImagingBoundingBox[1] = PageRight - xprint * 72;
- header.ImagingBoundingBox[3] = PageRight;
+ header.cupsImagingBBox[1] = PageRight - xprint * 72;
+ header.cupsImagingBBox[3] = PageRight;
break;
}
break;
}
- switch (header.cupsColorOrder)
- {
- default :
- header.cupsBytesPerLine = (header.cupsBitsPerPixel *
- header.cupsWidth + 7) / 8;
- num_planes = 1;
- break;
-
- case CUPS_ORDER_BANDED :
- if (header.cupsColorSpace == CUPS_CSPACE_KCMYcm &&
- header.cupsBitsPerColor > 1)
- header.cupsBytesPerLine = (header.cupsBitsPerPixel *
- header.cupsWidth + 7) / 8 * 4;
- else
- header.cupsBytesPerLine = (header.cupsBitsPerPixel *
- header.cupsWidth + 7) / 8 *
- Planes[header.cupsColorSpace];
- num_planes = 1;
- break;
+ header.ImagingBoundingBox[0] = header.cupsImagingBBox[0];
+ header.ImagingBoundingBox[1] = header.cupsImagingBBox[1];
+ header.ImagingBoundingBox[2] = header.cupsImagingBBox[2];
+ header.ImagingBoundingBox[3] = header.cupsImagingBBox[3];
- case CUPS_ORDER_PLANAR :
- header.cupsBytesPerLine = (header.cupsBitsPerPixel *
- header.cupsWidth + 7) / 8;
- num_planes = Planes[header.cupsColorSpace];
- break;
- }
+ if (header.cupsColorOrder == CUPS_ORDER_PLANAR)
+ num_planes = header.cupsNumColors;
+ else
+ num_planes = 1;
- if (header.cupsBitsPerColor >= 8)
- zoom_type = CUPS_IZOOM_NORMAL;
- else
- zoom_type = CUPS_IZOOM_FAST;
+ if (header.cupsBitsPerColor >= 8)
+ zoom_type = CUPS_IZOOM_NORMAL;
+ else
+ zoom_type = CUPS_IZOOM_FAST;
/*
* See if we need to collate, and if so how we need to do it...
OnPixels[i] = 17 * (i / 17 + 1);
OffPixels[i] = 17 * (i / 16);
}
-
- OnPixels[255] = OffPixels[255] = 0xff;
break;
}
fprintf(stderr, "DEBUG: cupsColorSpace = %d\n", header.cupsColorSpace);
fprintf(stderr, "DEBUG: img->colorspace = %d\n", img->colorspace);
- row = malloc(2 * header.cupsBytesPerLine);
- ras = cupsRasterOpen(1, CUPS_RASTER_WRITE);
- blank = img->colorspace < 0 ? 0 : ~0;
+ row = malloc(2 * header.cupsBytesPerLine);
+ ras = cupsRasterOpen(1, CUPS_RASTER_WRITE);
for (i = 0, page = 1; i < Copies; i ++)
for (xpage = 0; xpage < xpages; xpage ++)
for (ypage = 0; ypage < ypages; ypage ++, page ++)
{
- fprintf(stderr, "INFO: Formatting page %d...\n", page);
+ fprintf(stderr, _("INFO: Formatting page %d...\n"), page);
if (Orientation & 1)
{
if (Flip)
z = _cupsImageZoomNew(img, xc0, yc0, xc1, yc1, -xtemp, ytemp,
- Orientation & 1, zoom_type);
+ Orientation & 1, zoom_type);
else
z = _cupsImageZoomNew(img, xc0, yc0, xc1, yc1, xtemp, ytemp,
- Orientation & 1, zoom_type);
+ Orientation & 1, zoom_type);
/*
* Write leading blank space as needed...
if (header.cupsHeight > z->ysize && YPosition <= 0)
{
- memset(row, blank, header.cupsBytesPerLine);
+ blank_line(&header, row);
y = header.cupsHeight - z->ysize;
if (YPosition == 0)
y /= 2;
+ fprintf(stderr, "DEBUG: Writing %d leading blank lines...\n", y);
+
for (; y > 0; y --)
{
if (cupsRasterWritePixels(ras, row, header.cupsBytesPerLine) <
header.cupsBytesPerLine)
{
- fputs("ERROR: Unable to write raster data to driver!\n", stderr);
+ fputs(_("ERROR: Unable to write raster data to driver!\n"),
+ stderr);
cupsImageClose(img);
exit(1);
}
* Format this line of raster data for the printer...
*/
- memset(row, blank, header.cupsBytesPerLine);
+ blank_line(&header, row);
r0 = z->rows[z->row];
r1 = z->rows[1 - z->row];
format_YMCK(&header, row, y, plane, z->xsize, z->ysize,
yerr0, yerr1, r0, r1);
break;
+ case CUPS_CSPACE_KCMYcm :
+ if (header.cupsBitsPerColor == 1)
+ {
+ format_KCMYcm(&header, row, y, plane, z->xsize, z->ysize,
+ yerr0, yerr1, r0, r1);
+ break;
+ }
case CUPS_CSPACE_KCMY :
format_KCMY(&header, row, y, plane, z->xsize, z->ysize,
yerr0, yerr1, r0, r1);
break;
- case CUPS_CSPACE_KCMYcm :
- format_KCMYcm(&header, row, y, plane, z->xsize, z->ysize,
- yerr0, yerr1, r0, r1);
- break;
}
/*
if (cupsRasterWritePixels(ras, row, header.cupsBytesPerLine) <
header.cupsBytesPerLine)
{
- fputs("ERROR: Unable to write raster data to driver!\n", stderr);
+ fputs(_("ERROR: Unable to write raster data to driver!\n"),
+ stderr);
cupsImageClose(img);
exit(1);
}
if (header.cupsHeight > z->ysize && YPosition >= 0)
{
- memset(row, blank, header.cupsBytesPerLine);
+ blank_line(&header, row);
y = header.cupsHeight - z->ysize;
if (YPosition == 0)
y = y - y / 2;
+ fprintf(stderr, "DEBUG: Writing %d trailing blank lines...\n", y);
+
for (; y > 0; y --)
{
if (cupsRasterWritePixels(ras, row, header.cupsBytesPerLine) <
header.cupsBytesPerLine)
{
- fputs("ERROR: Unable to write raster data to driver!\n", stderr);
+ fputs(_("ERROR: Unable to write raster data to driver!\n"),
+ stderr);
cupsImageClose(img);
exit(1);
}
/*
- * 'exec_code()' - Execute PostScript setpagedevice commands as appropriate.
+ * 'blank_line()' - Clear a line buffer to the blank value...
*/
static void
-exec_code(cups_page_header2_t *header, /* I - Page header */
- const char *code) /* I - Option choice to execute */
+blank_line(cups_page_header2_t *header, /* I - Page header */
+ unsigned char *row) /* I - Row buffer */
{
- char *ptr, /* Pointer into name/value string */
- name[255], /* Name of pagedevice entry */
- value[1024]; /* Value of pagedevice entry */
-
-
- for (; *code != '\0';)
- {
- /*
- * Search for the start of a dictionary name...
- */
-
- while (*code != '/' && *code != '\0')
- code ++;
-
- if (*code == '\0')
- break;
-
- /*
- * Get the name...
- */
-
- code ++;
- for (ptr = name; isalnum(*code & 255) && (ptr - name) < (sizeof(name) - 1);)
- *ptr++ = *code++;
- *ptr = '\0';
-
- /*
- * The parse the value as needed...
- */
-
- while (isspace(*code & 255))
- code ++;
-
- if (*code == '\0')
- break;
+ int count; /* Remaining bytes */
- if (*code == '[')
- {
- /*
- * Read array of values...
- */
- code ++;
- for (ptr = value;
- *code != ']' && *code != '\0' &&
- (ptr - value) < (sizeof(value) - 1);)
- *ptr++ = *code++;
- *ptr = '\0';
- }
- else if (*code == '(')
- {
- /*
- * Read string value...
- */
+ count = header->cupsBytesPerLine;
- code ++;
- for (ptr = value;
- *code != ')' && *code != '\0' &&
- (ptr - value) < (sizeof(value) - 1);)
- if (*code == '\\')
+ switch (header->cupsColorSpace)
+ {
+ case CUPS_CSPACE_CIEXYZ :
+ while (count > 2)
{
- code ++;
- if (isdigit(*code & 255))
- *ptr++ = (char)strtol(code, (char **)&code, 8);
- else
- *ptr++ = *code++;
+ *row++ = 242;
+ *row++ = 255;
+ *row++ = 255;
+ count -= 3;
}
- else
- *ptr++ = *code++;
-
- *ptr = '\0';
- }
- else if (isdigit(*code & 255) || *code == '-')
- {
- /*
- * Read single number...
- */
-
- for (ptr = value;
- (isdigit(*code & 255) || *code == '-') &&
- (ptr - value) < (sizeof(value) - 1);)
- *ptr++ = *code++;
- *ptr = '\0';
- }
- else
- {
- /*
- * Read a single name...
- */
+ break;
- for (ptr = value;
- (isalnum(*code & 255) || *code == '_') &&
- (ptr - value) < (sizeof(value) - 1);)
- *ptr++ = *code++;
- *ptr = '\0';
- }
+ 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 :
+ while (count > 2)
+ {
+ *row++ = 255;
+ *row++ = 128;
+ *row++ = 128;
+ count -= 3;
+ }
+ break;
- /*
- * Assign the value as needed...
- */
+ case CUPS_CSPACE_K :
+ case CUPS_CSPACE_CMY :
+ case CUPS_CSPACE_CMYK :
+ case CUPS_CSPACE_YMC :
+ case CUPS_CSPACE_YMCK :
+ case CUPS_CSPACE_KCMY :
+ case CUPS_CSPACE_KCMYcm :
+ case CUPS_CSPACE_GMCK :
+ case CUPS_CSPACE_GMCS :
+ case CUPS_CSPACE_WHITE :
+ case CUPS_CSPACE_GOLD :
+ case CUPS_CSPACE_SILVER :
+ memset(row, 0, count);
+ break;
- if (!strcmp(name, "MediaClass"))
- strlcpy(header->MediaClass, value, sizeof(header->MediaClass));
- else if (!strcmp(name, "MediaColor"))
- strlcpy(header->MediaColor, value, sizeof(header->MediaColor));
- else if (!strcmp(name, "MediaType"))
- strlcpy(header->MediaType, value, sizeof(header->MediaType));
- else if (!strcmp(name, "OutputType"))
- strlcpy(header->OutputType, value, sizeof(header->OutputType));
- else if (!strcmp(name, "AdvanceDistance"))
- header->AdvanceDistance = atoi(value);
- else if (!strcmp(name, "AdvanceMedia"))
- header->AdvanceMedia = atoi(value);
- else if (!strcmp(name, "Collate"))
- header->Collate = !strcmp(value, "true");
- else if (!strcmp(name, "CutMedia"))
- header->CutMedia = (cups_cut_t)atoi(value);
- else if (!strcmp(name, "Duplex"))
- header->Duplex = !strcmp(value, "true");
- else if (!strcmp(name, "HWResolution"))
- sscanf(value, "%d%d", header->HWResolution + 0, header->HWResolution + 1);
- else if (!strcmp(name, "InsertSheet"))
- header->InsertSheet = !strcmp(value, "true");
- else if (!strcmp(name, "Jog"))
- header->Jog = atoi(value);
- else if (!strcmp(name, "LeadingEdge"))
- header->LeadingEdge = atoi(value);
- else if (!strcmp(name, "Margins"))
- sscanf(value, "%d%d", header->Margins + 0, header->Margins + 1);
- else if (!strcmp(name, "ManualFeed"))
- header->ManualFeed = !strcmp(value, "true");
- else if (!strcmp(name, "cupsMediaPosition") || /* Compatibility */
- !strcmp(name, "MediaPosition"))
- header->MediaPosition = atoi(value);
- else if (!strcmp(name, "MediaWeight"))
- header->MediaWeight = atoi(value);
- else if (!strcmp(name, "MirrorPrint"))
- header->MirrorPrint = !strcmp(value, "true");
- else if (!strcmp(name, "NegativePrint"))
- header->NegativePrint = !strcmp(value, "true");
- else if (!strcmp(name, "Orientation"))
- header->Orientation = atoi(value);
- else if (!strcmp(name, "OutputFaceUp"))
- header->OutputFaceUp = !strcmp(value, "true");
- else if (!strcmp(name, "Separations"))
- header->Separations = !strcmp(value, "true");
- else if (!strcmp(name, "TraySwitch"))
- header->TraySwitch = !strcmp(value, "true");
- else if (!strcmp(name, "Tumble"))
- header->Tumble = !strcmp(value, "true");
- else if (!strcmp(name, "cupsMediaType"))
- header->cupsMediaType = atoi(value);
- else if (!strcmp(name, "cupsBitsPerColor"))
- header->cupsBitsPerColor = atoi(value);
- else if (!strcmp(name, "cupsColorOrder"))
- header->cupsColorOrder = (cups_order_t)atoi(value);
- else if (!strcmp(name, "cupsColorSpace"))
- header->cupsColorSpace = (cups_cspace_t)atoi(value);
- else if (!strcmp(name, "cupsCompression"))
- header->cupsCompression = atoi(value);
- else if (!strcmp(name, "cupsRowCount"))
- header->cupsRowCount = atoi(value);
- else if (!strcmp(name, "cupsRowFeed"))
- header->cupsRowFeed = atoi(value);
- else if (!strcmp(name, "cupsRowStep"))
- header->cupsRowStep = atoi(value);
+ default :
+ memset(row, 255, count);
+ break;
}
}
int ysize, /* I - Height of image data */
int yerr0, /* I - Top Y error */
int yerr1, /* I - Bottom Y error */
- cups_ib_t *r0, /* I - Primary image data */
- cups_ib_t *r1) /* I - Image data for interpolation */
+ cups_ib_t *r0, /* I - Primary image data */
+ cups_ib_t *r1) /* I - Image data for interpolation */
{
- cups_ib_t *ptr, /* Pointer into row */
- *cptr, /* Pointer into cyan */
- *mptr, /* Pointer into magenta */
- *yptr, /* Pointer into yellow */
- bitmask; /* Current mask for pixel */
- int bitoffset; /* Current offset in line */
- int bandwidth; /* Width of a color band */
- int x, /* Current X coordinate on page */
- *dither; /* Pointer into dither array */
+ cups_ib_t *ptr, /* Pointer into row */
+ *cptr, /* Pointer into cyan */
+ *mptr, /* Pointer into magenta */
+ *yptr, /* Pointer into yellow */
+ bitmask; /* Current mask for pixel */
+ int bitoffset; /* Current offset in line */
+ int bandwidth; /* Width of a color band */
+ int x, /* Current X coordinate on page */
+ *dither; /* Pointer into dither array */
switch (XPosition)
{
case 1 :
bitmask = 64 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
+ dither = Floyd16x16[y & 15];
for (x = xsize ; x > 0; x --)
{
{
case 1 :
bitmask = 0x80 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
+ dither = Floyd16x16[y & 15];
for (x = xsize; x > 0; x --)
{
break;
case 2 :
- bitmask = 0x0 >> (bitoffset & 7);
+ bitmask = 0xc0 >> (bitoffset & 7);
dither = Floyd8x8[y & 7];
for (x = xsize; x > 0; x --)
bitmask >>= 2;
else
{
- bitmask = 0x0;
+ bitmask = 0xc0;
cptr ++;
mptr ++;
{
case 1 :
bitmask = 0x80 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
+ dither = Floyd16x16[y & 15];
switch (z)
{
break;
case 2 :
- bitmask = 0x0 >> (bitoffset & 7);
+ bitmask = 0xc0 >> (bitoffset & 7);
dither = Floyd8x8[y & 7];
r0 += z;
bitmask >>= 2;
else
{
- bitmask = 0x0;
+ bitmask = 0xc0;
ptr ++;
}
*/
static void
-format_CMYK(cups_page_header2_t *header, /* I - Page header */
+format_CMYK(cups_page_header2_t *header,/* I - Page header */
unsigned char *row, /* IO - Bitmap data for device */
int y, /* I - Current row */
int z, /* I - Current plane */
int ysize, /* I - Height of image data */
int yerr0, /* I - Top Y error */
int yerr1, /* I - Bottom Y error */
- cups_ib_t *r0, /* I - Primary image data */
- cups_ib_t *r1) /* I - Image data for interpolation */
+ cups_ib_t *r0, /* I - Primary image data */
+ cups_ib_t *r1) /* I - Image data for interpolation */
{
- cups_ib_t *ptr, /* Pointer into row */
- *cptr, /* Pointer into cyan */
- *mptr, /* Pointer into magenta */
- *yptr, /* Pointer into yellow */
- *kptr, /* Pointer into black */
- bitmask; /* Current mask for pixel */
- int bitoffset; /* Current offset in line */
- int bandwidth; /* Width of a color band */
- int x, /* Current X coordinate on page */
- *dither; /* Pointer into dither array */
+ cups_ib_t *ptr, /* Pointer into row */
+ *cptr, /* Pointer into cyan */
+ *mptr, /* Pointer into magenta */
+ *yptr, /* Pointer into yellow */
+ *kptr, /* Pointer into black */
+ bitmask; /* Current mask for pixel */
+ int bitoffset; /* Current offset in line */
+ int bandwidth; /* Width of a color band */
+ int x, /* Current X coordinate on page */
+ *dither; /* Pointer into dither array */
+ int pc, pm, py; /* CMY pixels */
switch (XPosition)
{
case 1 :
bitmask = 128 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
+ dither = Floyd16x16[y & 15];
for (x = xsize ; x > 0; x --)
{
- if (*r0++ > dither[x & 15])
- *ptr ^= bitmask;
- bitmask >>= 1;
+ pc = *r0++ > dither[x & 15];
+ pm = *r0++ > dither[x & 15];
+ py = *r0++ > dither[x & 15];
- if (*r0++ > dither[x & 15])
+ if (pc && pm && py)
+ {
+ bitmask >>= 3;
*ptr ^= bitmask;
- bitmask >>= 1;
+ }
+ else
+ {
+ if (pc)
+ *ptr ^= bitmask;
+ bitmask >>= 1;
- if (*r0++ > dither[x & 15])
- *ptr ^= bitmask;
- bitmask >>= 1;
+ if (pm)
+ *ptr ^= bitmask;
+ bitmask >>= 1;
- if (*r0++ > dither[x & 15])
- *ptr ^= bitmask;
+ if (py)
+ *ptr ^= bitmask;
+ bitmask >>= 1;
+ }
if (bitmask > 1)
bitmask >>= 1;
for (x = xsize ; x > 0; x --, r0 += 4)
{
if ((r0[0] & 63) > dither[x & 7])
- *ptr ^= (0x0 & OnPixels[r0[0]]);
+ *ptr ^= (0xc0 & OnPixels[r0[0]]);
else
- *ptr ^= (0x0 & OffPixels[r0[0]]);
+ *ptr ^= (0xc0 & OffPixels[r0[0]]);
if ((r0[1] & 63) > dither[x & 7])
*ptr ^= (0x30 & OnPixels[r0[1]]);
{
case 1 :
bitmask = 0x80 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
+ dither = Floyd16x16[y & 15];
for (x = xsize; x > 0; x --)
{
- if (*r0++ > dither[x & 15])
- *cptr ^= bitmask;
- if (*r0++ > dither[x & 15])
- *mptr ^= bitmask;
- if (*r0++ > dither[x & 15])
- *yptr ^= bitmask;
- if (*r0++ > dither[x & 15])
- *kptr ^= bitmask;
+ pc = *r0++ > dither[x & 15];
+ pm = *r0++ > dither[x & 15];
+ py = *r0++ > dither[x & 15];
+
+ if (pc && pm && py)
+ *kptr ^= bitmask;
+ else
+ {
+ if (pc)
+ *cptr ^= bitmask;
+ if (pm)
+ *mptr ^= bitmask;
+ if (py)
+ *yptr ^= bitmask;
+ }
if (bitmask > 1)
bitmask >>= 1;
break;
case 2 :
- bitmask = 0x0 >> (bitoffset & 7);
+ bitmask = 0xc0 >> (bitoffset & 7);
dither = Floyd8x8[y & 7];
for (x = xsize; x > 0; x --)
bitmask >>= 2;
else
{
- bitmask = 0x0;
+ bitmask = 0xc0;
cptr ++;
mptr ++;
{
case 1 :
bitmask = 0x80 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
- r0 += z;
+ dither = Floyd16x16[y & 15];
- for (x = xsize; x > 0; x --, r0 += 4)
+ for (x = xsize; x > 0; x --)
{
- if (*r0 > dither[x & 15])
+ pc = *r0++ > dither[x & 15];
+ pm = *r0++ > dither[x & 15];
+ py = *r0++ > dither[x & 15];
+
+ if ((pc && pm && py && z == 3) ||
+ (pc && z == 0) || (pm && z == 1) || (py && z == 2))
*ptr ^= bitmask;
if (bitmask > 1)
break;
case 2 :
- bitmask = 0x0 >> (bitoffset & 7);
+ bitmask = 0xc0 >> (bitoffset & 7);
dither = Floyd8x8[y & 7];
r0 += z;
bitmask >>= 2;
else
{
- bitmask = 0x0;
+ bitmask = 0xc0;
ptr ++;
}
int ysize, /* I - Height of image data */
int yerr0, /* I - Top Y error */
int yerr1, /* I - Bottom Y error */
- cups_ib_t *r0, /* I - Primary image data */
- cups_ib_t *r1) /* I - Image data for interpolation */
+ cups_ib_t *r0, /* I - Primary image data */
+ cups_ib_t *r1) /* I - Image data for interpolation */
{
- cups_ib_t *ptr, /* Pointer into row */
- bitmask; /* Current mask for pixel */
- int bitoffset; /* Current offset in line */
- int x, /* Current X coordinate on page */
- *dither; /* Pointer into dither array */
+ cups_ib_t *ptr, /* Pointer into row */
+ bitmask; /* Current mask for pixel */
+ int bitoffset; /* Current offset in line */
+ int x, /* Current X coordinate on page */
+ *dither; /* Pointer into dither array */
(void)z;
{
case 1 :
bitmask = 0x80 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
+ dither = Floyd16x16[y & 15];
for (x = xsize; x > 0; x --)
{
break;
case 2 :
- bitmask = 0x0 >> (bitoffset & 7);
+ bitmask = 0xc0 >> (bitoffset & 7);
dither = Floyd8x8[y & 7];
for (x = xsize; x > 0; x --)
bitmask >>= 2;
else
{
- bitmask = 0x0;
+ bitmask = 0xc0;
ptr ++;
}
*/
static void
-format_KCMY(cups_page_header2_t *header, /* I - Page header */
+format_KCMY(cups_page_header2_t *header,/* I - Page header */
unsigned char *row, /* IO - Bitmap data for device */
int y, /* I - Current row */
int z, /* I - Current plane */
int ysize, /* I - Height of image data */
int yerr0, /* I - Top Y error */
int yerr1, /* I - Bottom Y error */
- cups_ib_t *r0, /* I - Primary image data */
- cups_ib_t *r1) /* I - Image data for interpolation */
+ cups_ib_t *r0, /* I - Primary image data */
+ cups_ib_t *r1) /* I - Image data for interpolation */
{
- cups_ib_t *ptr, /* Pointer into row */
- *cptr, /* Pointer into cyan */
- *mptr, /* Pointer into magenta */
- *yptr, /* Pointer into yellow */
- *kptr, /* Pointer into black */
- bitmask; /* Current mask for pixel */
- int bitoffset; /* Current offset in line */
- int bandwidth; /* Width of a color band */
- int x, /* Current X coordinate on page */
- *dither; /* Pointer into dither array */
+ cups_ib_t *ptr, /* Pointer into row */
+ *cptr, /* Pointer into cyan */
+ *mptr, /* Pointer into magenta */
+ *yptr, /* Pointer into yellow */
+ *kptr, /* Pointer into black */
+ bitmask; /* Current mask for pixel */
+ int bitoffset; /* Current offset in line */
+ int bandwidth; /* Width of a color band */
+ int x, /* Current X coordinate on page */
+ *dither; /* Pointer into dither array */
+ int pc, pm, py; /* CMY pixels */
switch (XPosition)
{
case 1 :
bitmask = 128 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
+ dither = Floyd16x16[y & 15];
- for (x = xsize ; x > 0; x --, r0 += 4)
+ for (x = xsize ; x > 0; x --)
{
- if (r0[3] > dither[x & 15])
- *ptr ^= bitmask;
- bitmask >>= 1;
+ pc = *r0++ > dither[x & 15];
+ pm = *r0++ > dither[x & 15];
+ py = *r0++ > dither[x & 15];
- if (r0[0] > dither[x & 15])
+ if (pc && pm && py)
+ {
*ptr ^= bitmask;
- bitmask >>= 1;
+ bitmask >>= 3;
+ }
+ else
+ {
+ bitmask >>= 1;
+ if (pc)
+ *ptr ^= bitmask;
- if (r0[1] > dither[x & 15])
- *ptr ^= bitmask;
- bitmask >>= 1;
+ bitmask >>= 1;
+ if (pm)
+ *ptr ^= bitmask;
- if (r0[2] > dither[x & 15])
- *ptr ^= bitmask;
+ bitmask >>= 1;
+ if (py)
+ *ptr ^= bitmask;
+ }
if (bitmask > 1)
bitmask >>= 1;
for (x = xsize ; x > 0; x --, r0 += 4)
{
if ((r0[3] & 63) > dither[x & 7])
- *ptr ^= (0x0 & OnPixels[r0[3]]);
+ *ptr ^= (0xc0 & OnPixels[r0[3]]);
else
- *ptr ^= (0x0 & OffPixels[r0[3]]);
+ *ptr ^= (0xc0 & OffPixels[r0[3]]);
if ((r0[0] & 63) > dither[x & 7])
*ptr ^= (0x30 & OnPixels[r0[0]]);
{
case 1 :
bitmask = 0x80 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
+ dither = Floyd16x16[y & 15];
for (x = xsize; x > 0; x --)
{
- if (*r0++ > dither[x & 15])
- *cptr ^= bitmask;
- if (*r0++ > dither[x & 15])
- *mptr ^= bitmask;
- if (*r0++ > dither[x & 15])
- *yptr ^= bitmask;
- if (*r0++ > dither[x & 15])
- *kptr ^= bitmask;
+ pc = *r0++ > dither[x & 15];
+ pm = *r0++ > dither[x & 15];
+ py = *r0++ > dither[x & 15];
+
+ if (pc && pm && py)
+ *kptr ^= bitmask;
+ else
+ {
+ if (pc)
+ *cptr ^= bitmask;
+ if (pm)
+ *mptr ^= bitmask;
+ if (py)
+ *yptr ^= bitmask;
+ }
if (bitmask > 1)
bitmask >>= 1;
break;
case 2 :
- bitmask = 0x0 >> (bitoffset & 7);
+ bitmask = 0xc0 >> (bitoffset & 7);
dither = Floyd8x8[y & 7];
for (x = xsize; x > 0; x --)
bitmask >>= 2;
else
{
- bitmask = 0x0;
+ bitmask = 0xc0;
cptr ++;
mptr ++;
{
case 1 :
bitmask = 0x80 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
- if (z == 0)
- r0 += 3;
- else
- r0 += z - 1;
+ dither = Floyd16x16[y & 15];
- for (x = xsize; x > 0; x --, r0 += 4)
+ for (x = xsize; x > 0; x --)
{
- if (*r0 > dither[x & 15])
+ pc = *r0++ > dither[x & 15];
+ pm = *r0++ > dither[x & 15];
+ py = *r0++ > dither[x & 15];
+
+ if ((pc && pm && py && z == 0) ||
+ (pc && z == 1) || (pm && z == 2) || (py && z == 3))
*ptr ^= bitmask;
if (bitmask > 1)
break;
case 2 :
- bitmask = 0x0 >> (bitoffset & 7);
+ bitmask = 0xc0 >> (bitoffset & 7);
dither = Floyd8x8[y & 7];
if (z == 0)
r0 += 3;
bitmask >>= 2;
else
{
- bitmask = 0x0;
+ bitmask = 0xc0;
ptr ++;
}
*/
static void
-format_KCMYcm(cups_page_header2_t *header,/* I - Page header */
- unsigned char *row, /* IO - Bitmap data for device */
- int y, /* I - Current row */
- int z, /* I - Current plane */
- int xsize,/* I - Width of image data */
- int ysize,/* I - Height of image data */
- int yerr0,/* I - Top Y error */
- int yerr1,/* I - Bottom Y error */
- cups_ib_t *r0, /* I - Primary image data */
- cups_ib_t *r1) /* I - Image data for interpolation */
+format_KCMYcm(
+ cups_page_header2_t *header, /* I - Page header */
+ unsigned char *row, /* IO - Bitmap data for device */
+ int y, /* I - Current row */
+ int z, /* I - Current plane */
+ int xsize, /* I - Width of image data */
+ int ysize, /* I - Height of image data */
+ int yerr0, /* I - Top Y error */
+ int yerr1, /* I - Bottom Y error */
+ cups_ib_t *r0, /* I - Primary image data */
+ cups_ib_t *r1) /* I - Image data for interpolation */
{
- int pc, pm, py, pk; /* Cyan, magenta, yellow, and black values */
- cups_ib_t *ptr, /* Pointer into row */
- *cptr, /* Pointer into cyan */
- *mptr, /* Pointer into magenta */
- *yptr, /* Pointer into yellow */
- *kptr, /* Pointer into black */
- *lcptr, /* Pointer into light cyan */
- *lmptr, /* Pointer into light magenta */
- bitmask; /* Current mask for pixel */
- int bitoffset; /* Current offset in line */
- int bandwidth; /* Width of a color band */
- int x, /* Current X coordinate on page */
- *dither; /* Pointer into dither array */
+ int pc, pm, py, pk; /* Cyan, magenta, yellow, and black values */
+ cups_ib_t *ptr, /* Pointer into row */
+ *cptr, /* Pointer into cyan */
+ *mptr, /* Pointer into magenta */
+ *yptr, /* Pointer into yellow */
+ *kptr, /* Pointer into black */
+ *lcptr, /* Pointer into light cyan */
+ *lmptr, /* Pointer into light magenta */
+ bitmask; /* Current mask for pixel */
+ int bitoffset; /* Current offset in line */
+ int bandwidth; /* Width of a color band */
+ int x, /* Current X coordinate on page */
+ *dither; /* Pointer into dither array */
switch (XPosition)
break;
}
- ptr = row + bitoffset / 8;
- if (header->cupsBitsPerColor == 1)
- bandwidth = header->cupsBytesPerLine / 6;
- else
- bandwidth = header->cupsBytesPerLine / 4;
+ ptr = row + bitoffset / 8;
+ bandwidth = header->cupsBytesPerLine / 6;
switch (header->cupsColorOrder)
{
case CUPS_ORDER_CHUNKED :
- switch (header->cupsBitsPerColor)
+ dither = Floyd16x16[y & 15];
+
+ for (x = xsize ; x > 0; x --)
{
- case 1 :
- dither = Floyd16xc16[y & 15];
+ pc = *r0++ > dither[x & 15];
+ pm = *r0++ > dither[x & 15];
+ py = *r0++ > dither[x & 15];
+ pk = pc && pm && py;
+
+ if (pk)
+ *ptr++ ^= 32; /* Black */
+ else if (pc && pm)
+ *ptr++ ^= 17; /* Blue (cyan + light magenta) */
+ else if (pc && py)
+ *ptr++ ^= 6; /* Green (light cyan + yellow) */
+ else if (pm && py)
+ *ptr++ ^= 12; /* Red (magenta + yellow) */
+ else if (pc)
+ *ptr++ ^= 16;
+ else if (pm)
+ *ptr++ ^= 8;
+ else if (py)
+ *ptr++ ^= 4;
+ else
+ ptr ++;
+ }
+ break;
- for (x = xsize ; x > 0; x --)
- {
- pc = *r0++ > dither[x & 15];
- pm = *r0++ > dither[x & 15];
- py = *r0++ > dither[x & 15];
- pk = *r0++ > dither[x & 15];
-
- if (pk)
- *ptr++ ^= 32; /* Black */
- else if (pc && pm)
- *ptr++ ^= 17; /* Blue (cyan + light magenta) */
- else if (pc && py)
- *ptr++ ^= 6; /* Green (light cyan + yellow) */
- else if (pm && py)
- *ptr++ ^= 12; /* Red (magenta + yellow) */
- else if (pc)
- *ptr++ ^= 16;
- else if (pm)
- *ptr++ ^= 8;
- else if (py)
- *ptr++ ^= 4;
- }
- break;
+ case CUPS_ORDER_BANDED :
+ kptr = ptr;
+ cptr = ptr + bandwidth;
+ mptr = ptr + 2 * bandwidth;
+ yptr = ptr + 3 * bandwidth;
+ lcptr = ptr + 4 * bandwidth;
+ lmptr = ptr + 5 * bandwidth;
- case 8 :
- for (x = xsize; x > 0; x --, r0 += 4, r1 += 4)
- {
- if (r0[3] == r1[3])
- *ptr++ = r0[3];
- else
- *ptr++ = (r0[3] * yerr0 + r1[3] * yerr1) / ysize;
-
- if (r0[0] == r1[0])
- *ptr++ = r0[0];
- else
- *ptr++ = (r0[0] * yerr0 + r1[0] * yerr1) / ysize;
-
- if (r0[1] == r1[1])
- *ptr++ = r0[1];
- else
- *ptr++ = (r0[1] * yerr0 + r1[1] * yerr1) / ysize;
-
- if (r0[2] == r1[2])
- *ptr++ = r0[2];
- else
- *ptr++ = (r0[2] * yerr0 + r1[2] * yerr1) / ysize;
- }
- break;
- }
- break;
-
- case CUPS_ORDER_BANDED :
- kptr = ptr;
- cptr = ptr + bandwidth;
- mptr = ptr + 2 * bandwidth;
- yptr = ptr + 3 * bandwidth;
- lcptr = ptr + 4 * bandwidth;
- lmptr = ptr + 5 * bandwidth;
+ bitmask = 0x80 >> (bitoffset & 7);
+ dither = Floyd16x16[y & 15];
- switch (header->cupsBitsPerColor)
+ for (x = xsize; x > 0; x --)
{
- case 1 :
- bitmask = 0x80 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
-
- for (x = xsize; x > 0; x --)
- {
- pc = *r0++ > dither[x & 15];
- pm = *r0++ > dither[x & 15];
- py = *r0++ > dither[x & 15];
- pk = *r0++ > dither[x & 15];
-
- if (pk)
- *kptr ^= bitmask; /* Black */
- else if (pc && pm)
- {
- *cptr ^= bitmask; /* Blue (cyan + light magenta) */
- *lmptr ^= bitmask;
- }
- else if (pc && py)
- {
- *lcptr ^= bitmask; /* Green (light cyan + yellow) */
- *yptr ^= bitmask;
- }
- else if (pm && py)
- {
- *mptr ^= bitmask; /* Red (magenta + yellow) */
- *yptr ^= bitmask;
- }
- else if (pc)
- *cptr ^= bitmask;
- else if (pm)
- *mptr ^= bitmask;
- else if (py)
- *yptr ^= bitmask;
-
- if (bitmask > 1)
- bitmask >>= 1;
- else
- {
- bitmask = 0x80;
- cptr ++;
- mptr ++;
- yptr ++;
- kptr ++;
- lcptr ++;
- lmptr ++;
- }
- }
- break;
-
- case 8 :
- for (x = xsize; x > 0; x --, r0 += 4, r1 += 4)
- {
- if (r0[0] == r1[0])
- *cptr++ = r0[0];
- else
- *cptr++ = (r0[0] * yerr0 + r1[0] * yerr1) / ysize;
-
- if (r0[1] == r1[1])
- *mptr++ = r0[1];
- else
- *mptr++ = (r0[1] * yerr0 + r1[1] * yerr1) / ysize;
-
- if (r0[2] == r1[2])
- *yptr++ = r0[2];
- else
- *yptr++ = (r0[2] * yerr0 + r1[2] * yerr1) / ysize;
+ pc = *r0++ > dither[x & 15];
+ pm = *r0++ > dither[x & 15];
+ py = *r0++ > dither[x & 15];
+ pk = pc && pm && py;
+
+ if (pk)
+ *kptr ^= bitmask; /* Black */
+ else if (pc && pm)
+ {
+ *cptr ^= bitmask; /* Blue (cyan + light magenta) */
+ *lmptr ^= bitmask;
+ }
+ else if (pc && py)
+ {
+ *lcptr ^= bitmask; /* Green (light cyan + yellow) */
+ *yptr ^= bitmask;
+ }
+ else if (pm && py)
+ {
+ *mptr ^= bitmask; /* Red (magenta + yellow) */
+ *yptr ^= bitmask;
+ }
+ else if (pc)
+ *cptr ^= bitmask;
+ else if (pm)
+ *mptr ^= bitmask;
+ else if (py)
+ *yptr ^= bitmask;
- if (r0[3] == r1[3])
- *kptr++ = r0[3];
- else
- *kptr++ = (r0[3] * yerr0 + r1[3] * yerr1) / ysize;
- }
- break;
- }
+ if (bitmask > 1)
+ bitmask >>= 1;
+ else
+ {
+ bitmask = 0x80;
+ cptr ++;
+ mptr ++;
+ yptr ++;
+ kptr ++;
+ lcptr ++;
+ lmptr ++;
+ }
+ }
break;
case CUPS_ORDER_PLANAR :
- switch (header->cupsBitsPerColor)
- {
- case 1 :
- bitmask = 0x80 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
-
- switch (z)
- {
- case 0 :
- for (x = xsize; x > 0; x --, r0 += 4)
- {
- if (r0[3] > dither[x & 15])
- *ptr ^= bitmask;
-
- if (bitmask > 1)
- bitmask >>= 1;
- else
- {
- bitmask = 0x80;
- ptr ++;
- }
- }
- break;
-
- case 1 :
- for (x = xsize; x > 0; x --, r0 += 4)
- {
- if (r0[0] > dither[x & 15] &&
- r0[2] < dither[x & 15])
- *ptr ^= bitmask;
-
- if (bitmask > 1)
- bitmask >>= 1;
- else
- {
- bitmask = 0x80;
- ptr ++;
- }
- }
- break;
-
- case 2 :
- for (x = xsize; x > 0; x --, r0 += 4)
- {
- if (r0[1] > dither[x & 15] &&
- (r0[0] < dither[x & 15] ||
- r0[2] > dither[x & 15]))
- *ptr ^= bitmask;
-
- if (bitmask > 1)
- bitmask >>= 1;
- else
- {
- bitmask = 0x80;
- ptr ++;
- }
- }
- break;
-
- case 3 :
- for (x = xsize; x > 0; x --, r0 += 4)
- {
- if (r0[2] > dither[x & 15] &&
- (r0[0] < dither[x & 15] ||
- r0[1] < dither[x & 15]))
- *ptr ^= bitmask;
-
- if (bitmask > 1)
- bitmask >>= 1;
- else
- {
- bitmask = 0x80;
- ptr ++;
- }
- }
- break;
-
- case 4 :
- for (x = xsize; x > 0; x --, r0 += 4)
- {
- if (r0[0] > dither[x & 15] &&
- r0[2] > dither[x & 15])
- *ptr ^= bitmask;
-
- if (bitmask > 1)
- bitmask >>= 1;
- else
- {
- bitmask = 0x80;
- ptr ++;
- }
- }
- break;
-
- case 5 :
- for (x = xsize; x > 0; x --, r0 += 4)
- {
- if (r0[0] > dither[x & 15] &&
- r0[1] > dither[x & 15] &&
- r0[2] < dither[x & 15])
- *ptr ^= bitmask;
+ bitmask = 0x80 >> (bitoffset & 7);
+ dither = Floyd16x16[y & 15];
- if (bitmask > 1)
- bitmask >>= 1;
- else
- {
- bitmask = 0x80;
- ptr ++;
- }
- }
- break;
- }
- break;
+ for (x = xsize; x > 0; x --)
+ {
+ pc = *r0++ > dither[x & 15];
+ pm = *r0++ > dither[x & 15];
+ py = *r0++ > dither[x & 15];
+ pk = pc && pm && py;
- case 8 :
- if (z == 0)
- {
- r0 += 3;
- r1 += 3;
- }
- else
- {
- r0 += z - 1;
- r1 += z - 1;
- }
+ if (pk && z == 0)
+ *ptr ^= bitmask;
+ else if (pc && pm && (z == 1 || z == 5))
+ *ptr ^= bitmask; /* Blue (cyan + light magenta) */
+ else if (pc && py && (z == 3 || z == 4))
+ *ptr ^= bitmask; /* Green (light cyan + yellow) */
+ else if (pm && py && (z == 2 || z == 3))
+ *ptr ^= bitmask; /* Red (magenta + yellow) */
+ else if (pc && z == 1)
+ *ptr ^= bitmask;
+ else if (pm && z == 2)
+ *ptr ^= bitmask;
+ else if (py && z == 3)
+ *ptr ^= bitmask;
- for (x = xsize; x > 0; x --, r0 += 4, r1 += 4)
- {
- if (*r0 == *r1)
- *ptr++ = *r0;
- else
- *ptr++ = (*r0 * yerr0 + *r1 * yerr1) / ysize;
- }
- break;
- }
+ if (bitmask > 1)
+ bitmask >>= 1;
+ else
+ {
+ bitmask = 0x80;
+ ptr ++;
+ }
+ }
break;
}
}
*/
static void
-format_RGBA(cups_page_header2_t *header, /* I - Page header */
+format_RGBA(cups_page_header2_t *header,/* I - Page header */
unsigned char *row, /* IO - Bitmap data for device */
int y, /* I - Current row */
int z, /* I - Current plane */
int ysize, /* I - Height of image data */
int yerr0, /* I - Top Y error */
int yerr1, /* I - Bottom Y error */
- cups_ib_t *r0, /* I - Primary image data */
- cups_ib_t *r1) /* I - Image data for interpolation */
+ cups_ib_t *r0, /* I - Primary image data */
+ cups_ib_t *r1) /* I - Image data for interpolation */
{
- cups_ib_t *ptr, /* Pointer into row */
- *cptr, /* Pointer into cyan */
- *mptr, /* Pointer into magenta */
- *yptr, /* Pointer into yellow */
- bitmask; /* Current mask for pixel */
- int bitoffset; /* Current offset in line */
- int bandwidth; /* Width of a color band */
- int x, /* Current X coordinate on page */
- *dither; /* Pointer into dither array */
+ cups_ib_t *ptr, /* Pointer into row */
+ *cptr, /* Pointer into cyan */
+ *mptr, /* Pointer into magenta */
+ *yptr, /* Pointer into yellow */
+ bitmask; /* Current mask for pixel */
+ int bitoffset; /* Current offset in line */
+ int bandwidth; /* Width of a color band */
+ int x, /* Current X coordinate on page */
+ *dither; /* Pointer into dither array */
switch (XPosition)
{
case 1 :
bitmask = 128 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
+ dither = Floyd16x16[y & 15];
for (x = xsize ; x > 0; x --)
{
*ptr ^= bitmask;
if (bitmask > 2)
- {
- *ptr ^= 16;
bitmask >>= 2;
- }
else
{
bitmask = 128;
- *ptr++ ^= 1;
+ ptr ++;
}
}
break;
for (x = xsize ; x > 0; x --, r0 += 3)
{
if ((r0[0] & 63) > dither[x & 7])
- *ptr ^= (0x0 & OnPixels[r0[0]]);
+ *ptr ^= (0xc0 & OnPixels[r0[0]]);
else
- *ptr ^= (0x0 & OffPixels[r0[0]]);
+ *ptr ^= (0xc0 & OffPixels[r0[0]]);
if ((r0[1] & 63) > dither[x & 7])
*ptr ^= (0x30 & OnPixels[r0[1]]);
else
*ptr ^= (0x0c & OffPixels[r0[2]]);
- *ptr++ ^= 0x03;
+ ptr ++;
}
break;
else
*ptr ^= (0xf0 & OffPixels[r0[2]]);
- *ptr++ ^= 0x0f;
+ ptr ++;
}
break;
else
*ptr++ = (r0[2] * yerr0 + r1[2] * yerr1) / ysize;
- *ptr++ = 255;
+ ptr ++;
}
break;
}
{
case 1 :
bitmask = 0x80 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
+ dither = Floyd16x16[y & 15];
for (x = xsize; x > 0; x --)
{
break;
case 2 :
- bitmask = 0x0 >> (bitoffset & 7);
+ bitmask = 0xc0 >> (bitoffset & 7);
dither = Floyd8x8[y & 7];
for (x = xsize; x > 0; x --)
bitmask >>= 2;
else
{
- bitmask = 0x0;
+ bitmask = 0xc0;
cptr ++;
mptr ++;
{
case 1 :
bitmask = 0x80 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
+ dither = Floyd16x16[y & 15];
switch (z)
{
break;
case 2 :
- bitmask = 0x0 >> (bitoffset & 7);
+ bitmask = 0xc0 >> (bitoffset & 7);
dither = Floyd8x8[y & 7];
r0 += z;
bitmask >>= 2;
else
{
- bitmask = 0x0;
+ bitmask = 0xc0;
ptr ++;
}
int ysize, /* I - Height of image data */
int yerr0, /* I - Top Y error */
int yerr1, /* I - Bottom Y error */
- cups_ib_t *r0, /* I - Primary image data */
- cups_ib_t *r1) /* I - Image data for interpolation */
+ cups_ib_t *r0, /* I - Primary image data */
+ cups_ib_t *r1) /* I - Image data for interpolation */
{
- cups_ib_t *ptr, /* Pointer into row */
- bitmask; /* Current mask for pixel */
- int bitoffset; /* Current offset in line */
- int x, /* Current X coordinate on page */
- *dither; /* Pointer into dither array */
+ cups_ib_t *ptr, /* Pointer into row */
+ bitmask; /* Current mask for pixel */
+ int bitoffset; /* Current offset in line */
+ int x, /* Current X coordinate on page */
+ *dither; /* Pointer into dither array */
(void)z;
{
case 1 :
bitmask = 0x80 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
+ dither = Floyd16x16[y & 15];
for (x = xsize; x > 0; x --)
{
break;
case 2 :
- bitmask = 0x0 >> (bitoffset & 7);
+ bitmask = 0xc0 >> (bitoffset & 7);
dither = Floyd8x8[y & 7];
for (x = xsize; x > 0; x --)
bitmask >>= 2;
else
{
- bitmask = 0x0;
+ bitmask = 0xc0;
ptr ++;
}
int ysize, /* I - Height of image data */
int yerr0, /* I - Top Y error */
int yerr1, /* I - Bottom Y error */
- cups_ib_t *r0, /* I - Primary image data */
- cups_ib_t *r1) /* I - Image data for interpolation */
+ cups_ib_t *r0, /* I - Primary image data */
+ cups_ib_t *r1) /* I - Image data for interpolation */
{
- cups_ib_t *ptr, /* Pointer into row */
- *cptr, /* Pointer into cyan */
- *mptr, /* Pointer into magenta */
- *yptr, /* Pointer into yellow */
- bitmask; /* Current mask for pixel */
- int bitoffset; /* Current offset in line */
- int bandwidth; /* Width of a color band */
- int x, /* Current X coordinate on page */
- *dither; /* Pointer into dither array */
+ cups_ib_t *ptr, /* Pointer into row */
+ *cptr, /* Pointer into cyan */
+ *mptr, /* Pointer into magenta */
+ *yptr, /* Pointer into yellow */
+ bitmask; /* Current mask for pixel */
+ int bitoffset; /* Current offset in line */
+ int bandwidth; /* Width of a color band */
+ int x, /* Current X coordinate on page */
+ *dither; /* Pointer into dither array */
switch (XPosition)
{
case 1 :
bitmask = 64 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
+ dither = Floyd16x16[y & 15];
for (x = xsize ; x > 0; x --, r0 += 3)
{
{
case 1 :
bitmask = 0x80 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
+ dither = Floyd16x16[y & 15];
for (x = xsize; x > 0; x --)
{
break;
case 2 :
- bitmask = 0x0 >> (bitoffset & 7);
+ bitmask = 0xc0 >> (bitoffset & 7);
dither = Floyd8x8[y & 7];
for (x = xsize; x > 0; x --)
bitmask >>= 2;
else
{
- bitmask = 0x0;
+ bitmask = 0xc0;
cptr ++;
mptr ++;
{
case 1 :
bitmask = 0x80 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
+ dither = Floyd16x16[y & 15];
switch (z)
{
break;
case 2 :
- bitmask = 0x0 >> (bitoffset & 7);
+ bitmask = 0xc0 >> (bitoffset & 7);
dither = Floyd8x8[y & 7];
z = 2 - z;
r0 += z;
bitmask >>= 2;
else
{
- bitmask = 0x0;
+ bitmask = 0xc0;
ptr ++;
}
*/
static void
-format_YMCK(cups_page_header2_t *header, /* I - Page header */
+format_YMCK(cups_page_header2_t *header,/* I - Page header */
unsigned char *row, /* IO - Bitmap data for device */
int y, /* I - Current row */
int z, /* I - Current plane */
int ysize, /* I - Height of image data */
int yerr0, /* I - Top Y error */
int yerr1, /* I - Bottom Y error */
- cups_ib_t *r0, /* I - Primary image data */
- cups_ib_t *r1) /* I - Image data for interpolation */
+ cups_ib_t *r0, /* I - Primary image data */
+ cups_ib_t *r1) /* I - Image data for interpolation */
{
- cups_ib_t *ptr, /* Pointer into row */
- *cptr, /* Pointer into cyan */
- *mptr, /* Pointer into magenta */
- *yptr, /* Pointer into yellow */
- *kptr, /* Pointer into black */
- bitmask; /* Current mask for pixel */
- int bitoffset; /* Current offset in line */
- int bandwidth; /* Width of a color band */
- int x, /* Current X coordinate on page */
- *dither; /* Pointer into dither array */
+ cups_ib_t *ptr, /* Pointer into row */
+ *cptr, /* Pointer into cyan */
+ *mptr, /* Pointer into magenta */
+ *yptr, /* Pointer into yellow */
+ *kptr, /* Pointer into black */
+ bitmask; /* Current mask for pixel */
+ int bitoffset; /* Current offset in line */
+ int bandwidth; /* Width of a color band */
+ int x, /* Current X coordinate on page */
+ *dither; /* Pointer into dither array */
+ int pc, pm, py; /* CMY pixels */
switch (XPosition)
{
case 1 :
bitmask = 128 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
+ dither = Floyd16x16[y & 15];
- for (x = xsize ; x > 0; x --, r0 += 4)
+ for (x = xsize ; x > 0; x --)
{
- if (r0[2] > dither[x & 15])
- *ptr ^= bitmask;
- bitmask >>= 1;
+ pc = *r0++ > dither[x & 15];
+ pm = *r0++ > dither[x & 15];
+ py = *r0++ > dither[x & 15];
- if (r0[1] > dither[x & 15])
+ if (pc && pm && py)
+ {
+ bitmask >>= 3;
*ptr ^= bitmask;
- bitmask >>= 1;
+ }
+ else
+ {
+ if (py)
+ *ptr ^= bitmask;
+ bitmask >>= 1;
- if (r0[0] > dither[x & 15])
- *ptr ^= bitmask;
- bitmask >>= 1;
+ if (pm)
+ *ptr ^= bitmask;
+ bitmask >>= 1;
- if (r0[3] > dither[x & 15])
- *ptr ^= bitmask;
+ if (pc)
+ *ptr ^= bitmask;
+ bitmask >>= 1;
+ }
if (bitmask > 1)
bitmask >>= 1;
for (x = xsize ; x > 0; x --, r0 += 4)
{
if ((r0[2] & 63) > dither[x & 7])
- *ptr ^= (0x0 & OnPixels[r0[2]]);
+ *ptr ^= (0xc0 & OnPixels[r0[2]]);
else
- *ptr ^= (0x0 & OffPixels[r0[2]]);
+ *ptr ^= (0xc0 & OffPixels[r0[2]]);
if ((r0[1] & 63) > dither[x & 7])
*ptr ^= (0x30 & OnPixels[r0[1]]);
{
case 1 :
bitmask = 0x80 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
+ dither = Floyd16x16[y & 15];
for (x = xsize; x > 0; x --)
{
- if (*r0++ > dither[x & 15])
- *cptr ^= bitmask;
- if (*r0++ > dither[x & 15])
- *mptr ^= bitmask;
- if (*r0++ > dither[x & 15])
- *yptr ^= bitmask;
- if (*r0++ > dither[x & 15])
- *kptr ^= bitmask;
+ pc = *r0++ > dither[x & 15];
+ pm = *r0++ > dither[x & 15];
+ py = *r0++ > dither[x & 15];
+
+ if (pc && pm && py)
+ *kptr ^= bitmask;
+ else
+ {
+ if (pc)
+ *cptr ^= bitmask;
+ if (pm)
+ *mptr ^= bitmask;
+ if (py)
+ *yptr ^= bitmask;
+ }
if (bitmask > 1)
bitmask >>= 1;
break;
case 2 :
- bitmask = 0x0 >> (bitoffset & 7);
+ bitmask = 0xc0 >> (bitoffset & 7);
dither = Floyd8x8[y & 7];
for (x = xsize; x > 0; x --)
bitmask >>= 2;
else
{
- bitmask = 0x0;
+ bitmask = 0xc0;
cptr ++;
mptr ++;
{
case 1 :
bitmask = 0x80 >> (bitoffset & 7);
- dither = Floyd16xc16[y & 15];
+ dither = Floyd16x16[y & 15];
- if (z < 3)
- r0 += 2 - z;
- else
- r0 += z;
-
- for (x = xsize; x > 0; x --, r0 += 4)
+ for (x = xsize; x > 0; x --)
{
- if (*r0 > dither[x & 15])
+ pc = *r0++ > dither[x & 15];
+ pm = *r0++ > dither[x & 15];
+ py = *r0++ > dither[x & 15];
+
+ if ((pc && pm && py && z == 3) ||
+ (pc && z == 2) || (pm && z == 1) || (py && z == 0))
*ptr ^= bitmask;
if (bitmask > 1)
break;
case 2 :
- bitmask = 0x0 >> (bitoffset & 7);
+ bitmask = 0xc0 >> (bitoffset & 7);
dither = Floyd8x8[y & 7];
if (z == 3)
r0 += 3;
bitmask >>= 2;
else
{
- bitmask = 0x0;
+ bitmask = 0xc0;
ptr ++;
}
/*
- * End of "$Id: imagetoraster.c 5191 2006-02-27 02:47:56Z mike $".
+ * 'raster_cb()' - Validate the page header.
+ */
+
+static int /* O - 0 if OK, -1 if not */
+raster_cb(
+ cups_page_header2_t *header, /* IO - Raster header */
+ int preferred_bits) /* I - Preferred bits per color */
+{
+ /*
+ * Ensure that colorimetric colorspaces use at least 8 bits per
+ * component...
+ */
+
+ if ((header->cupsColorSpace == CUPS_CSPACE_CIEXYZ ||
+ header->cupsColorSpace == CUPS_CSPACE_CIELab ||
+ header->cupsColorSpace >= CUPS_CSPACE_ICC1) &&
+ header->cupsBitsPerColor < 8)
+ header->cupsBitsPerColor = 8;
+
+ return (0);
+}
+
+
+/*
+ * End of "$Id: imagetoraster.c 6649 2007-07-11 21:46:42Z mike $".
*/
projects / thirdparty / cups.git / blobdiff