Cups v2.2.0
Test: none
Change-Id: Ic1716fa930940f63b4679144b1459263a35476ef
diff --git a/filter/raster.c b/filter/raster.c
new file mode 100644
index 0000000..dee8eec
--- /dev/null
+++ b/filter/raster.c
@@ -0,0 +1,1799 @@
+/*
+ * Raster file routines for CUPS.
+ *
+ * Copyright 2007-2016 by Apple Inc.
+ * Copyright 1997-2006 by Easy Software Products.
+ *
+ * This file is part of the CUPS Imaging library.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * 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.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include <cups/raster-private.h>
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif /* HAVE_STDINT_H */
+
+
+/*
+ * Private structures...
+ */
+
+struct _cups_raster_s /**** Raster stream data ****/
+{
+ unsigned sync; /* Sync word from start of stream */
+ void *ctx; /* File descriptor */
+ cups_raster_iocb_t iocb; /* IO callback */
+ cups_mode_t mode; /* Read/write mode */
+ cups_page_header2_t header; /* Raster header for current page */
+ unsigned count, /* Current row run-length count */
+ remaining, /* Remaining rows in page image */
+ bpp; /* Bytes per pixel/color */
+ unsigned char *pixels, /* Pixels for current row */
+ *pend, /* End of pixel buffer */
+ *pcurrent; /* Current byte in pixel buffer */
+ int compressed, /* Non-zero if data is compressed */
+ swapped; /* Non-zero if data is byte-swapped */
+ unsigned char *buffer, /* Read/write buffer */
+ *bufptr, /* Current (read) position in buffer */
+ *bufend; /* End of current (read) buffer */
+ size_t bufsize; /* Buffer size */
+#ifdef DEBUG
+ size_t iocount; /* Number of bytes read/written */
+#endif /* DEBUG */
+};
+
+
+/*
+ * Local functions...
+ */
+
+static ssize_t cups_raster_io(cups_raster_t *r, unsigned char *buf, size_t bytes);
+static unsigned cups_raster_read_header(cups_raster_t *r);
+static ssize_t cups_raster_read(cups_raster_t *r, unsigned char *buf,
+ size_t bytes);
+static int cups_raster_update(cups_raster_t *r);
+static ssize_t cups_raster_write(cups_raster_t *r,
+ const unsigned char *pixels);
+static ssize_t cups_read_fd(void *ctx, unsigned char *buf, size_t bytes);
+static void cups_swap(unsigned char *buf, size_t bytes);
+static ssize_t cups_write_fd(void *ctx, unsigned char *buf, size_t bytes);
+
+
+/*
+ * 'cupsRasterClose()' - Close a raster stream.
+ *
+ * The file descriptor associated with the raster stream must be closed
+ * separately as needed.
+ */
+
+void
+cupsRasterClose(cups_raster_t *r) /* I - Stream to close */
+{
+ if (r != NULL)
+ {
+ if (r->buffer)
+ free(r->buffer);
+
+ if (r->pixels)
+ free(r->pixels);
+
+ free(r);
+ }
+}
+
+
+/*
+ * 'cupsRasterInitPWGHeader()' - Initialize a page header for PWG Raster output.
+ *
+ * The "media" argument specifies the media to use.
+ *
+ * The "type" argument specifies a "pwg-raster-document-type-supported" value
+ * that controls the color space and bit depth of the raster data.
+ *
+ * The "xres" and "yres" arguments specify the raster resolution in dots per
+ * inch.
+ *
+ * The "sheet_back" argument specifies a "pwg-raster-document-sheet-back" value
+ * to apply for the back side of a page. Pass @code NULL@ for the front side.
+ *
+ * @since CUPS 2.2/macOS 10.12@
+ */
+
+int /* O - 1 on success, 0 on failure */
+cupsRasterInitPWGHeader(
+ cups_page_header2_t *h, /* I - Page header */
+ pwg_media_t *media, /* I - PWG media information */
+ const char *type, /* I - PWG raster type string */
+ int xdpi, /* I - Cross-feed direction (horizontal) resolution */
+ int ydpi, /* I - Feed direction (vertical) resolution */
+ const char *sides, /* I - IPP "sides" option value */
+ const char *sheet_back) /* I - Transform for back side or @code NULL@ for none */
+{
+ if (!h || !media || !type || xdpi <= 0 || ydpi <= 0)
+ {
+ _cupsRasterAddError("%s", strerror(EINVAL));
+ return (0);
+ }
+
+ /*
+ * Initialize the page header...
+ */
+
+ memset(h, 0, sizeof(cups_page_header2_t));
+
+ strlcpy(h->cupsPageSizeName, media->pwg, sizeof(h->cupsPageSizeName));
+
+ h->PageSize[0] = (unsigned)(72 * media->width / 2540);
+ h->PageSize[1] = (unsigned)(72 * media->length / 2540);
+
+ /* This never gets written but is needed for some applications */
+ h->cupsPageSize[0] = 72.0f * media->width / 2540.0f;
+ h->cupsPageSize[1] = 72.0f * media->length / 2540.0f;
+
+ h->ImagingBoundingBox[2] = h->PageSize[0];
+ h->ImagingBoundingBox[3] = h->PageSize[1];
+
+ h->HWResolution[0] = (unsigned)xdpi;
+ h->HWResolution[1] = (unsigned)ydpi;
+
+ h->cupsWidth = (unsigned)(media->width * xdpi / 2540);
+ h->cupsHeight = (unsigned)(media->length * ydpi / 2540);
+
+ if (h->cupsWidth > 0x00ffffff || h->cupsHeight > 0x00ffffff)
+ {
+ _cupsRasterAddError("Raster dimensions too large.");
+ return (0);
+ }
+
+ h->cupsInteger[CUPS_RASTER_PWG_ImageBoxRight] = h->cupsWidth;
+ h->cupsInteger[CUPS_RASTER_PWG_ImageBoxBottom] = h->cupsHeight;
+
+ /*
+ * Colorspace and bytes per line...
+ */
+
+ if (!strcmp(type, "adobe-rgb_8"))
+ {
+ h->cupsBitsPerColor = 8;
+ h->cupsBitsPerPixel = 24;
+ h->cupsColorSpace = CUPS_CSPACE_ADOBERGB;
+ }
+ else if (!strcmp(type, "adobe-rgb_16"))
+ {
+ h->cupsBitsPerColor = 16;
+ h->cupsBitsPerPixel = 48;
+ h->cupsColorSpace = CUPS_CSPACE_ADOBERGB;
+ }
+ else if (!strcmp(type, "black_1"))
+ {
+ h->cupsBitsPerColor = 1;
+ h->cupsBitsPerPixel = 1;
+ h->cupsColorSpace = CUPS_CSPACE_K;
+ }
+ else if (!strcmp(type, "black_8"))
+ {
+ h->cupsBitsPerColor = 8;
+ h->cupsBitsPerPixel = 8;
+ h->cupsColorSpace = CUPS_CSPACE_K;
+ }
+ else if (!strcmp(type, "black_16"))
+ {
+ h->cupsBitsPerColor = 16;
+ h->cupsBitsPerPixel = 16;
+ h->cupsColorSpace = CUPS_CSPACE_K;
+ }
+ else if (!strcmp(type, "cmyk_8"))
+ {
+ h->cupsBitsPerColor = 8;
+ h->cupsBitsPerPixel = 32;
+ h->cupsColorSpace = CUPS_CSPACE_CMYK;
+ }
+ else if (!strcmp(type, "cmyk_16"))
+ {
+ h->cupsBitsPerColor = 16;
+ h->cupsBitsPerPixel = 64;
+ h->cupsColorSpace = CUPS_CSPACE_CMYK;
+ }
+ else if (!strncmp(type, "device", 6) && type[6] >= '1' && type[6] <= '9')
+ {
+ int ncolors, bits; /* Number of colors and bits */
+
+
+ if (sscanf(type, "device%d_%d", &ncolors, &bits) != 2 || ncolors > 15 || (bits != 8 && bits != 16))
+ {
+ _cupsRasterAddError("Unsupported raster type \'%s\'.", type);
+ return (0);
+ }
+
+ h->cupsBitsPerColor = (unsigned)bits;
+ h->cupsBitsPerPixel = (unsigned)(ncolors * bits);
+ h->cupsColorSpace = (cups_cspace_t)(CUPS_CSPACE_DEVICE1 + ncolors - 1);
+ }
+ else if (!strcmp(type, "rgb_8"))
+ {
+ h->cupsBitsPerColor = 8;
+ h->cupsBitsPerPixel = 24;
+ h->cupsColorSpace = CUPS_CSPACE_RGB;
+ }
+ else if (!strcmp(type, "rgb_16"))
+ {
+ h->cupsBitsPerColor = 16;
+ h->cupsBitsPerPixel = 48;
+ h->cupsColorSpace = CUPS_CSPACE_RGB;
+ }
+ else if (!strcmp(type, "sgray_1"))
+ {
+ h->cupsBitsPerColor = 1;
+ h->cupsBitsPerPixel = 1;
+ h->cupsColorSpace = CUPS_CSPACE_SW;
+ }
+ else if (!strcmp(type, "sgray_8"))
+ {
+ h->cupsBitsPerColor = 8;
+ h->cupsBitsPerPixel = 8;
+ h->cupsColorSpace = CUPS_CSPACE_SW;
+ }
+ else if (!strcmp(type, "sgray_16"))
+ {
+ h->cupsBitsPerColor = 16;
+ h->cupsBitsPerPixel = 16;
+ h->cupsColorSpace = CUPS_CSPACE_SW;
+ }
+ else if (!strcmp(type, "srgb_8"))
+ {
+ h->cupsBitsPerColor = 8;
+ h->cupsBitsPerPixel = 24;
+ h->cupsColorSpace = CUPS_CSPACE_SRGB;
+ }
+ else if (!strcmp(type, "srgb_16"))
+ {
+ h->cupsBitsPerColor = 16;
+ h->cupsBitsPerPixel = 48;
+ h->cupsColorSpace = CUPS_CSPACE_SRGB;
+ }
+ else
+ {
+ _cupsRasterAddError("Unsupported raster type \'%s\'.", type);
+ return (0);
+ }
+
+ h->cupsColorOrder = CUPS_ORDER_CHUNKED;
+ h->cupsNumColors = h->cupsBitsPerPixel / h->cupsBitsPerColor;
+ h->cupsBytesPerLine = (h->cupsWidth * h->cupsBitsPerPixel + 7) / 8;
+
+ /*
+ * Duplex support...
+ */
+
+ h->cupsInteger[CUPS_RASTER_PWG_CrossFeedTransform] = 1;
+ h->cupsInteger[CUPS_RASTER_PWG_FeedTransform] = 1;
+
+ if (sides)
+ {
+ if (!strcmp(sides, "two-sided-long-edge"))
+ {
+ h->Duplex = 1;
+ }
+ else if (!strcmp(sides, "two-sided-short-edge"))
+ {
+ h->Duplex = 1;
+ h->Tumble = 1;
+ }
+ else if (strcmp(sides, "one-sided"))
+ {
+ _cupsRasterAddError("Unsupported sides value \'%s\'.", sides);
+ return (0);
+ }
+
+ if (sheet_back)
+ {
+ if (!strcmp(sheet_back, "flipped"))
+ {
+ if (h->Tumble)
+ h->cupsInteger[CUPS_RASTER_PWG_CrossFeedTransform] = 0xffffffffU;
+ else
+ h->cupsInteger[CUPS_RASTER_PWG_FeedTransform] = 0xffffffffU;
+ }
+ else if (!strcmp(sheet_back, "manual-tumble"))
+ {
+ if (h->Tumble)
+ {
+ h->cupsInteger[CUPS_RASTER_PWG_CrossFeedTransform] = 0xffffffffU;
+ h->cupsInteger[CUPS_RASTER_PWG_FeedTransform] = 0xffffffffU;
+ }
+ }
+ else if (!strcmp(sheet_back, "rotated"))
+ {
+ if (!h->Tumble)
+ {
+ h->cupsInteger[CUPS_RASTER_PWG_CrossFeedTransform] = 0xffffffffU;
+ h->cupsInteger[CUPS_RASTER_PWG_FeedTransform] = 0xffffffffU;
+ }
+ }
+ else if (strcmp(sheet_back, "normal"))
+ {
+ _cupsRasterAddError("Unsupported sheet_back value \'%s\'.", sheet_back);
+ return (0);
+ }
+ }
+ }
+
+ return (1);
+}
+
+
+/*
+ * 'cupsRasterOpen()' - Open a raster stream using a file descriptor.
+ *
+ * This function associates a raster stream with the given file descriptor.
+ * For most printer driver filters, "fd" will be 0 (stdin). For most raster
+ * image processor (RIP) filters that generate raster data, "fd" will be 1
+ * (stdout).
+ *
+ * When writing raster data, the @code CUPS_RASTER_WRITE@,
+ * @code CUPS_RASTER_WRITE_COMPRESS@, or @code CUPS_RASTER_WRITE_PWG@ mode can
+ * be used - compressed and PWG output is generally 25-50% smaller but adds a
+ * 100-300% execution time overhead.
+ */
+
+cups_raster_t * /* O - New stream */
+cupsRasterOpen(int fd, /* I - File descriptor */
+ cups_mode_t mode) /* I - Mode - @code CUPS_RASTER_READ@,
+ @code CUPS_RASTER_WRITE@,
+ @code CUPS_RASTER_WRITE_COMPRESSED@,
+ or @code CUPS_RASTER_WRITE_PWG@ */
+{
+ if (mode == CUPS_RASTER_READ)
+ return (cupsRasterOpenIO(cups_read_fd, (void *)((intptr_t)fd), mode));
+ else
+ return (cupsRasterOpenIO(cups_write_fd, (void *)((intptr_t)fd), mode));
+}
+
+
+/*
+ * 'cupsRasterOpenIO()' - Open a raster stream using a callback function.
+ *
+ * This function associates a raster stream with the given callback function and
+ * context pointer.
+ *
+ * When writing raster data, the @code CUPS_RASTER_WRITE@,
+ * @code CUPS_RASTER_WRITE_COMPRESS@, or @code CUPS_RASTER_WRITE_PWG@ mode can
+ * be used - compressed and PWG output is generally 25-50% smaller but adds a
+ * 100-300% execution time overhead.
+ */
+
+cups_raster_t * /* O - New stream */
+cupsRasterOpenIO(
+ cups_raster_iocb_t iocb, /* I - Read/write callback */
+ void *ctx, /* I - Context pointer for callback */
+ cups_mode_t mode) /* I - Mode - @code CUPS_RASTER_READ@,
+ @code CUPS_RASTER_WRITE@,
+ @code CUPS_RASTER_WRITE_COMPRESSED@,
+ or @code CUPS_RASTER_WRITE_PWG@ */
+{
+ cups_raster_t *r; /* New stream */
+
+
+ _cupsRasterClearError();
+
+ if ((r = calloc(sizeof(cups_raster_t), 1)) == NULL)
+ {
+ _cupsRasterAddError("Unable to allocate memory for raster stream: %s\n",
+ strerror(errno));
+ return (NULL);
+ }
+
+ r->ctx = ctx;
+ r->iocb = iocb;
+ r->mode = mode;
+
+ if (mode == CUPS_RASTER_READ)
+ {
+ /*
+ * Open for read - get sync word...
+ */
+
+ if (cups_raster_io(r, (unsigned char *)&(r->sync), sizeof(r->sync)) !=
+ sizeof(r->sync))
+ {
+ _cupsRasterAddError("Unable to read header from raster stream: %s\n",
+ strerror(errno));
+ free(r);
+ return (NULL);
+ }
+
+ if (r->sync != CUPS_RASTER_SYNC &&
+ r->sync != CUPS_RASTER_REVSYNC &&
+ r->sync != CUPS_RASTER_SYNCv1 &&
+ r->sync != CUPS_RASTER_REVSYNCv1 &&
+ r->sync != CUPS_RASTER_SYNCv2 &&
+ r->sync != CUPS_RASTER_REVSYNCv2)
+ {
+ _cupsRasterAddError("Unknown raster format %08x!\n", r->sync);
+ free(r);
+ return (NULL);
+ }
+
+ if (r->sync == CUPS_RASTER_SYNCv2 ||
+ r->sync == CUPS_RASTER_REVSYNCv2)
+ r->compressed = 1;
+
+ if (r->sync == CUPS_RASTER_REVSYNC ||
+ r->sync == CUPS_RASTER_REVSYNCv1 ||
+ r->sync == CUPS_RASTER_REVSYNCv2)
+ r->swapped = 1;
+
+ DEBUG_printf(("1cupsRasterOpenIO: r->swapped=%d, r->sync=%08x\n", r->swapped, r->sync));
+ }
+ else
+ {
+ /*
+ * Open for write - put sync word...
+ */
+
+ switch (mode)
+ {
+ default :
+ case CUPS_RASTER_WRITE :
+ r->sync = CUPS_RASTER_SYNC;
+ break;
+
+ case CUPS_RASTER_WRITE_COMPRESSED :
+ r->compressed = 1;
+ r->sync = CUPS_RASTER_SYNCv2;
+ break;
+
+ case CUPS_RASTER_WRITE_PWG :
+ r->compressed = 1;
+ r->sync = htonl(CUPS_RASTER_SYNC_PWG);
+ r->swapped = r->sync != CUPS_RASTER_SYNC_PWG;
+ break;
+ }
+
+ if (cups_raster_io(r, (unsigned char *)&(r->sync), sizeof(r->sync)) < (ssize_t)sizeof(r->sync))
+ {
+ _cupsRasterAddError("Unable to write raster stream header: %s\n",
+ strerror(errno));
+ free(r);
+ return (NULL);
+ }
+ }
+
+ return (r);
+}
+
+
+/*
+ * 'cupsRasterReadHeader()' - Read a raster page header and store it in a
+ * version 1 page header structure.
+ *
+ * This function is deprecated. Use @link cupsRasterReadHeader2@ instead.
+ *
+ * Version 1 page headers were used in CUPS 1.0 and 1.1 and contain a subset
+ * of the version 2 page header data. This function handles reading version 2
+ * page headers and copying only the version 1 data into the provided buffer.
+ *
+ * @deprecated@
+ */
+
+unsigned /* O - 1 on success, 0 on failure/end-of-file */
+cupsRasterReadHeader(
+ cups_raster_t *r, /* I - Raster stream */
+ cups_page_header_t *h) /* I - Pointer to header data */
+{
+ /*
+ * Get the raster header...
+ */
+
+ if (!cups_raster_read_header(r))
+ {
+ memset(h, 0, sizeof(cups_page_header_t));
+ return (0);
+ }
+
+ /*
+ * Copy the header to the user-supplied buffer...
+ */
+
+ memcpy(h, &(r->header), sizeof(cups_page_header_t));
+
+ return (1);
+}
+
+
+/*
+ * 'cupsRasterReadHeader2()' - Read a raster page header and store it in a
+ * version 2 page header structure.
+ *
+ * @since CUPS 1.2/macOS 10.5@
+ */
+
+unsigned /* O - 1 on success, 0 on failure/end-of-file */
+cupsRasterReadHeader2(
+ cups_raster_t *r, /* I - Raster stream */
+ cups_page_header2_t *h) /* I - Pointer to header data */
+{
+ /*
+ * Get the raster header...
+ */
+
+ DEBUG_printf(("cupsRasterReadHeader2(r=%p, h=%p)", (void *)r, (void *)h));
+
+ if (!cups_raster_read_header(r))
+ {
+ memset(h, 0, sizeof(cups_page_header2_t));
+ return (0);
+ }
+
+ /*
+ * Copy the header to the user-supplied buffer...
+ */
+
+ memcpy(h, &(r->header), sizeof(cups_page_header2_t));
+
+ return (1);
+}
+
+
+/*
+ * 'cupsRasterReadPixels()' - Read raster pixels.
+ *
+ * For best performance, filters should read one or more whole lines.
+ * The "cupsBytesPerLine" value from the page header can be used to allocate
+ * the line buffer and as the number of bytes to read.
+ */
+
+unsigned /* O - Number of bytes read */
+cupsRasterReadPixels(cups_raster_t *r, /* I - Raster stream */
+ unsigned char *p, /* I - Pointer to pixel buffer */
+ unsigned len) /* I - Number of bytes to read */
+{
+ ssize_t bytes; /* Bytes read */
+ unsigned cupsBytesPerLine; /* cupsBytesPerLine value */
+ unsigned remaining; /* Bytes remaining */
+ unsigned char *ptr, /* Pointer to read buffer */
+ byte, /* Byte from file */
+ *temp; /* Pointer into buffer */
+ unsigned count; /* Repetition count */
+
+
+ DEBUG_printf(("cupsRasterReadPixels(r=%p, p=%p, len=%u)", (void *)r, (void *)p, len));
+
+ if (r == NULL || r->mode != CUPS_RASTER_READ || r->remaining == 0 ||
+ r->header.cupsBytesPerLine == 0)
+ {
+ DEBUG_puts("1cupsRasterReadPixels: Returning 0.");
+ return (0);
+ }
+
+ DEBUG_printf(("1cupsRasterReadPixels: compressed=%d, remaining=%u", r->compressed, r->remaining));
+
+ if (!r->compressed)
+ {
+ /*
+ * Read without compression...
+ */
+
+ r->remaining -= len / r->header.cupsBytesPerLine;
+
+ if (cups_raster_io(r, p, len) < (ssize_t)len)
+ {
+ DEBUG_puts("1cupsRasterReadPixels: Read error, returning 0.");
+ return (0);
+ }
+
+ /*
+ * Swap bytes as needed...
+ */
+
+ if (r->swapped &&
+ (r->header.cupsBitsPerColor == 16 ||
+ r->header.cupsBitsPerPixel == 12 ||
+ r->header.cupsBitsPerPixel == 16))
+ cups_swap(p, len);
+
+ /*
+ * Return...
+ */
+
+ DEBUG_printf(("1cupsRasterReadPixels: Returning %u", len));
+
+ return (len);
+ }
+
+ /*
+ * Read compressed data...
+ */
+
+ remaining = len;
+ cupsBytesPerLine = r->header.cupsBytesPerLine;
+
+ while (remaining > 0 && r->remaining > 0)
+ {
+ if (r->count == 0)
+ {
+ /*
+ * Need to read a new row...
+ */
+
+ if (remaining == cupsBytesPerLine)
+ ptr = p;
+ else
+ ptr = r->pixels;
+
+ /*
+ * Read using a modified PackBits compression...
+ */
+
+ if (!cups_raster_read(r, &byte, 1))
+ {
+ DEBUG_puts("1cupsRasterReadPixels: Read error, returning 0.");
+ return (0);
+ }
+
+ r->count = (unsigned)byte + 1;
+
+ if (r->count > 1)
+ ptr = r->pixels;
+
+ temp = ptr;
+ bytes = (ssize_t)cupsBytesPerLine;
+
+ while (bytes > 0)
+ {
+ /*
+ * Get a new repeat count...
+ */
+
+ if (!cups_raster_read(r, &byte, 1))
+ {
+ DEBUG_puts("1cupsRasterReadPixels: Read error, returning 0.");
+ return (0);
+ }
+
+ if (byte & 128)
+ {
+ /*
+ * Copy N literal pixels...
+ */
+
+ count = (unsigned)(257 - byte) * r->bpp;
+
+ if (count > (unsigned)bytes)
+ count = (unsigned)bytes;
+
+ if (!cups_raster_read(r, temp, count))
+ {
+ DEBUG_puts("1cupsRasterReadPixels: Read error, returning 0.");
+ return (0);
+ }
+
+ temp += count;
+ bytes -= (ssize_t)count;
+ }
+ else
+ {
+ /*
+ * Repeat the next N bytes...
+ */
+
+ count = ((unsigned)byte + 1) * r->bpp;
+ if (count > (unsigned)bytes)
+ count = (unsigned)bytes;
+
+ if (count < r->bpp)
+ break;
+
+ bytes -= (ssize_t)count;
+
+ if (!cups_raster_read(r, temp, r->bpp))
+ {
+ DEBUG_puts("1cupsRasterReadPixels: Read error, returning 0.");
+ return (0);
+ }
+
+ temp += r->bpp;
+ count -= r->bpp;
+
+ while (count > 0)
+ {
+ memcpy(temp, temp - r->bpp, r->bpp);
+ temp += r->bpp;
+ count -= r->bpp;
+ }
+ }
+ }
+
+ /*
+ * Swap bytes as needed...
+ */
+
+ if ((r->header.cupsBitsPerColor == 16 ||
+ r->header.cupsBitsPerPixel == 12 ||
+ r->header.cupsBitsPerPixel == 16) &&
+ r->swapped)
+ cups_swap(ptr, (size_t)bytes);
+
+ /*
+ * Update pointers...
+ */
+
+ if (remaining >= cupsBytesPerLine)
+ {
+ bytes = (ssize_t)cupsBytesPerLine;
+ r->pcurrent = r->pixels;
+ r->count --;
+ r->remaining --;
+ }
+ else
+ {
+ bytes = (ssize_t)remaining;
+ r->pcurrent = r->pixels + bytes;
+ }
+
+ /*
+ * Copy data as needed...
+ */
+
+ if (ptr != p)
+ memcpy(p, ptr, (size_t)bytes);
+ }
+ else
+ {
+ /*
+ * Copy fragment from buffer...
+ */
+
+ if ((unsigned)(bytes = (int)(r->pend - r->pcurrent)) > remaining)
+ bytes = (ssize_t)remaining;
+
+ memcpy(p, r->pcurrent, (size_t)bytes);
+ r->pcurrent += bytes;
+
+ if (r->pcurrent >= r->pend)
+ {
+ r->pcurrent = r->pixels;
+ r->count --;
+ r->remaining --;
+ }
+ }
+
+ remaining -= (unsigned)bytes;
+ p += bytes;
+ }
+
+ DEBUG_printf(("1cupsRasterReadPixels: Returning %u", len));
+
+ return (len);
+}
+
+
+/*
+ * 'cupsRasterWriteHeader()' - Write a raster page header from a version 1 page
+ * header structure.
+ *
+ * This function is deprecated. Use @link cupsRasterWriteHeader2@ instead.
+ *
+ * @deprecated@
+ */
+
+unsigned /* O - 1 on success, 0 on failure */
+cupsRasterWriteHeader(
+ cups_raster_t *r, /* I - Raster stream */
+ cups_page_header_t *h) /* I - Raster page header */
+{
+ if (r == NULL || r->mode == CUPS_RASTER_READ)
+ return (0);
+
+ /*
+ * Make a copy of the header, and compute the number of raster
+ * lines in the page image...
+ */
+
+ memset(&(r->header), 0, sizeof(r->header));
+ memcpy(&(r->header), h, sizeof(cups_page_header_t));
+
+ if (!cups_raster_update(r))
+ return (0);
+
+ /*
+ * Write the raster header...
+ */
+
+ if (r->mode == CUPS_RASTER_WRITE_PWG)
+ {
+ /*
+ * PWG raster data is always network byte order with much of the page header
+ * zeroed.
+ */
+
+ cups_page_header2_t fh; /* File page header */
+
+ memset(&fh, 0, sizeof(fh));
+
+ strlcpy(fh.MediaClass, "PwgRaster", sizeof(fh.MediaClass));
+ /* PwgRaster */
+ strlcpy(fh.MediaColor, r->header.MediaColor, sizeof(fh.MediaColor));
+ strlcpy(fh.MediaType, r->header.MediaType, sizeof(fh.MediaType));
+ strlcpy(fh.OutputType, r->header.OutputType, sizeof(fh.OutputType));
+ /* PrintContentType */
+
+ fh.CutMedia = htonl(r->header.CutMedia);
+ fh.Duplex = htonl(r->header.Duplex);
+ fh.HWResolution[0] = htonl(r->header.HWResolution[0]);
+ fh.HWResolution[1] = htonl(r->header.HWResolution[1]);
+ fh.ImagingBoundingBox[0] = htonl(r->header.ImagingBoundingBox[0]);
+ fh.ImagingBoundingBox[1] = htonl(r->header.ImagingBoundingBox[1]);
+ fh.ImagingBoundingBox[2] = htonl(r->header.ImagingBoundingBox[2]);
+ fh.ImagingBoundingBox[3] = htonl(r->header.ImagingBoundingBox[3]);
+ fh.InsertSheet = htonl(r->header.InsertSheet);
+ fh.Jog = htonl(r->header.Jog);
+ fh.LeadingEdge = htonl(r->header.LeadingEdge);
+ fh.ManualFeed = htonl(r->header.ManualFeed);
+ fh.MediaPosition = htonl(r->header.MediaPosition);
+ fh.MediaWeight = htonl(r->header.MediaWeight);
+ fh.NumCopies = htonl(r->header.NumCopies);
+ fh.Orientation = htonl(r->header.Orientation);
+ fh.PageSize[0] = htonl(r->header.PageSize[0]);
+ fh.PageSize[1] = htonl(r->header.PageSize[1]);
+ fh.Tumble = htonl(r->header.Tumble);
+ fh.cupsWidth = htonl(r->header.cupsWidth);
+ fh.cupsHeight = htonl(r->header.cupsHeight);
+ fh.cupsBitsPerColor = htonl(r->header.cupsBitsPerColor);
+ fh.cupsBitsPerPixel = htonl(r->header.cupsBitsPerPixel);
+ fh.cupsBytesPerLine = htonl(r->header.cupsBytesPerLine);
+ fh.cupsColorOrder = htonl(r->header.cupsColorOrder);
+ fh.cupsColorSpace = htonl(r->header.cupsColorSpace);
+ fh.cupsNumColors = htonl(r->header.cupsNumColors);
+ fh.cupsInteger[0] = htonl(r->header.cupsInteger[0]);
+ /* TotalPageCount */
+ fh.cupsInteger[1] = htonl(r->header.cupsInteger[1]);
+ /* CrossFeedTransform */
+ fh.cupsInteger[2] = htonl(r->header.cupsInteger[2]);
+ /* FeedTransform */
+ fh.cupsInteger[3] = htonl(r->header.cupsInteger[3]);
+ /* ImageBoxLeft */
+ fh.cupsInteger[4] = htonl(r->header.cupsInteger[4]);
+ /* ImageBoxTop */
+ fh.cupsInteger[5] = htonl(r->header.cupsInteger[5]);
+ /* ImageBoxRight */
+ fh.cupsInteger[6] = htonl(r->header.cupsInteger[6]);
+ /* ImageBoxBottom */
+ fh.cupsInteger[7] = htonl(r->header.cupsInteger[7]);
+ /* BlackPrimary */
+ fh.cupsInteger[8] = htonl(r->header.cupsInteger[8]);
+ /* PrintQuality */
+ fh.cupsInteger[14] = htonl(r->header.cupsInteger[14]);
+ /* VendorIdentifier */
+ fh.cupsInteger[15] = htonl(r->header.cupsInteger[15]);
+ /* VendorLength */
+
+ void *dst = fh.cupsReal; /* Bypass bogus compiler warning */
+ void *src = r->header.cupsReal;
+ memcpy(dst, src, sizeof(fh.cupsReal) + sizeof(fh.cupsString));
+ /* VendorData */
+
+ strlcpy(fh.cupsRenderingIntent, r->header.cupsRenderingIntent,
+ sizeof(fh.cupsRenderingIntent));
+ strlcpy(fh.cupsPageSizeName, r->header.cupsPageSizeName,
+ sizeof(fh.cupsPageSizeName));
+
+ return (cups_raster_io(r, (unsigned char *)&fh, sizeof(fh)) == sizeof(fh));
+ }
+ else
+ return (cups_raster_io(r, (unsigned char *)&(r->header), sizeof(r->header))
+ == sizeof(r->header));
+}
+
+
+/*
+ * 'cupsRasterWriteHeader2()' - Write a raster page header from a version 2
+ * page header structure.
+ *
+ * The page header can be initialized using @link cupsRasterInterpretPPD@.
+ *
+ * @since CUPS 1.2/macOS 10.5@
+ */
+
+unsigned /* O - 1 on success, 0 on failure */
+cupsRasterWriteHeader2(
+ cups_raster_t *r, /* I - Raster stream */
+ cups_page_header2_t *h) /* I - Raster page header */
+{
+ if (r == NULL || r->mode == CUPS_RASTER_READ)
+ return (0);
+
+ /*
+ * Make a copy of the header, and compute the number of raster
+ * lines in the page image...
+ */
+
+ memcpy(&(r->header), h, sizeof(cups_page_header2_t));
+
+ if (!cups_raster_update(r))
+ return (0);
+
+ /*
+ * Write the raster header...
+ */
+
+ if (r->mode == CUPS_RASTER_WRITE_PWG)
+ {
+ /*
+ * PWG raster data is always network byte order with most of the page header
+ * zeroed.
+ */
+
+ cups_page_header2_t fh; /* File page header */
+
+ memset(&fh, 0, sizeof(fh));
+ strlcpy(fh.MediaClass, "PwgRaster", sizeof(fh.MediaClass));
+ strlcpy(fh.MediaColor, r->header.MediaColor, sizeof(fh.MediaColor));
+ strlcpy(fh.MediaType, r->header.MediaType, sizeof(fh.MediaType));
+ strlcpy(fh.OutputType, r->header.OutputType, sizeof(fh.OutputType));
+ strlcpy(fh.cupsRenderingIntent, r->header.cupsRenderingIntent,
+ sizeof(fh.cupsRenderingIntent));
+ strlcpy(fh.cupsPageSizeName, r->header.cupsPageSizeName,
+ sizeof(fh.cupsPageSizeName));
+
+ fh.CutMedia = htonl(r->header.CutMedia);
+ fh.Duplex = htonl(r->header.Duplex);
+ fh.HWResolution[0] = htonl(r->header.HWResolution[0]);
+ fh.HWResolution[1] = htonl(r->header.HWResolution[1]);
+ fh.ImagingBoundingBox[0] = htonl(r->header.ImagingBoundingBox[0]);
+ fh.ImagingBoundingBox[1] = htonl(r->header.ImagingBoundingBox[1]);
+ fh.ImagingBoundingBox[2] = htonl(r->header.ImagingBoundingBox[2]);
+ fh.ImagingBoundingBox[3] = htonl(r->header.ImagingBoundingBox[3]);
+ fh.InsertSheet = htonl(r->header.InsertSheet);
+ fh.Jog = htonl(r->header.Jog);
+ fh.LeadingEdge = htonl(r->header.LeadingEdge);
+ fh.ManualFeed = htonl(r->header.ManualFeed);
+ fh.MediaPosition = htonl(r->header.MediaPosition);
+ fh.MediaWeight = htonl(r->header.MediaWeight);
+ fh.NumCopies = htonl(r->header.NumCopies);
+ fh.Orientation = htonl(r->header.Orientation);
+ fh.PageSize[0] = htonl(r->header.PageSize[0]);
+ fh.PageSize[1] = htonl(r->header.PageSize[1]);
+ fh.Tumble = htonl(r->header.Tumble);
+ fh.cupsWidth = htonl(r->header.cupsWidth);
+ fh.cupsHeight = htonl(r->header.cupsHeight);
+ fh.cupsBitsPerColor = htonl(r->header.cupsBitsPerColor);
+ fh.cupsBitsPerPixel = htonl(r->header.cupsBitsPerPixel);
+ fh.cupsBytesPerLine = htonl(r->header.cupsBytesPerLine);
+ fh.cupsColorOrder = htonl(r->header.cupsColorOrder);
+ fh.cupsColorSpace = htonl(r->header.cupsColorSpace);
+ fh.cupsNumColors = htonl(r->header.cupsNumColors);
+ fh.cupsInteger[0] = htonl(r->header.cupsInteger[0]);
+ fh.cupsInteger[1] = htonl(r->header.cupsInteger[1]);
+ fh.cupsInteger[2] = htonl(r->header.cupsInteger[2]);
+ fh.cupsInteger[3] = htonl((unsigned)(r->header.cupsImagingBBox[0] * r->header.HWResolution[0] / 72.0));
+ fh.cupsInteger[4] = htonl((unsigned)(r->header.cupsImagingBBox[1] * r->header.HWResolution[1] / 72.0));
+ fh.cupsInteger[5] = htonl((unsigned)(r->header.cupsImagingBBox[2] * r->header.HWResolution[0] / 72.0));
+ fh.cupsInteger[6] = htonl((unsigned)(r->header.cupsImagingBBox[3] * r->header.HWResolution[1] / 72.0));
+ fh.cupsInteger[7] = htonl(0xffffff);
+
+ return (cups_raster_io(r, (unsigned char *)&fh, sizeof(fh)) == sizeof(fh));
+ }
+ else
+ return (cups_raster_io(r, (unsigned char *)&(r->header), sizeof(r->header))
+ == sizeof(r->header));
+}
+
+
+/*
+ * 'cupsRasterWritePixels()' - Write raster pixels.
+ *
+ * For best performance, filters should write one or more whole lines.
+ * The "cupsBytesPerLine" value from the page header can be used to allocate
+ * the line buffer and as the number of bytes to write.
+ */
+
+unsigned /* O - Number of bytes written */
+cupsRasterWritePixels(cups_raster_t *r, /* I - Raster stream */
+ unsigned char *p, /* I - Bytes to write */
+ unsigned len)/* I - Number of bytes to write */
+{
+ ssize_t bytes; /* Bytes read */
+ unsigned remaining; /* Bytes remaining */
+
+
+ DEBUG_printf(("cupsRasterWritePixels(r=%p, p=%p, len=%u), remaining=%u", (void *)r, (void *)p, len, r->remaining));
+
+ if (r == NULL || r->mode == CUPS_RASTER_READ || r->remaining == 0)
+ return (0);
+
+ if (!r->compressed)
+ {
+ /*
+ * Without compression, just write the raster data raw unless the data needs
+ * to be swapped...
+ */
+
+ r->remaining -= len / r->header.cupsBytesPerLine;
+
+ if (r->swapped &&
+ (r->header.cupsBitsPerColor == 16 ||
+ r->header.cupsBitsPerPixel == 12 ||
+ r->header.cupsBitsPerPixel == 16))
+ {
+ unsigned char *bufptr; /* Pointer into write buffer */
+ unsigned count; /* Remaining count */
+
+ /*
+ * Allocate a write buffer as needed...
+ */
+
+ if ((size_t)len > r->bufsize)
+ {
+ if (r->buffer)
+ bufptr = realloc(r->buffer, len);
+ else
+ bufptr = malloc(len);
+
+ if (!bufptr)
+ return (0);
+
+ r->buffer = bufptr;
+ r->bufsize = len;
+ }
+
+ /*
+ * Byte swap the pixels...
+ */
+
+ for (bufptr = r->buffer, count = len; count > 1; count -= 2, bufptr += 2)
+ {
+ bufptr[1] = *p++;
+ bufptr[0] = *p++;
+ }
+
+ if (count) /* This should never happen... */
+ *bufptr = *p;
+
+ /*
+ * Write the byte-swapped buffer...
+ */
+
+ bytes = cups_raster_io(r, r->buffer, len);
+ }
+ else
+ bytes = cups_raster_io(r, p, len);
+
+ if (bytes < len)
+ return (0);
+ else
+ return (len);
+ }
+
+ /*
+ * Otherwise, compress each line...
+ */
+
+ for (remaining = len; remaining > 0; remaining -= (unsigned)bytes, p += bytes)
+ {
+ /*
+ * Figure out the number of remaining bytes on the current line...
+ */
+
+ if ((bytes = (ssize_t)remaining) > (ssize_t)(r->pend - r->pcurrent))
+ bytes = (ssize_t)(r->pend - r->pcurrent);
+
+ if (r->count > 0)
+ {
+ /*
+ * Check to see if this line is the same as the previous line...
+ */
+
+ if (memcmp(p, r->pcurrent, (size_t)bytes))
+ {
+ if (cups_raster_write(r, r->pixels) <= 0)
+ return (0);
+
+ r->count = 0;
+ }
+ else
+ {
+ /*
+ * Mark more bytes as the same...
+ */
+
+ r->pcurrent += bytes;
+
+ if (r->pcurrent >= r->pend)
+ {
+ /*
+ * Increase the repeat count...
+ */
+
+ r->count ++;
+ r->pcurrent = r->pixels;
+
+ /*
+ * Flush out this line if it is the last one...
+ */
+
+ r->remaining --;
+
+ if (r->remaining == 0)
+ {
+ if (cups_raster_write(r, r->pixels) <= 0)
+ return (0);
+ else
+ return (len);
+ }
+ else if (r->count == 256)
+ {
+ if (cups_raster_write(r, r->pixels) <= 0)
+ return (0);
+
+ r->count = 0;
+ }
+ }
+
+ continue;
+ }
+ }
+
+ if (r->count == 0)
+ {
+ /*
+ * Copy the raster data to the buffer...
+ */
+
+ memcpy(r->pcurrent, p, (size_t)bytes);
+
+ r->pcurrent += bytes;
+
+ if (r->pcurrent >= r->pend)
+ {
+ /*
+ * Increase the repeat count...
+ */
+
+ r->count ++;
+ r->pcurrent = r->pixels;
+
+ /*
+ * Flush out this line if it is the last one...
+ */
+
+ r->remaining --;
+
+ if (r->remaining == 0)
+ {
+ if (cups_raster_write(r, r->pixels) <= 0)
+ return (0);
+ }
+ }
+ }
+ }
+
+ return (len);
+}
+
+
+/*
+ * 'cups_raster_read_header()' - Read a raster page header.
+ */
+
+static unsigned /* O - 1 on success, 0 on fail */
+cups_raster_read_header(
+ cups_raster_t *r) /* I - Raster stream */
+{
+ size_t len; /* Length for read/swap */
+
+
+ DEBUG_printf(("3cups_raster_read_header(r=%p), r->mode=%d", (void *)r, r ? r->mode : 0));
+
+ if (r == NULL || r->mode != CUPS_RASTER_READ)
+ return (0);
+
+ DEBUG_printf(("4cups_raster_read_header: r->iocount=" CUPS_LLFMT, CUPS_LLCAST r->iocount));
+
+ /*
+ * Get the length of the raster header...
+ */
+
+ if (r->sync == CUPS_RASTER_SYNCv1 || r->sync == CUPS_RASTER_REVSYNCv1)
+ len = sizeof(cups_page_header_t);
+ else
+ len = sizeof(cups_page_header2_t);
+
+ DEBUG_printf(("4cups_raster_read_header: len=%d", (int)len));
+
+ /*
+ * Read the header...
+ */
+
+ memset(&(r->header), 0, sizeof(r->header));
+
+ if (cups_raster_read(r, (unsigned char *)&(r->header), len) < (ssize_t)len)
+ {
+ DEBUG_printf(("4cups_raster_read_header: EOF, r->iocount=" CUPS_LLFMT, CUPS_LLCAST r->iocount));
+ return (0);
+ }
+
+ /*
+ * Swap bytes as needed...
+ */
+
+ if (r->swapped)
+ {
+ unsigned *s, /* Current word */
+ temp; /* Temporary copy */
+
+
+ DEBUG_puts("4cups_raster_read_header: Swapping header bytes.");
+
+ for (len = 81, s = &(r->header.AdvanceDistance);
+ len > 0;
+ len --, s ++)
+ {
+ temp = *s;
+ *s = ((temp & 0xff) << 24) |
+ ((temp & 0xff00) << 8) |
+ ((temp & 0xff0000) >> 8) |
+ ((temp & 0xff000000) >> 24);
+
+ DEBUG_printf(("4cups_raster_read_header: %08x => %08x", temp, *s));
+ }
+ }
+
+ /*
+ * Update the header and row count...
+ */
+
+ if (!cups_raster_update(r))
+ return (0);
+
+ DEBUG_printf(("4cups_raster_read_header: cupsBitsPerPixel=%u, cupsBitsPerColor=%u, cupsBytesPerLine=%u, cupsWidth=%u, cupsHeight=%u, r->bpp=%d", r->header.cupsBitsPerPixel, r->header.cupsBitsPerColor, r->header.cupsBytesPerLine, r->header.cupsWidth, r->header.cupsHeight, r->bpp));
+
+ return (r->header.cupsBitsPerPixel > 0 && r->header.cupsBitsPerPixel <= 240 && r->header.cupsBitsPerColor > 0 && r->header.cupsBitsPerColor <= 16 && r->header.cupsBytesPerLine > 0 && r->header.cupsBytesPerLine <= 0x7fffffff && r->header.cupsHeight != 0 && (r->header.cupsBytesPerLine % r->bpp) == 0);
+}
+
+
+/*
+ * 'cups_raster_io()' - Read/write bytes from a context, handling interruptions.
+ */
+
+static ssize_t /* O - Bytes read/write or -1 */
+cups_raster_io(cups_raster_t *r, /* I - Raster stream */
+ unsigned char *buf, /* I - Buffer for read/write */
+ size_t bytes) /* I - Number of bytes to read/write */
+{
+ ssize_t count, /* Number of bytes read/written */
+ total; /* Total bytes read/written */
+
+
+ DEBUG_printf(("5cups_raster_io(r=%p, buf=%p, bytes=" CUPS_LLFMT ")", (void *)r, (void *)buf, CUPS_LLCAST bytes));
+
+ for (total = 0; total < (ssize_t)bytes; total += count, buf += count)
+ {
+ count = (*r->iocb)(r->ctx, buf, bytes - (size_t)total);
+
+ DEBUG_printf(("6cups_raster_io: count=%d, total=%d", (int)count, (int)total));
+ if (count == 0)
+ {
+ DEBUG_puts("6cups_raster_io: Returning 0.");
+ return (0);
+ }
+ else if (count < 0)
+ {
+ DEBUG_puts("6cups_raster_io: Returning -1 on error.");
+ return (-1);
+ }
+
+#ifdef DEBUG
+ r->iocount += (size_t)count;
+#endif /* DEBUG */
+ }
+
+ DEBUG_printf(("6cups_raster_io: Returning " CUPS_LLFMT ".", CUPS_LLCAST total));
+
+ return (total);
+}
+
+
+/*
+ * 'cups_raster_read()' - Read through the raster buffer.
+ */
+
+static ssize_t /* O - Number of bytes read */
+cups_raster_read(cups_raster_t *r, /* I - Raster stream */
+ unsigned char *buf, /* I - Buffer */
+ size_t bytes) /* I - Number of bytes to read */
+{
+ ssize_t count, /* Number of bytes read */
+ remaining, /* Remaining bytes in buffer */
+ total; /* Total bytes read */
+
+
+ DEBUG_printf(("5cups_raster_read(r=%p, buf=%p, bytes=" CUPS_LLFMT ")", (void *)r, (void *)buf, CUPS_LLCAST bytes));
+
+ if (!r->compressed)
+ return (cups_raster_io(r, buf, bytes));
+
+ /*
+ * Allocate a read buffer as needed...
+ */
+
+ count = (ssize_t)(2 * r->header.cupsBytesPerLine);
+ if (count < 65536)
+ count = 65536;
+
+ if ((size_t)count > r->bufsize)
+ {
+ ssize_t offset = r->bufptr - r->buffer;
+ /* Offset to current start of buffer */
+ ssize_t end = r->bufend - r->buffer;/* Offset to current end of buffer */
+ unsigned char *rptr; /* Pointer in read buffer */
+
+ if (r->buffer)
+ rptr = realloc(r->buffer, (size_t)count);
+ else
+ rptr = malloc((size_t)count);
+
+ if (!rptr)
+ return (0);
+
+ r->buffer = rptr;
+ r->bufptr = rptr + offset;
+ r->bufend = rptr + end;
+ r->bufsize = (size_t)count;
+ }
+
+ /*
+ * Loop until we have read everything...
+ */
+
+ for (total = 0, remaining = (int)(r->bufend - r->bufptr);
+ total < (ssize_t)bytes;
+ total += count, buf += count)
+ {
+ count = (ssize_t)bytes - total;
+
+ DEBUG_printf(("6cups_raster_read: count=" CUPS_LLFMT ", remaining=" CUPS_LLFMT ", buf=%p, bufptr=%p, bufend=%p", CUPS_LLCAST count, CUPS_LLCAST remaining, (void *)buf, (void *)r->bufptr, (void *)r->bufend));
+
+ if (remaining == 0)
+ {
+ if (count < 16)
+ {
+ /*
+ * Read into the raster buffer and then copy...
+ */
+
+ remaining = (*r->iocb)(r->ctx, r->buffer, r->bufsize);
+ if (remaining <= 0)
+ return (0);
+
+ r->bufptr = r->buffer;
+ r->bufend = r->buffer + remaining;
+
+#ifdef DEBUG
+ r->iocount += (size_t)remaining;
+#endif /* DEBUG */
+ }
+ else
+ {
+ /*
+ * Read directly into "buf"...
+ */
+
+ count = (*r->iocb)(r->ctx, buf, (size_t)count);
+
+ if (count <= 0)
+ return (0);
+
+#ifdef DEBUG
+ r->iocount += (size_t)count;
+#endif /* DEBUG */
+
+ continue;
+ }
+ }
+
+ /*
+ * Copy bytes from raster buffer to "buf"...
+ */
+
+ if (count > remaining)
+ count = remaining;
+
+ if (count == 1)
+ {
+ /*
+ * Copy 1 byte...
+ */
+
+ *buf = *(r->bufptr)++;
+ remaining --;
+ }
+ else if (count < 128)
+ {
+ /*
+ * Copy up to 127 bytes without using memcpy(); this is
+ * faster because it avoids an extra function call and is
+ * often further optimized by the compiler...
+ */
+
+ unsigned char *bufptr; /* Temporary buffer pointer */
+
+ remaining -= count;
+
+ for (bufptr = r->bufptr; count > 0; count --, total ++)
+ *buf++ = *bufptr++;
+
+ r->bufptr = bufptr;
+ }
+ else
+ {
+ /*
+ * Use memcpy() for a large read...
+ */
+
+ memcpy(buf, r->bufptr, (size_t)count);
+ r->bufptr += count;
+ remaining -= count;
+ }
+ }
+
+ DEBUG_printf(("6cups_raster_read: Returning %ld", (long)total));
+
+ return (total);
+}
+
+
+/*
+ * 'cups_raster_update()' - Update the raster header and row count for the
+ * current page.
+ */
+
+static int /* O - 1 on success, 0 on failure */
+cups_raster_update(cups_raster_t *r) /* I - Raster stream */
+{
+ if (r->sync == CUPS_RASTER_SYNCv1 || r->sync == CUPS_RASTER_REVSYNCv1 ||
+ r->header.cupsNumColors == 0)
+ {
+ /*
+ * Set the "cupsNumColors" field according to the colorspace...
+ */
+
+ switch (r->header.cupsColorSpace)
+ {
+ case CUPS_CSPACE_W :
+ case CUPS_CSPACE_K :
+ case CUPS_CSPACE_WHITE :
+ case CUPS_CSPACE_GOLD :
+ case CUPS_CSPACE_SILVER :
+ case CUPS_CSPACE_SW :
+ r->header.cupsNumColors = 1;
+ break;
+
+ case CUPS_CSPACE_RGB :
+ case CUPS_CSPACE_CMY :
+ case CUPS_CSPACE_YMC :
+ case CUPS_CSPACE_CIEXYZ :
+ case CUPS_CSPACE_CIELab :
+ case CUPS_CSPACE_SRGB :
+ case CUPS_CSPACE_ADOBERGB :
+ 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 :
+ r->header.cupsNumColors = 3;
+ break;
+
+ case CUPS_CSPACE_RGBA :
+ case CUPS_CSPACE_RGBW :
+ case CUPS_CSPACE_CMYK :
+ case CUPS_CSPACE_YMCK :
+ case CUPS_CSPACE_KCMY :
+ case CUPS_CSPACE_GMCK :
+ case CUPS_CSPACE_GMCS :
+ r->header.cupsNumColors = 4;
+ break;
+
+ case CUPS_CSPACE_KCMYcm :
+ if (r->header.cupsBitsPerPixel < 8)
+ r->header.cupsNumColors = 6;
+ else
+ r->header.cupsNumColors = 4;
+ break;
+
+ case CUPS_CSPACE_DEVICE1 :
+ case CUPS_CSPACE_DEVICE2 :
+ case CUPS_CSPACE_DEVICE3 :
+ case CUPS_CSPACE_DEVICE4 :
+ case CUPS_CSPACE_DEVICE5 :
+ case CUPS_CSPACE_DEVICE6 :
+ case CUPS_CSPACE_DEVICE7 :
+ case CUPS_CSPACE_DEVICE8 :
+ case CUPS_CSPACE_DEVICE9 :
+ case CUPS_CSPACE_DEVICEA :
+ case CUPS_CSPACE_DEVICEB :
+ case CUPS_CSPACE_DEVICEC :
+ case CUPS_CSPACE_DEVICED :
+ case CUPS_CSPACE_DEVICEE :
+ case CUPS_CSPACE_DEVICEF :
+ r->header.cupsNumColors = r->header.cupsColorSpace -
+ CUPS_CSPACE_DEVICE1 + 1;
+ break;
+
+ default :
+ /* Unknown color space */
+ return (0);
+ }
+ }
+
+ /*
+ * Set the number of bytes per pixel/color...
+ */
+
+ if (r->header.cupsColorOrder == CUPS_ORDER_CHUNKED)
+ r->bpp = (r->header.cupsBitsPerPixel + 7) / 8;
+ else
+ r->bpp = (r->header.cupsBitsPerColor + 7) / 8;
+
+ if (r->bpp == 0)
+ r->bpp = 1;
+
+ /*
+ * Set the number of remaining rows...
+ */
+
+ if (r->header.cupsColorOrder == CUPS_ORDER_PLANAR)
+ r->remaining = r->header.cupsHeight * r->header.cupsNumColors;
+ else
+ r->remaining = r->header.cupsHeight;
+
+ /*
+ * Allocate the compression buffer...
+ */
+
+ if (r->compressed)
+ {
+ if (r->pixels != NULL)
+ free(r->pixels);
+
+ if ((r->pixels = calloc(r->header.cupsBytesPerLine, 1)) == NULL)
+ {
+ r->pcurrent = NULL;
+ r->pend = NULL;
+ r->count = 0;
+
+ return (0);
+ }
+
+ r->pcurrent = r->pixels;
+ r->pend = r->pixels + r->header.cupsBytesPerLine;
+ r->count = 0;
+ }
+
+ return (1);
+}
+
+
+/*
+ * 'cups_raster_write()' - Write a row of compressed raster data...
+ */
+
+static ssize_t /* O - Number of bytes written */
+cups_raster_write(
+ cups_raster_t *r, /* I - Raster stream */
+ const unsigned char *pixels) /* I - Pixel data to write */
+{
+ const unsigned char *start, /* Start of sequence */
+ *ptr, /* Current pointer in sequence */
+ *pend, /* End of raster buffer */
+ *plast; /* Pointer to last pixel */
+ unsigned char *wptr; /* Pointer into write buffer */
+ unsigned bpp, /* Bytes per pixel */
+ count; /* Count */
+
+
+ DEBUG_printf(("3cups_raster_write(r=%p, pixels=%p)", (void *)r, (void *)pixels));
+
+ /*
+ * Allocate a write buffer as needed...
+ */
+
+ count = r->header.cupsBytesPerLine * 2;
+ if (count < 65536)
+ count = 65536;
+
+ if ((size_t)count > r->bufsize)
+ {
+ if (r->buffer)
+ wptr = realloc(r->buffer, count);
+ else
+ wptr = malloc(count);
+
+ if (!wptr)
+ {
+ DEBUG_printf(("4cups_raster_write: Unable to allocate " CUPS_LLFMT " bytes for raster buffer: %s", CUPS_LLCAST count, strerror(errno)));
+ return (-1);
+ }
+
+ r->buffer = wptr;
+ r->bufsize = count;
+ }
+
+ /*
+ * Write the row repeat count...
+ */
+
+ bpp = r->bpp;
+ pend = pixels + r->header.cupsBytesPerLine;
+ plast = pend - bpp;
+ wptr = r->buffer;
+ *wptr++ = (unsigned char)(r->count - 1);
+
+ /*
+ * Write using a modified PackBits compression...
+ */
+
+ for (ptr = pixels; ptr < pend;)
+ {
+ start = ptr;
+ ptr += bpp;
+
+ if (ptr == pend)
+ {
+ /*
+ * Encode a single pixel at the end...
+ */
+
+ *wptr++ = 0;
+ for (count = bpp; count > 0; count --)
+ *wptr++ = *start++;
+ }
+ else if (!memcmp(start, ptr, bpp))
+ {
+ /*
+ * Encode a sequence of repeating pixels...
+ */
+
+ for (count = 2; count < 128 && ptr < plast; count ++, ptr += bpp)
+ if (memcmp(ptr, ptr + bpp, bpp))
+ break;
+
+ *wptr++ = (unsigned char)(count - 1);
+ for (count = bpp; count > 0; count --)
+ *wptr++ = *ptr++;
+ }
+ else
+ {
+ /*
+ * Encode a sequence of non-repeating pixels...
+ */
+
+ for (count = 1; count < 128 && ptr < plast; count ++, ptr += bpp)
+ if (!memcmp(ptr, ptr + bpp, bpp))
+ break;
+
+ if (ptr >= plast && count < 128)
+ {
+ count ++;
+ ptr += bpp;
+ }
+
+ *wptr++ = (unsigned char)(257 - count);
+
+ count *= bpp;
+ memcpy(wptr, start, count);
+ wptr += count;
+ }
+ }
+
+ DEBUG_printf(("4cups_raster_write: Writing " CUPS_LLFMT " bytes.", CUPS_LLCAST (wptr - r->buffer)));
+
+ return (cups_raster_io(r, r->buffer, (size_t)(wptr - r->buffer)));
+}
+
+
+/*
+ * 'cups_read_fd()' - Read bytes from a file.
+ */
+
+static ssize_t /* O - Bytes read or -1 */
+cups_read_fd(void *ctx, /* I - File descriptor as pointer */
+ unsigned char *buf, /* I - Buffer for read */
+ size_t bytes) /* I - Maximum number of bytes to read */
+{
+ int fd = (int)((intptr_t)ctx);
+ /* File descriptor */
+ ssize_t count; /* Number of bytes read */
+
+
+#ifdef WIN32 /* Sigh */
+ while ((count = read(fd, buf, (unsigned)bytes)) < 0)
+#else
+ while ((count = read(fd, buf, bytes)) < 0)
+#endif /* WIN32 */
+ if (errno != EINTR && errno != EAGAIN)
+ {
+ DEBUG_printf(("4cups_read_fd: %s", strerror(errno)));
+ return (-1);
+ }
+
+ DEBUG_printf(("4cups_read_fd: Returning %d bytes.", (int)count));
+
+ return (count);
+}
+
+
+/*
+ * 'cups_swap()' - Swap bytes in raster data...
+ */
+
+static void
+cups_swap(unsigned char *buf, /* I - Buffer to swap */
+ size_t bytes) /* I - Number of bytes to swap */
+{
+ unsigned char even, odd; /* Temporary variables */
+
+
+ bytes /= 2;
+
+ while (bytes > 0)
+ {
+ even = buf[0];
+ odd = buf[1];
+ buf[0] = odd;
+ buf[1] = even;
+
+ buf += 2;
+ bytes --;
+ }
+}
+
+
+/*
+ * 'cups_write_fd()' - Write bytes to a file.
+ */
+
+static ssize_t /* O - Bytes written or -1 */
+cups_write_fd(void *ctx, /* I - File descriptor pointer */
+ unsigned char *buf, /* I - Bytes to write */
+ size_t bytes) /* I - Number of bytes to write */
+{
+ int fd = (int)((intptr_t)ctx);
+ /* File descriptor */
+ ssize_t count; /* Number of bytes written */
+
+
+#ifdef WIN32 /* Sigh */
+ while ((count = write(fd, buf, (unsigned)bytes)) < 0)
+#else
+ while ((count = write(fd, buf, bytes)) < 0)
+#endif /* WIN32 */
+ if (errno != EINTR && errno != EAGAIN)
+ {
+ DEBUG_printf(("4cups_write_fd: %s", strerror(errno)));
+ return (-1);
+ }
+
+ return (count);
+}