/* * Imaging library stubs for CUPS. * * Copyright © 2018 by Apple Inc. * * Licensed under Apache License v2.0. See the file "LICENSE" for more * information. */ /* * Include necessary headers... */ #include "raster-private.h" /* * These stubs wrap the real functions in libcups - this allows one library to * provide all of the CUPS API functions while still supporting the old split * library organization... */ /* * Local functions... */ static ssize_t cups_read_fd(void *ctx, 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 */ { _cupsRasterDelete(r); } /* * 'cupsRasterErrorString()' - Return the last error from a raster function. * * If there are no recent errors, `NULL` is returned. * * @since CUPS 1.3/macOS 10.5@ */ const char * /* O - Last error or `NULL` */ cupsRasterErrorString(void) { return (_cupsRasterErrorString()); } /* * '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 */ { return (_cupsRasterInitPWGHeader(h, media, type, xdpi, ydpi, sides, sheet_back)); } /* * '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 (_cupsRasterNew(cups_read_fd, (void *)((intptr_t)fd), mode)); else return (_cupsRasterNew(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@ */ { return (_cupsRasterNew(iocb, ctx, mode)); } /* * '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 (!_cupsRasterReadHeader(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... */ if (!_cupsRasterReadHeader(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 */ { return (_cupsRasterReadPixels(r, p, 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 write using the private function... */ memset(&(r->header), 0, sizeof(r->header)); memcpy(&(r->header), h, sizeof(cups_page_header_t)); return (_cupsRasterWriteHeader(r)); } /* * 'cupsRasterWriteHeader2()' - Write a raster page header from a version 2 * page header structure. * * The page header can be initialized using @link cupsRasterInitPWGHeader@. * * @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)); return (_cupsRasterWriteHeader(r)); } /* * '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 */ { return (_cupsRasterWritePixels(r, p, len)); } /* * '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) return (-1); return (count); } /* * '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) return (-1); return (count); }