/*
- * "$Id: raster.c 181 2006-06-22 20:01:18Z jlovell $"
+ * "$Id$"
*
- * Raster file routines for the Common UNIX Printing System (CUPS).
+ * Raster file routines for CUPS.
*
+ * Copyright 2007-2012 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.
+ * cupsRasterOpen() - Open a raster stream using a file descriptor.
+ * cupsRasterOpenIO() - Open a raster stream using a callback function.
* cupsRasterReadHeader() - Read a raster page header and store it in a
- * V1 page header structure.
+ * version 1 page header structure.
* cupsRasterReadHeader2() - Read a raster page header and store it in a
- * V2 page header structure.
+ * version 2 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.
+ * 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_read() - Read through the raster buffer.
* 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_raster_write() - Write a row of compressed raster data...
+ * cups_read_fd() - Read bytes from a file.
* cups_swap() - Swap bytes in raster data...
- * cups_write() - Write bytes to a file.
+ * cups_write_fd() - Write bytes to a file.
*/
/*
* Include necessary headers...
*/
-#include "raster.h"
-#include <cups/debug.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <cups/string.h>
-
-#if defined(WIN32) || defined(__EMX__)
-# include <io.h>
-#else
-# include <unistd.h>
-#endif /* WIN32 || __EMX__ */
+#include <cups/raster-private.h>
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif /* HAVE_STDINT_H */
/*
struct _cups_raster_s /**** Raster stream data ****/
{
unsigned sync; /* Sync word from start of stream */
- int fd; /* File descriptor */
+ 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 */
int count, /* Current row run-length count */
unsigned char *buffer, /* Read/write buffer */
*bufptr, /* Current (read) position in buffer */
*bufend; /* End of current (read) buffer */
- int bufsize; /* Buffer size */
+ size_t bufsize; /* Buffer size */
};
* Local functions...
*/
+static int cups_raster_io(cups_raster_t *r, unsigned char *buf, int bytes);
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, const unsigned char *pixels);
-static int cups_read(int fd, unsigned char *buf, int bytes);
+static int 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, int bytes);
-static int cups_write(int fd, const unsigned char *buf, int 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
/*
- * 'cupsRasterOpen()' - Open a raster stream.
+ * '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 */
+ 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->fd = fd;
- r->mode = mode == CUPS_RASTER_WRITE_COMPRESSED ? CUPS_RASTER_WRITE : mode;
+ r->ctx = ctx;
+ r->iocb = iocb;
+ r->mode = mode;
if (mode == CUPS_RASTER_READ)
{
* Open for read - get sync word...
*/
- if (!cups_read(r->fd, (unsigned char *)&(r->sync), sizeof(r->sync)))
+ 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);
}
r->sync != CUPS_RASTER_SYNCv2 &&
r->sync != CUPS_RASTER_REVSYNCv2)
{
+ _cupsRasterAddError("Unknown raster format %08x!\n", r->sync);
free(r);
return (NULL);
}
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...
*/
- if (mode == CUPS_RASTER_WRITE_COMPRESSED)
+ switch (mode)
{
- r->compressed = 1;
- r->sync = CUPS_RASTER_SYNCv2;
+ 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;
}
- else
- r->sync = CUPS_RASTER_SYNC;
- if (cups_write(r->fd, (unsigned char *)&(r->sync), sizeof(r->sync))
+ if (cups_raster_io(r, (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 */
if (!cups_raster_read_header(r))
return (0);
-
+
/*
* Copy the header to the user-supplied buffer...
*/
/*
* '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/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 */
if (!cups_raster_read_header(r))
return (0);
-
+
/*
* Copy the header to the user-supplied buffer...
*/
/*
* '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 */
int count; /* Repetition count */
- if (r == NULL || r->mode != CUPS_RASTER_READ || r->remaining == 0)
+ if (r == NULL || r->mode != CUPS_RASTER_READ || r->remaining == 0 ||
+ r->header.cupsBytesPerLine == 0)
return (0);
if (!r->compressed)
r->remaining -= len / r->header.cupsBytesPerLine;
- if (!cups_read(r->fd, p, len))
+ if (cups_raster_io(r, p, len) < (ssize_t)len)
return (0);
/*
* Swap bytes as needed...
*/
- if ((r->header.cupsBitsPerColor == 16 ||
+ if (r->swapped &&
+ (r->header.cupsBitsPerColor == 16 ||
r->header.cupsBitsPerPixel == 12 ||
- r->header.cupsBitsPerPixel == 16) &&
- r->swapped)
+ r->header.cupsBitsPerPixel == 16))
cups_swap(p, len);
/*
ptr = r->pixels;
/*
- * Read using a modified TIFF "packbits" compression...
+ * Read using a modified PackBits compression...
*/
if (!cups_raster_read(r, &byte, 1))
* Copy fragment from buffer...
*/
- if ((bytes = r->pend - r->pcurrent) > remaining)
+ if ((unsigned)(bytes = (int)(r->pend - r->pcurrent)) > remaining)
bytes = remaining;
memcpy(p, r->pcurrent, 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 */
cupsRasterWriteHeader(
cups_raster_t *r, /* I - Raster stream */
cups_page_header_t *h) /* I - Raster page header */
{
- if (r == NULL || r->mode != CUPS_RASTER_WRITE)
+ if (r == NULL || r->mode == CUPS_RASTER_READ)
return (0);
/*
* Write the raster header...
*/
- return (cups_write(r->fd, (unsigned char *)&(r->header), sizeof(r->header))
- > 0);
+ 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 */
+
+ memcpy(fh.cupsReal, r->header.cupsReal,
+ 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 V2 page
- * header structure.
+ * 'cupsRasterWriteHeader2()' - Write a raster page header from a version 2
+ * page header structure.
*
- * @since CUPS 1.2@
+ * The page header can be initialized using @link cupsRasterInterpretPPD@.
+ *
+ * @since CUPS 1.2/OS X 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_WRITE)
+ if (r == NULL || r->mode == CUPS_RASTER_READ)
return (0);
/*
* Write the raster header...
*/
- return (cups_write(r->fd, (unsigned char *)&(r->header), sizeof(r->header))
- > 0);
+ 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]));
+ fh.cupsInteger[4] = htonl((unsigned)(r->header.cupsImagingBBox[1] *
+ r->header.HWResolution[1]));
+ fh.cupsInteger[5] = htonl((unsigned)(r->header.cupsImagingBBox[2] *
+ r->header.HWResolution[0]));
+ fh.cupsInteger[6] = htonl((unsigned)(r->header.cupsImagingBBox[3] *
+ r->header.HWResolution[1]));
+ 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 */
unsigned remaining; /* Bytes remaining */
-#ifdef DEBUG
- fprintf(stderr, "cupsRasterWritePixels(r=%p, p=%p, len=%u), remaining=%u\n",
- r, p, len, r->remaining);
-#endif /* DEBUG */
+ 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)
+ if (r == NULL || r->mode == CUPS_RASTER_READ || r->remaining == 0)
return (0);
if (!r->compressed)
{
/*
- * Without compression, just write the raster data raw...
+ * Without compression, just write the raster data raw unless the data needs
+ * to be swapped...
*/
r->remaining -= len / r->header.cupsBytesPerLine;
- return (cups_write(r->fd, p, len));
+ 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...
+ */
+
+ return (cups_raster_io(r, r->buffer, len));
+ }
+ else
+ return (cups_raster_io(r, p, len));
}
/*
* Figure out the number of remaining bytes on the current line...
*/
- if ((bytes = remaining) > (r->pend - r->pcurrent))
- bytes = r->pend - r->pcurrent;
+ if ((bytes = remaining) > (int)(r->pend - r->pcurrent))
+ bytes = (int)(r->pend - r->pcurrent);
if (r->count > 0)
{
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)
*/
if (r->swapped)
- for (len = 81, s = (union swap_s *)&(r->header.AdvanceDistance);
+ {
+ 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_update(r);
- return (1);
+ return (r->header.cupsBytesPerLine != 0 && r->header.cupsHeight != 0);
+}
+
+
+/*
+ * 'cups_raster_io()' - Read/write bytes from a context, handling interruptions.
+ */
+
+static int /* O - Bytes read or -1 */
+cups_raster_io(cups_raster_t *r, /* I - Raster stream */
+ unsigned char *buf, /* I - Buffer for read/write */
+ int bytes) /* I - Number of bytes to read/write */
+{
+ ssize_t count; /* Number of bytes read/written */
+ size_t total; /* Total bytes read/written */
+
+
+ DEBUG_printf(("4cups_raster_io(r=%p, buf=%p, bytes=%d)", r, buf, bytes));
+
+ for (total = 0; total < (size_t)bytes; total += count, buf += count)
+ {
+ count = (*r->iocb)(r->ctx, buf, bytes - total);
+
+ DEBUG_printf(("5cups_raster_io: count=%d, total=%d", (int)count,
+ (int)total));
+ if (count == 0)
+ return (0);
+ else if (count < 0)
+ return (-1);
+ }
+
+ return ((int)total);
}
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));
+ return (cups_raster_io(r, buf, bytes));
/*
* Allocate a read buffer as needed...
count = 2 * r->header.cupsBytesPerLine;
- if (count > r->bufsize)
+ if ((size_t)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 */
+ int offset = (int)(r->bufptr - r->buffer);
+ /* Offset to current start of buffer */
+ int end = (int)(r->bufend - r->buffer);
+ /* Offset to current end of buffer */
unsigned char *rptr; /* Pointer in read buffer */
if (r->buffer)
* Loop until we have read everything...
*/
- for (total = 0, remaining = r->bufend - r->bufptr;
+ for (total = 0, remaining = (int)(r->bufend - r->bufptr);
total < bytes;
total += count, buf += count)
{
* Read into the raster buffer and then copy...
*/
- remaining = cups_read(r->fd, r->buffer, r->bufsize);
+ remaining = (*r->iocb)(r->ctx, r->buffer, r->bufsize);
if (remaining <= 0)
return (0);
* Read directly into "buf"...
*/
- count = cups_read(r->fd, buf, count);
+ count = (*r->iocb)(r->ctx, buf, count);
if (count <= 0)
return (0);
unsigned char *bufptr; /* Temporary buffer pointer */
-
remaining -= count;
for (bufptr = r->bufptr; count > 0; count --, total ++)
case CUPS_CSPACE_WHITE :
case CUPS_CSPACE_GOLD :
case CUPS_CSPACE_SILVER :
+ case CUPS_CSPACE_SW :
r->header.cupsNumColors = 1;
break;
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 :
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;
}
}
*plast; /* Pointer to last pixel */
unsigned char *wptr; /* Pointer into write buffer */
int bpp, /* Bytes per pixel */
- count, /* Count */
- maxrun; /* Maximum run of 128 * bpp */
+ count; /* Count */
-#ifdef DEBUG
- fprintf(stderr, "cups_raster_write(r=%p, pixels=%p)\n", r, pixels);
-#endif /* DEBUG */
+ DEBUG_printf(("cups_raster_write(r=%p, pixels=%p)\n", r, pixels));
/*
* Allocate a write buffer as needed...
*/
count = r->header.cupsBytesPerLine * 2;
- if (count > r->bufsize)
+ if ((size_t)count > r->bufsize)
{
if (r->buffer)
wptr = realloc(r->buffer, count);
plast = pend - bpp;
wptr = r->buffer;
*wptr++ = r->count - 1;
- maxrun = 128 * bpp;
/*
- * Write using a modified TIFF "packbits" compression...
+ * Write using a modified PackBits compression...
*/
for (ptr = pixels; ptr < pend;)
* Encode a sequence of non-repeating pixels...
*/
- for (count = 1; count < 127 && ptr < plast; count ++, ptr += bpp)
+ for (count = 1; count < 128 && ptr < plast; count ++, ptr += bpp)
if (!memcmp(ptr, ptr + bpp, bpp))
break;
count ++;
ptr += bpp;
}
-
+
*wptr++ = 257 - count;
count *= bpp;
}
}
- return (cups_write(r->fd, r->buffer, wptr - r->buffer));
+ return (cups_raster_io(r, r->buffer, (int)(wptr - r->buffer)));
}
/*
- * 'cups_read()' - Read bytes from a file.
+ * 'cups_read_fd()' - Read bytes from a file.
*/
-static int /* O - Bytes read or -1 */
-cups_read(int fd, /* I - File descriptor */
- unsigned char *buf, /* I - Buffer for read */
- int bytes) /* I - Number of bytes to read */
+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 count, /* Number of bytes read */
- total; /* Total bytes read */
+ int fd = (int)((intptr_t)ctx);
+ /* File descriptor */
+ ssize_t count; /* Number of bytes read */
- for (total = 0; total < bytes; total += count, buf += count)
- {
- count = read(fd, buf, bytes - total);
-
- if (count == 0)
- return (0);
- else if (count < 0)
- {
- if (errno == EINTR)
- count = 0;
- else
- return (-1);
- }
- }
+#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)
+ return (-1);
- return (total);
+ return (count);
}
/*
- * 'cups_write()' - Write bytes to a file.
+ * 'cups_write_fd()' - Write bytes to a file.
*/
-static int /* O - Bytes written or -1 */
-cups_write(int fd, /* I - File descriptor */
- const unsigned char *buf, /* I - Bytes to write */
- int bytes) /* I - Number of bytes to write */
+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 count, /* Number of bytes written */
- total; /* Total bytes written */
+ int fd = (int)((intptr_t)ctx);
+ /* File descriptor */
+ ssize_t count; /* Number of bytes written */
- for (total = 0; total < bytes; total += count, buf += count)
- {
- count = write(fd, buf, bytes - total);
-
- if (count < 0)
- {
- if (errno == EINTR)
- count = 0;
- else
- return (-1);
- }
- }
+#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)
+ return (-1);
- return (total);
+ return (count);
}
/*
- * End of "$Id: raster.c 181 2006-06-22 20:01:18Z jlovell $".
+ * End of "$Id$".
*/
projects / thirdparty / cups.git / blobdiff