| /* |
| * 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); |
| } |