/*
- * "$Id: raster.c 5192 2006-02-27 03:08:47Z mike $"
+ * "$Id: raster.c 7720 2008-07-11 22:46:21Z mike $"
*
* Raster file routines for the Common UNIX Printing System (CUPS).
*
+ * Copyright 2007-2008 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 Easy Software Products and are protected by Federal
- * copyright law. Distribution and use rights are outlined in the file
- * "LICENSE.txt" which should have been included with this file. If this
- * file is missing or damaged please contact Easy Software Products
- * at:
- *
- * Attn: CUPS Licensing Information
- * Easy Software Products
- * 44141 Airport View Drive, Suite 204
- * Hollywood, Maryland 20636 USA
- *
- * Voice: (301) 373-9600
- * EMail: cups-info@cups.org
- * WWW: http://www.cups.org
- *
- * This code and any derivative of it may be used and distributed
- * freely under the terms of the GNU General Public License when
- * used with GNU/GPL Ghostscript or its derivatives. Use of the
- * code (or any derivative of it) with software other than GNU/GPL
- * GhostScript (or its derivatives) is governed by the CUPS license
- * agreement.
+ * 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:
*
- * cupsRasterClose() - Close a raster stream.
- * cupsRasterOpen() - Open a raster stream.
- * cupsRasterReadHeader() - Read a raster page header and store it in a
- * V1 page header structure.
- * cupsRasterReadHeader2() - Read a raster page header and store it in a
- * V2 page header structure.
- * cupsRasterReadPixels() - Read raster pixels.
- * cupsRasterWriteHeader() - Write a raster page header from a V1 page
- * header structure.
- * cupsRasterWriteHeader2() - Write a raster page header from a V2 page
- * header structure.
- * cupsRasterWritePixels() - Write raster pixels.
- * cups_raster_update() - Update the raster header and row count for the
- * current page.
- * cups_raster_write() - Write a row of raster data...
- * cups_read() - Read bytes from a file.
- * cups_write() - Write bytes to a file.
+ * cupsRasterClose() - Close a raster stream.
+ * cupsRasterOpen() - Open a raster stream.
+ * cupsRasterReadHeader() - Read a raster page header and store it in a
+ * version 1 page header structure.
+ * cupsRasterReadHeader2() - Read a raster page header and store it in a
+ * version 2 page header structure.
+ * cupsRasterReadPixels() - Read raster pixels.
+ * cupsRasterWriteHeader() - Write a raster page header from a version 1
+ * page header structure.
+ * cupsRasterWriteHeader2() - Write a raster page header from a version 2
+ * page header structure.
+ * cupsRasterWritePixels() - Write raster pixels.
+ * cups_raster_read() - Read through the raster buffer.
+ * cups_raster_read_header() - Read a raster page header.
+ * cups_raster_update() - Update the raster header and row count for the
+ * current page.
+ * cups_raster_write() - Write a row of raster data...
+ * cups_read() - Read bytes from a file.
+ * cups_swap() - Swap bytes in raster data...
+ * cups_write() - Write bytes to a file.
*/
/*
* Include necessary headers...
*/
-#include "raster.h"
-#include <stdio.h>
+#include "image-private.h"
+#include <cups/debug.h>
#include <stdlib.h>
#include <errno.h>
#include <cups/string.h>
#endif /* WIN32 || __EMX__ */
+/*
+ * Private structures...
+ */
+
+struct _cups_raster_s /**** Raster stream data ****/
+{
+ unsigned sync; /* Sync word from start of stream */
+ int fd; /* File descriptor */
+ cups_mode_t mode; /* Read/write mode */
+ cups_page_header2_t header; /* Raster header for current page */
+ int 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 */
+ int bufsize; /* Buffer size */
+};
+
+
/*
* Local functions...
*/
static unsigned cups_raster_read_header(cups_raster_t *r);
+static int cups_raster_read(cups_raster_t *r, unsigned char *buf,
+ int bytes);
static void cups_raster_update(cups_raster_t *r);
-static int cups_raster_write(cups_raster_t *r);
+static int cups_raster_write(cups_raster_t *r, const unsigned char *pixels);
static int cups_read(int fd, unsigned char *buf, int bytes);
+static void cups_swap(unsigned char *buf, int bytes);
static int cups_write(int fd, const unsigned char *buf, int bytes);
/*
* 'cupsRasterClose()' - Close a raster stream.
+ *
+ * The file descriptor associated with the raster stream must be closed
+ * separately as needed.
*/
void
{
if (r != NULL)
{
+ if (r->buffer)
+ free(r->buffer);
+
if (r->pixels)
free(r->pixels);
/*
* 'cupsRasterOpen()' - Open a raster stream.
+ *
+ * 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@ or
+ * @code CUPS_RASTER_WRITE_COMPRESS@ mode can be used - compressed 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 */
+ cups_mode_t mode) /* I - Mode - @code CUPS_RASTER_READ@, @code CUPS_RASTER_WRITE@, or @code CUPS_RASTER_WRITE_COMPRESSED@ */
{
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->fd = fd;
- r->mode = mode;
+ r->mode = mode == CUPS_RASTER_WRITE_COMPRESSED ? CUPS_RASTER_WRITE : mode;
if (mode == CUPS_RASTER_READ)
{
* Open for read - get sync word...
*/
- if (cups_read(r->fd, (unsigned char *)&(r->sync), sizeof(r->sync))
- < sizeof(r->sync))
+ if (!cups_read(r->fd, (unsigned char *)&(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_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(("r->swapped=%d, r->sync=%08x\n", r->swapped, r->sync));
}
else
{
* Open for write - put sync word...
*/
- r->sync = CUPS_RASTER_SYNC;
+ if (mode == CUPS_RASTER_WRITE_COMPRESSED)
+ {
+ r->compressed = 1;
+ r->sync = CUPS_RASTER_SYNCv2;
+ }
+ else
+ r->sync = CUPS_RASTER_SYNC;
+
if (cups_write(r->fd, (unsigned char *)&(r->sync), sizeof(r->sync))
< sizeof(r->sync))
{
+ _cupsRasterAddError("Unable to write raster stream header: %s\n",
+ strerror(errno));
free(r);
return (NULL);
}
/*
* 'cupsRasterReadHeader()' - Read a raster page header and store it in a
- * V1 page header structure.
+ * 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 fail */
+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 */
/*
* 'cupsRasterReadHeader2()' - Read a raster page header and store it in a
- * V2 page header structure.
+ * version 2 page header structure.
*
- * @since CUPS 1.2@
+ * @since CUPS 1.2/Mac OS X 10.5@
*/
-unsigned /* O - 1 on success, 0 on fail */
+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 */
/*
* '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 */
unsigned len) /* I - Number of bytes to read */
{
int bytes; /* Bytes read */
+ unsigned cupsBytesPerLine; /* cupsBytesPerLine value */
unsigned remaining; /* Bytes remaining */
unsigned char *ptr, /* Pointer to read buffer */
- byte; /* Byte from file */
+ byte, /* Byte from file */
+ *temp; /* Pointer into buffer */
+ int count; /* Repetition count */
if (r == NULL || r->mode != CUPS_RASTER_READ || r->remaining == 0)
return (0);
- remaining = len;
+ if (!r->compressed)
+ {
+ /*
+ * Read without compression...
+ */
+
+ r->remaining -= len / r->header.cupsBytesPerLine;
+
+ if (!cups_read(r->fd, p, len))
+ return (0);
+
+ /*
+ * Swap bytes as needed...
+ */
+
+ if ((r->header.cupsBitsPerColor == 16 ||
+ r->header.cupsBitsPerPixel == 12 ||
+ r->header.cupsBitsPerPixel == 16) &&
+ r->swapped)
+ cups_swap(p, len);
+
+ /*
+ * Return...
+ */
+
+ return (len);
+ }
+
+ /*
+ * Read compressed data...
+ */
+
+ remaining = len;
+ cupsBytesPerLine = r->header.cupsBytesPerLine;
while (remaining > 0 && r->remaining > 0)
{
* Need to read a new row...
*/
- if (remaining == r->header.cupsBytesPerLine)
+ if (remaining == cupsBytesPerLine)
ptr = p;
else
ptr = r->pixels;
- if (r->sync == CUPS_RASTER_SYNCv1 || r->sync == CUPS_RASTER_REVSYNCv1)
- {
- /*
- * Read without compression...
- */
+ /*
+ * Read using a modified TIFF "packbits" compression...
+ */
- if (cups_read(r->fd, ptr, r->header.cupsBytesPerLine) <
- r->header.cupsBytesPerLine)
- return (0);
+ if (!cups_raster_read(r, &byte, 1))
+ return (0);
- r->count = 1;
- }
- else
+ r->count = byte + 1;
+
+ if (r->count > 1)
+ ptr = r->pixels;
+
+ temp = ptr;
+ bytes = cupsBytesPerLine;
+
+ while (bytes > 0)
{
/*
- * Read using a modified TIFF "packbits" compression...
+ * Get a new repeat count...
*/
- unsigned char *temp; /* Pointer into buffer */
- int count; /* Repetition count */
-
-
- if (cups_read(r->fd, &byte, 1) < 1)
+ if (!cups_raster_read(r, &byte, 1))
return (0);
- r->count = byte + 1;
-
- if (r->count > 1)
- ptr = r->pixels;
-
- temp = ptr;
- bytes = r->header.cupsBytesPerLine;
-
- while (bytes > 0)
+ if (byte & 128)
{
/*
- * Get a new repeat count...
+ * Copy N literal pixels...
*/
- if (cups_read(r->fd, &byte, 1) < 1)
- return (0);
-
- if (byte & 128)
- {
- /*
- * Copy N literal pixels...
- */
+ count = (257 - byte) * r->bpp;
- count = (257 - byte) * r->bpp;
+ if (count > bytes)
+ count = bytes;
- if (count > bytes)
- count = bytes;
+ if (!cups_raster_read(r, temp, count))
+ return (0);
- if (cups_read(r->fd, temp, count) < count)
- return (0);
+ temp += count;
+ bytes -= count;
+ }
+ else
+ {
+ /*
+ * Repeat the next N bytes...
+ */
- temp += count;
- bytes -= count;
- }
- else
- {
- /*
- * Repeat the next N bytes...
- */
+ count = (byte + 1) * r->bpp;
+ if (count > bytes)
+ count = bytes;
- count = (byte + 1) * r->bpp;
- if (count > bytes)
- count = bytes;
+ if (count < r->bpp)
+ break;
- if (count < r->bpp)
- break;
+ bytes -= count;
- bytes -= count;
+ if (!cups_raster_read(r, temp, r->bpp))
+ return (0);
- if (cups_read(r->fd, temp, r->bpp) < r->bpp)
- return (0);
+ temp += r->bpp;
+ count -= r->bpp;
+ while (count > 0)
+ {
+ memcpy(temp, temp - r->bpp, r->bpp);
temp += r->bpp;
count -= r->bpp;
-
- while (count > 0)
- {
- memcpy(temp, temp - r->bpp, r->bpp);
- temp += r->bpp;
- count -= r->bpp;
- }
- }
+ }
}
}
- if (r->header.cupsBitsPerColor == 16 &&
- (r->sync == CUPS_RASTER_REVSYNC || r->sync == CUPS_RASTER_REVSYNCv1))
- {
- /*
- * Swap bytes in the pixel data...
- */
-
- unsigned char *temp;
- int count;
+ /*
+ * Swap bytes as needed...
+ */
+ if ((r->header.cupsBitsPerColor == 16 ||
+ r->header.cupsBitsPerPixel == 12 ||
+ r->header.cupsBitsPerPixel == 16) &&
+ r->swapped)
+ cups_swap(ptr, bytes);
- for (temp = ptr, count = r->header.cupsBytesPerLine;
- count > 0;
- temp += 2, count -= 2)
- {
- byte = temp[0];
- temp[0] = temp[1];
- temp[1] = byte;
- }
- }
+ /*
+ * Update pointers...
+ */
- if (remaining >= r->header.cupsBytesPerLine)
+ if (remaining >= cupsBytesPerLine)
{
- bytes = r->header.cupsBytesPerLine;
+ bytes = cupsBytesPerLine;
r->pcurrent = r->pixels;
r->count --;
r->remaining --;
r->pcurrent = r->pixels + bytes;
}
+ /*
+ * Copy data as needed...
+ */
+
if (ptr != p)
memcpy(p, ptr, bytes);
}
/*
- * 'cupsRasterWriteHeader()' - Write a raster page header from a V1 page
+ * '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 */
/*
- * 'cupsRasterWriteHeader2()' - Write a raster page header from a V2 page
- * header structure.
+ * '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@
+ * @since CUPS 1.2/Mac OS X 10.5@
*/
unsigned /* O - 1 on success, 0 on failure */
/*
* '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 */
unsigned remaining; /* Bytes remaining */
+ DEBUG_printf(("cupsRasterWritePixels(r=%p, p=%p, len=%u), remaining=%u\n",
+ r, p, len, r->remaining));
+
if (r == NULL || r->mode != CUPS_RASTER_WRITE || r->remaining == 0)
return (0);
- remaining = len;
+ if (!r->compressed)
+ {
+ /*
+ * Without compression, just write the raster data raw...
+ */
+
+ r->remaining -= len / r->header.cupsBytesPerLine;
- while (remaining > 0)
+ return (cups_write(r->fd, p, len));
+ }
+
+ /*
+ * Otherwise, compress each line...
+ */
+
+ for (remaining = len; remaining > 0; remaining -= bytes, p += bytes)
{
/*
* Figure out the number of remaining bytes on the current line...
if (memcmp(p, r->pcurrent, bytes))
{
- if (!cups_raster_write(r))
+ if (!cups_raster_write(r, r->pixels))
return (0);
r->count = 0;
*/
r->remaining --;
+
if (r->remaining == 0)
- return (cups_raster_write(r));
+ return (cups_raster_write(r, r->pixels));
else if (r->count == 256)
{
- cups_raster_write(r);
+ if (cups_raster_write(r, r->pixels) == 0)
+ return (0);
+
r->count = 0;
}
}
+
+ continue;
}
}
*/
r->remaining --;
+
if (r->remaining == 0)
- return (cups_raster_write(r));
+ return (cups_raster_write(r, r->pixels));
}
}
-
- remaining -= bytes;
- p += bytes;
}
return (len);
cups_raster_read_header(
cups_raster_t *r) /* I - Raster stream */
{
- int len; /* Number of words to swap */
- union swap_s /* Swapping structure */
- {
- unsigned char b[4];
- unsigned v;
- } *s;
+ int len; /* Length for read/swap */
if (r == NULL || r->mode != CUPS_RASTER_READ)
memset(&(r->header), 0, sizeof(r->header));
- if (cups_read(r->fd, (unsigned char *)&(r->header), len) < len)
+ if (cups_raster_read(r, (unsigned char *)&(r->header), len) < len)
return (0);
/*
* Swap bytes as needed...
*/
- if (r->sync == CUPS_RASTER_REVSYNC || r->sync == CUPS_RASTER_REVSYNCv1)
- for (len = 81, s = (union swap_s *)&(r->header.AdvanceDistance);
+ if (r->swapped)
+ {
+ unsigned *s, /* Current word */
+ temp; /* Temporary copy */
+
+
+ DEBUG_puts("Swapping header bytes...");
+
+ for (len = 81, s = &(r->header.AdvanceDistance);
len > 0;
len --, s ++)
- s->v = (((((s->b[3] << 8) | s->b[2]) << 8) | s->b[1]) << 8) | s->b[0];
+ {
+ DEBUG_printf(("%08x =>", *s));
+
+ temp = *s;
+ *s = ((temp & 0xff) << 24) |
+ ((temp & 0xff00) << 8) |
+ ((temp & 0xff0000) >> 8) |
+ ((temp & 0xff000000) >> 24);
+
+ DEBUG_printf((" %08x\n", *s));
+ }
+ }
/*
* Update the header and row count...
}
+/*
+ * 'cups_raster_read()' - Read through the raster buffer.
+ */
+
+static int /* O - Number of bytes read */
+cups_raster_read(cups_raster_t *r, /* I - Raster stream */
+ unsigned char *buf, /* I - Buffer */
+ int bytes) /* I - Number of bytes to read */
+{
+ int count, /* Number of bytes read */
+ remaining, /* Remaining bytes in buffer */
+ total; /* Total bytes read */
+
+
+ DEBUG_printf(("cups_raster_read(r=%p, buf=%p, bytes=%d)\n", r, buf, bytes));
+
+ if (!r->compressed)
+ return (cups_read(r->fd, buf, bytes));
+
+ /*
+ * Allocate a read buffer as needed...
+ */
+
+ count = 2 * r->header.cupsBytesPerLine;
+
+ if (count > r->bufsize)
+ {
+ int offset = r->bufptr - r->buffer; /* Offset to current start of buffer */
+ int 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, count);
+ else
+ rptr = malloc(count);
+
+ if (!rptr)
+ return (0);
+
+ r->buffer = rptr;
+ r->bufptr = rptr + offset;
+ r->bufend = rptr + end;
+ r->bufsize = count;
+ }
+
+ /*
+ * Loop until we have read everything...
+ */
+
+ for (total = 0, remaining = r->bufend - r->bufptr;
+ total < bytes;
+ total += count, buf += count)
+ {
+ count = bytes - total;
+
+ DEBUG_printf(("count=%d, remaining=%d, buf=%p, bufptr=%p, bufend=%p...\n",
+ count, remaining, buf, r->bufptr, r->bufend));
+
+ if (remaining == 0)
+ {
+ if (count < 16)
+ {
+ /*
+ * Read into the raster buffer and then copy...
+ */
+
+ remaining = cups_read(r->fd, r->buffer, r->bufsize);
+ if (remaining <= 0)
+ return (0);
+
+ r->bufptr = r->buffer;
+ r->bufend = r->buffer + remaining;
+ }
+ else
+ {
+ /*
+ * Read directly into "buf"...
+ */
+
+ count = cups_read(r->fd, buf, count);
+
+ if (count <= 0)
+ return (0);
+
+ 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, count);
+ r->bufptr += count;
+ remaining -= count;
+ }
+ }
+
+ return (total);
+}
+
+
/*
* 'cups_raster_update()' - Update the raster header and row count for the
* current page.
static void
cups_raster_update(cups_raster_t *r) /* I - Raster stream */
{
- if (r->sync == CUPS_RASTER_SYNCv1 || r->sync == CUPS_RASTER_REVSYNCv1)
+ if (r->sync == CUPS_RASTER_SYNCv1 || r->sync == CUPS_RASTER_REVSYNCv1 ||
+ r->header.cupsNumColors == 0)
{
/*
* Set the "cupsNumColors" field according to the colorspace...
case CUPS_CSPACE_WHITE :
case CUPS_CSPACE_GOLD :
case CUPS_CSPACE_SILVER :
- case CUPS_CSPACE_ICC1 :
r->header.cupsNumColors = 1;
break;
- case CUPS_CSPACE_ICC2 :
- r->header.cupsNumColors = 2;
- break;
-
case CUPS_CSPACE_RGB :
case CUPS_CSPACE_CMY :
case CUPS_CSPACE_YMC :
case CUPS_CSPACE_CIEXYZ :
case CUPS_CSPACE_CIELab :
+ case CUPS_CSPACE_ICC1 :
+ case CUPS_CSPACE_ICC2 :
case CUPS_CSPACE_ICC3 :
+ case CUPS_CSPACE_ICC4 :
+ case CUPS_CSPACE_ICC5 :
+ case CUPS_CSPACE_ICC6 :
+ case CUPS_CSPACE_ICC7 :
+ case CUPS_CSPACE_ICC8 :
+ case CUPS_CSPACE_ICC9 :
+ case CUPS_CSPACE_ICCA :
+ case CUPS_CSPACE_ICCB :
+ case CUPS_CSPACE_ICCC :
+ case CUPS_CSPACE_ICCD :
+ case CUPS_CSPACE_ICCE :
+ case CUPS_CSPACE_ICCF :
r->header.cupsNumColors = 3;
break;
case CUPS_CSPACE_KCMY :
case CUPS_CSPACE_GMCK :
case CUPS_CSPACE_GMCS :
- case CUPS_CSPACE_ICC4 :
r->header.cupsNumColors = 4;
break;
else
r->header.cupsNumColors = 4;
break;
-
- 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 = r->header.cupsColorSpace -
- CUPS_CSPACE_ICC1 + 1;
- break;
}
}
r->remaining = r->header.cupsHeight;
/*
- * Allocate the read/write buffer...
+ * Allocate the compression buffer...
*/
- if (r->pixels != NULL)
- free(r->pixels);
+ if (r->compressed)
+ {
+ if (r->pixels != NULL)
+ free(r->pixels);
- r->pixels = calloc(r->header.cupsBytesPerLine, 1);
- r->pcurrent = r->pixels;
- r->pend = r->pixels + r->header.cupsBytesPerLine;
- r->count = 0;
+ r->pixels = calloc(r->header.cupsBytesPerLine, 1);
+ r->pcurrent = r->pixels;
+ r->pend = r->pixels + r->header.cupsBytesPerLine;
+ r->count = 0;
+ }
}
/*
- * 'cups_raster_write()' - Write a row of raster data...
+ * 'cups_raster_write()' - Write a row of compressed raster data...
*/
static int /* O - Number of bytes written */
-cups_raster_write(cups_raster_t *r) /* I - Raster stream */
+cups_raster_write(
+ cups_raster_t *r, /* I - Raster stream */
+ const unsigned char *pixels) /* I - Pixel data to write */
{
- unsigned char *start, /* Start of sequence */
- *ptr, /* Current pointer in sequence */
- byte; /* Byte to write */
- int count; /* Count */
+ 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 */
+ int bpp, /* Bytes per pixel */
+ count; /* Count */
+
+ DEBUG_printf(("cups_raster_write(r=%p, pixels=%p)\n", r, pixels));
/*
- * Write the row repeat count...
+ * Allocate a write buffer as needed...
*/
- byte = r->count - 1;
+ count = r->header.cupsBytesPerLine * 2;
+ if (count > r->bufsize)
+ {
+ if (r->buffer)
+ wptr = realloc(r->buffer, count);
+ else
+ wptr = malloc(count);
- if (cups_write(r->fd, &byte, 1) < 1)
- return (0);
+ if (!wptr)
+ 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++ = r->count - 1;
/*
* Write using a modified TIFF "packbits" compression...
*/
- for (ptr = r->pixels; ptr < r->pend;)
+ for (ptr = pixels; ptr < pend;)
{
start = ptr;
- ptr += r->bpp;
+ ptr += bpp;
- if (ptr == r->pend)
+ if (ptr == pend)
{
/*
* Encode a single pixel at the end...
*/
- byte = 0;
- if (cups_write(r->fd, &byte, 1) < 1)
- return (0);
-
- if (cups_write(r->fd, start, r->bpp) < r->bpp)
- return (0);
+ *wptr++ = 0;
+ for (count = bpp; count > 0; count --)
+ *wptr++ = *start++;
}
- else if (!memcmp(start, ptr, r->bpp))
+ else if (!memcmp(start, ptr, bpp))
{
/*
* Encode a sequence of repeating pixels...
*/
- for (count = 2; count < 128 && ptr < (r->pend - r->bpp); count ++, ptr += r->bpp)
- if (memcmp(ptr, ptr + r->bpp, r->bpp) != 0)
+ for (count = 2; count < 128 && ptr < plast; count ++, ptr += bpp)
+ if (memcmp(ptr, ptr + bpp, bpp))
break;
- ptr += r->bpp;
-
- byte = count - 1;
-
- if (cups_write(r->fd, &byte, 1) < 1)
- return (0);
-
- if (cups_write(r->fd, start, r->bpp) < r->bpp)
- return (0);
+ *wptr++ = count - 1;
+ for (count = bpp; count > 0; count --)
+ *wptr++ = *ptr++;
}
else
{
* Encode a sequence of non-repeating pixels...
*/
- for (count = 1; count < 127 && ptr < (r->pend - r->bpp); count ++, ptr += r->bpp)
- if (!memcmp(ptr, ptr + r->bpp, r->bpp))
+ for (count = 1; count < 127 && ptr < plast; count ++, ptr += bpp)
+ if (!memcmp(ptr, ptr + bpp, bpp))
break;
- if (ptr >= (r->pend - r->bpp) && count < 128)
+ if (ptr >= plast && count < 128)
{
count ++;
- ptr += r->bpp;
+ ptr += bpp;
}
- byte = 257 - count;
+ *wptr++ = 257 - count;
- if (cups_write(r->fd, &byte, 1) < 1)
- return (0);
-
- count *= r->bpp;
-
- if (cups_write(r->fd, start, count) < count)
- return (0);
+ count *= bpp;
+ memcpy(wptr, start, count);
+ wptr += count;
}
}
- return (r->header.cupsBytesPerLine);
+ return (cups_write(r->fd, r->buffer, wptr - r->buffer));
}
}
+/*
+ * 'cups_swap()' - Swap bytes in raster data...
+ */
+
+static void
+cups_swap(unsigned char *buf, /* I - Buffer to swap */
+ int 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()' - Write bytes to a file.
*/
/*
- * End of "$Id: raster.c 5192 2006-02-27 03:08:47Z mike $".
+ * End of "$Id: raster.c 7720 2008-07-11 22:46:21Z mike $".
*/
projects / thirdparty / cups.git / blobdiff