/*
* Hewlett-Packard Page Control Language filter for CUPS.
*
* Copyright 2007-2015 by Apple Inc.
* Copyright 1993-2007 by Easy Software Products.
*
* 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
* 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/cups.h>
#include <cups/ppd.h>
#include <cups/string-private.h>
#include <cups/language-private.h>
#include <cups/raster.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
/*
* Globals...
*/
unsigned char *Planes[4], /* Output buffers */
*CompBuffer, /* Compression buffer */
*BitBuffer; /* Buffer for output bits */
unsigned NumPlanes, /* Number of color planes */
ColorBits, /* Number of bits per color */
Feed; /* Number of lines to skip */
int Duplex, /* Current duplex mode */
Page, /* Current page number */
Canceled; /* Has the current job been canceled? */
/*
* Prototypes...
*/
void Setup(void);
void StartPage(ppd_file_t *ppd, cups_page_header2_t *header);
void EndPage(void);
void Shutdown(void);
void CancelJob(int sig);
void CompressData(unsigned char *line, unsigned length, unsigned plane, unsigned type);
void OutputLine(cups_page_header2_t *header);
/*
* 'Setup()' - Prepare the printer for printing.
*/
void
Setup(void)
{
/*
* Send a PCL reset sequence.
*/
putchar(0x1b);
putchar('E');
}
/*
* 'StartPage()' - Start a page of graphics.
*/
void
StartPage(ppd_file_t *ppd, /* I - PPD file */
cups_page_header2_t *header) /* I - Page header */
{
unsigned plane; /* Looping var */
/*
* Show page device dictionary...
*/
fprintf(stderr, "DEBUG: StartPage...\n");
fprintf(stderr, "DEBUG: Duplex = %d\n", header->Duplex);
fprintf(stderr, "DEBUG: HWResolution = [ %d %d ]\n", header->HWResolution[0], header->HWResolution[1]);
fprintf(stderr, "DEBUG: ImagingBoundingBox = [ %d %d %d %d ]\n", header->ImagingBoundingBox[0], header->ImagingBoundingBox[1], header->ImagingBoundingBox[2], header->ImagingBoundingBox[3]);
fprintf(stderr, "DEBUG: Margins = [ %d %d ]\n", header->Margins[0], header->Margins[1]);
fprintf(stderr, "DEBUG: ManualFeed = %d\n", header->ManualFeed);
fprintf(stderr, "DEBUG: MediaPosition = %d\n", header->MediaPosition);
fprintf(stderr, "DEBUG: NumCopies = %d\n", header->NumCopies);
fprintf(stderr, "DEBUG: Orientation = %d\n", header->Orientation);
fprintf(stderr, "DEBUG: PageSize = [ %d %d ]\n", header->PageSize[0], header->PageSize[1]);
fprintf(stderr, "DEBUG: cupsWidth = %d\n", header->cupsWidth);
fprintf(stderr, "DEBUG: cupsHeight = %d\n", header->cupsHeight);
fprintf(stderr, "DEBUG: cupsMediaType = %d\n", header->cupsMediaType);
fprintf(stderr, "DEBUG: cupsBitsPerColor = %d\n", header->cupsBitsPerColor);
fprintf(stderr, "DEBUG: cupsBitsPerPixel = %d\n", header->cupsBitsPerPixel);
fprintf(stderr, "DEBUG: cupsBytesPerLine = %d\n", header->cupsBytesPerLine);
fprintf(stderr, "DEBUG: cupsColorOrder = %d\n", header->cupsColorOrder);
fprintf(stderr, "DEBUG: cupsColorSpace = %d\n", header->cupsColorSpace);
fprintf(stderr, "DEBUG: cupsCompression = %d\n", header->cupsCompression);
/*
* Setup printer/job attributes...
*/
Duplex = header->Duplex;
ColorBits = header->cupsBitsPerColor;
if ((!Duplex || (Page & 1)) && header->MediaPosition)
printf("\033&l%dH", /* Set media position */
header->MediaPosition);
if (Duplex && ppd && ppd->model_number == 2)
{
/*
* Handle duplexing on new DeskJet printers...
*/
printf("\033&l-2H"); /* Load media */
if (Page & 1)
printf("\033&l2S"); /* Set duplex mode */
}
if (!Duplex || (Page & 1) || (ppd && ppd->model_number == 2))
{
/*
* Set the media size...
*/
printf("\033&l6D\033&k12H"); /* Set 6 LPI, 10 CPI */
printf("\033&l0O"); /* Set portrait orientation */
switch (header->PageSize[1])
{
case 540 : /* Monarch Envelope */
printf("\033&l80A"); /* Set page size */
break;
case 595 : /* A5 */
printf("\033&l25A"); /* Set page size */
break;
case 624 : /* DL Envelope */
printf("\033&l90A"); /* Set page size */
break;
case 649 : /* C5 Envelope */
printf("\033&l91A"); /* Set page size */
break;
case 684 : /* COM-10 Envelope */
printf("\033&l81A"); /* Set page size */
break;
case 709 : /* B5 Envelope */
printf("\033&l100A"); /* Set page size */
break;
case 756 : /* Executive */
printf("\033&l1A"); /* Set page size */
break;
case 792 : /* Letter */
printf("\033&l2A"); /* Set page size */
break;
case 842 : /* A4 */
printf("\033&l26A"); /* Set page size */
break;
case 1008 : /* Legal */
printf("\033&l3A"); /* Set page size */
break;
case 1191 : /* A3 */
printf("\033&l27A"); /* Set page size */
break;
case 1224 : /* Tabloid */
printf("\033&l6A"); /* Set page size */
break;
}
printf("\033&l%dP", /* Set page length */
header->PageSize[1] / 12);
printf("\033&l0E"); /* Set top margin to 0 */
}
if (!Duplex || (Page & 1))
{
/*
* Set other job options...
*/
printf("\033&l%dX", header->NumCopies); /* Set number copies */
if (header->cupsMediaType &&
(!ppd || ppd->model_number != 2 || header->HWResolution[0] == 600))
printf("\033&l%dM", /* Set media type */
header->cupsMediaType);
if (!ppd || ppd->model_number != 2)
{
int mode = Duplex ? 1 + header->Tumble != 0 : 0;
printf("\033&l%dS", mode); /* Set duplex mode */
printf("\033&l0L"); /* Turn off perforation skip */
}
}
else if (!ppd || ppd->model_number != 2)
printf("\033&a2G"); /* Set back side */
/*
* Set graphics mode...
*/
if (ppd && ppd->model_number == 2)
{
/*
* Figure out the number of color planes...
*/
if (header->cupsColorSpace == CUPS_CSPACE_KCMY)
NumPlanes = 4;
else
NumPlanes = 1;
/*
* Set the resolution and top-of-form...
*/
printf("\033&u%dD", header->HWResolution[0]);
/* Resolution */
printf("\033&l0e0L"); /* Reset top and don't skip */
printf("\033*p0Y\033*p0X"); /* Set top of form */
/*
* Send 26-byte configure image data command with horizontal and
* vertical resolutions as well as a color count...
*/
printf("\033*g26W");
putchar(2); /* Format 2 */
putchar((int)NumPlanes); /* Output planes */
putchar((int)(header->HWResolution[0] >> 8));/* Black resolution */
putchar((int)header->HWResolution[0]);
putchar((int)(header->HWResolution[1] >> 8));
putchar((int)header->HWResolution[1]);
putchar(0);
putchar(1 << ColorBits); /* # of black levels */
putchar((int)(header->HWResolution[0] >> 8));/* Cyan resolution */
putchar((int)header->HWResolution[0]);
putchar((int)(header->HWResolution[1] >> 8));
putchar((int)header->HWResolution[1]);
putchar(0);
putchar(1 << ColorBits); /* # of cyan levels */
putchar((int)(header->HWResolution[0] >> 8));/* Magenta resolution */
putchar((int)header->HWResolution[0]);
putchar((int)(header->HWResolution[1] >> 8));
putchar((int)header->HWResolution[1]);
putchar(0);
putchar(1 << ColorBits); /* # of magenta levels */
putchar((int)(header->HWResolution[0] >> 8));/* Yellow resolution */
putchar((int)header->HWResolution[0]);
putchar((int)(header->HWResolution[1] >> 8));
putchar((int)header->HWResolution[1]);
putchar(0);
putchar(1 << ColorBits); /* # of yellow levels */
printf("\033&l0H"); /* Set media position */
}
else
{
printf("\033*t%uR", header->HWResolution[0]);
/* Set resolution */
if (header->cupsColorSpace == CUPS_CSPACE_KCMY)
{
NumPlanes = 4;
printf("\033*r-4U"); /* Set KCMY graphics */
}
else if (header->cupsColorSpace == CUPS_CSPACE_CMY)
{
NumPlanes = 3;
printf("\033*r-3U"); /* Set CMY graphics */
}
else
NumPlanes = 1; /* Black&white graphics */
/*
* Set size and position of graphics...
*/
printf("\033*r%uS", header->cupsWidth); /* Set width */
printf("\033*r%uT", header->cupsHeight); /* Set height */
printf("\033&a0H"); /* Set horizontal position */
if (ppd)
printf("\033&a%.0fV", /* Set vertical position */
10.0 * (ppd->sizes[0].length - ppd->sizes[0].top));
else
printf("\033&a0V"); /* Set top-of-page */
}
printf("\033*r1A"); /* Start graphics */
if (header->cupsCompression)
printf("\033*b%uM", /* Set compression */
header->cupsCompression);
Feed = 0; /* No blank lines yet */
/*
* Allocate memory for a line of graphics...
*/
if ((Planes[0] = malloc(header->cupsBytesPerLine + NumPlanes)) == NULL)
{
fputs("ERROR: Unable to allocate memory\n", stderr);
exit(1);
}
for (plane = 1; plane < NumPlanes; plane ++)
Planes[plane] = Planes[0] + plane * header->cupsBytesPerLine / NumPlanes;
if (ColorBits > 1)
BitBuffer = malloc(ColorBits * ((header->cupsWidth + 7) / 8));
else
BitBuffer = NULL;
if (header->cupsCompression)
CompBuffer = malloc(header->cupsBytesPerLine * 2 + 2);
else
CompBuffer = NULL;
}
/*
* 'EndPage()' - Finish a page of graphics.
*/
void
EndPage(void)
{
/*
* Eject the current page...
*/
if (NumPlanes > 1)
{
printf("\033*rC"); /* End color GFX */
if (!(Duplex && (Page & 1)))
printf("\033&l0H"); /* Eject current page */
}
else
{
printf("\033*r0B"); /* End GFX */
if (!(Duplex && (Page & 1)))
printf("\014"); /* Eject current page */
}
fflush(stdout);
/*
* Free memory...
*/
free(Planes[0]);
if (BitBuffer)
free(BitBuffer);
if (CompBuffer)
free(CompBuffer);
}
/*
* 'Shutdown()' - Shutdown the printer.
*/
void
Shutdown(void)
{
/*
* Send a PCL reset sequence.
*/
putchar(0x1b);
putchar('E');
}
/*
* 'CancelJob()' - Cancel the current job...
*/
void
CancelJob(int sig) /* I - Signal */
{
(void)sig;
Canceled = 1;
}
/*
* 'CompressData()' - Compress a line of graphics.
*/
void
CompressData(unsigned char *line, /* I - Data to compress */
unsigned length, /* I - Number of bytes */
unsigned plane, /* I - Color plane */
unsigned type) /* I - Type of compression */
{
unsigned char *line_ptr, /* Current byte pointer */
*line_end, /* End-of-line byte pointer */
*comp_ptr, /* Pointer into compression buffer */
*start; /* Start of compression sequence */
unsigned count; /* Count of bytes for output */
switch (type)
{
default :
/*
* Do no compression...
*/
line_ptr = line;
line_end = line + length;
break;
case 1 :
/*
* Do run-length encoding...
*/
line_end = line + length;
for (line_ptr = line, comp_ptr = CompBuffer;
line_ptr < line_end;
comp_ptr += 2, line_ptr += count)
{
for (count = 1;
(line_ptr + count) < line_end &&
line_ptr[0] == line_ptr[count] &&
count < 256;
count ++);
comp_ptr[0] = (unsigned char)(count - 1);
comp_ptr[1] = line_ptr[0];
}
line_ptr = CompBuffer;
line_end = comp_ptr;
break;
case 2 :
/*
* Do TIFF pack-bits encoding...
*/
line_ptr = line;
line_end = line + length;
comp_ptr = CompBuffer;
while (line_ptr < line_end)
{
if ((line_ptr + 1) >= line_end)
{
/*
* Single byte on the end...
*/
*comp_ptr++ = 0x00;
*comp_ptr++ = *line_ptr++;
}
else if (line_ptr[0] == line_ptr[1])
{
/*
* Repeated sequence...
*/
line_ptr ++;
count = 2;
while (line_ptr < (line_end - 1) &&
line_ptr[0] == line_ptr[1] &&
count < 127)
{
line_ptr ++;
count ++;
}
*comp_ptr++ = (unsigned char)(257 - count);
*comp_ptr++ = *line_ptr++;
}
else
{
/*
* Non-repeated sequence...
*/
start = line_ptr;
line_ptr ++;
count = 1;
while (line_ptr < (line_end - 1) &&
line_ptr[0] != line_ptr[1] &&
count < 127)
{
line_ptr ++;
count ++;
}
*comp_ptr++ = (unsigned char)(count - 1);
memcpy(comp_ptr, start, count);
comp_ptr += count;
}
}
line_ptr = CompBuffer;
line_end = comp_ptr;
break;
}
/*
* Set the length of the data and write a raster plane...
*/
printf("\033*b%d%c", (int)(line_end - line_ptr), plane);
fwrite(line_ptr, (size_t)(line_end - line_ptr), 1, stdout);
}
/*
* 'OutputLine()' - Output a line of graphics.
*/
void
OutputLine(cups_page_header2_t *header) /* I - Page header */
{
unsigned plane, /* Current plane */
bytes, /* Bytes to write */
count; /* Bytes to convert */
unsigned char bit, /* Current plane data */
bit0, /* Current low bit data */
bit1, /* Current high bit data */
*plane_ptr, /* Pointer into Planes */
*bit_ptr; /* Pointer into BitBuffer */
/*
* Output whitespace as needed...
*/
if (Feed > 0)
{
printf("\033*b%dY", Feed);
Feed = 0;
}
/*
* Write bitmap data as needed...
*/
bytes = (header->cupsWidth + 7) / 8;
for (plane = 0; plane < NumPlanes; plane ++)
if (ColorBits == 1)
{
/*
* Send bits as-is...
*/
CompressData(Planes[plane], bytes, plane < (NumPlanes - 1) ? 'V' : 'W',
header->cupsCompression);
}
else
{
/*
* Separate low and high bit data into separate buffers.
*/
for (count = header->cupsBytesPerLine / NumPlanes,
plane_ptr = Planes[plane], bit_ptr = BitBuffer;
count > 0;
count -= 2, plane_ptr += 2, bit_ptr ++)
{
bit = plane_ptr[0];
bit0 = (unsigned char)(((bit & 64) << 1) | ((bit & 16) << 2) | ((bit & 4) << 3) | ((bit & 1) << 4));
bit1 = (unsigned char)((bit & 128) | ((bit & 32) << 1) | ((bit & 8) << 2) | ((bit & 2) << 3));
if (count > 1)
{
bit = plane_ptr[1];
bit0 |= (unsigned char)((bit & 1) | ((bit & 4) >> 1) | ((bit & 16) >> 2) | ((bit & 64) >> 3));
bit1 |= (unsigned char)(((bit & 2) >> 1) | ((bit & 8) >> 2) | ((bit & 32) >> 3) | ((bit & 128) >> 4));
}
bit_ptr[0] = bit0;
bit_ptr[bytes] = bit1;
}
/*
* Send low and high bits...
*/
CompressData(BitBuffer, bytes, 'V', header->cupsCompression);
CompressData(BitBuffer + bytes, bytes, plane < (NumPlanes - 1) ? 'V' : 'W',
header->cupsCompression);
}
fflush(stdout);
}
/*
* 'main()' - Main entry and processing of driver.
*/
int /* O - Exit status */
main(int argc, /* I - Number of command-line arguments */
char *argv[]) /* I - Command-line arguments */
{
int fd; /* File descriptor */
cups_raster_t *ras; /* Raster stream for printing */
cups_page_header2_t header; /* Page header from file */
unsigned y; /* Current line */
ppd_file_t *ppd; /* PPD file */
#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
struct sigaction action; /* Actions for POSIX signals */
#endif /* HAVE_SIGACTION && !HAVE_SIGSET */
/*
* Make sure status messages are not buffered...
*/
setbuf(stderr, NULL);
/*
* Check command-line...
*/
if (argc < 6 || argc > 7)
{
/*
* We don't have the correct number of arguments; write an error message
* and return.
*/
_cupsLangPrintFilter(stderr, "ERROR",
_("%s job-id user title copies options [file]"),
"rastertohp");
return (1);
}
/*
* Open the page stream...
*/
if (argc == 7)
{
if ((fd = open(argv[6], O_RDONLY)) == -1)
{
_cupsLangPrintError("ERROR", _("Unable to open raster file"));
sleep(1);
return (1);
}
}
else
fd = 0;
ras = cupsRasterOpen(fd, CUPS_RASTER_READ);
/*
* Register a signal handler to eject the current page if the
* job is cancelled.
*/
Canceled = 0;
#ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
sigset(SIGTERM, CancelJob);
#elif defined(HAVE_SIGACTION)
memset(&action, 0, sizeof(action));
sigemptyset(&action.sa_mask);
action.sa_handler = CancelJob;
sigaction(SIGTERM, &action, NULL);
#else
signal(SIGTERM, CancelJob);
#endif /* HAVE_SIGSET */
/*
* Initialize the print device...
*/
ppd = ppdOpenFile(getenv("PPD"));
if (!ppd)
{
ppd_status_t status; /* PPD error */
int linenum; /* Line number */
_cupsLangPrintFilter(stderr, "ERROR",
_("The PPD file could not be opened."));
status = ppdLastError(&linenum);
fprintf(stderr, "DEBUG: %s on line %d.\n", ppdErrorString(status), linenum);
return (1);
}
Setup();
/*
* Process pages as needed...
*/
Page = 0;
while (cupsRasterReadHeader2(ras, &header))
{
/*
* Write a status message with the page number and number of copies.
*/
if (Canceled)
break;
Page ++;
fprintf(stderr, "PAGE: %d %d\n", Page, header.NumCopies);
_cupsLangPrintFilter(stderr, "INFO", _("Starting page %d."), Page);
/*
* Start the page...
*/
StartPage(ppd, &header);
/*
* Loop for each line on the page...
*/
for (y = 0; y < header.cupsHeight; y ++)
{
/*
* Let the user know how far we have progressed...
*/
if (Canceled)
break;
if ((y & 127) == 0)
{
_cupsLangPrintFilter(stderr, "INFO",
_("Printing page %d, %u%% complete."),
Page, 100 * y / header.cupsHeight);
fprintf(stderr, "ATTR: job-media-progress=%u\n",
100 * y / header.cupsHeight);
}
/*
* Read a line of graphics...
*/
if (cupsRasterReadPixels(ras, Planes[0], header.cupsBytesPerLine) < 1)
break;
/*
* See if the line is blank; if not, write it to the printer...
*/
if (Planes[0][0] ||
memcmp(Planes[0], Planes[0] + 1, header.cupsBytesPerLine - 1))
OutputLine(&header);
else
Feed ++;
}
/*
* Eject the page...
*/
_cupsLangPrintFilter(stderr, "INFO", _("Finished page %d."), Page);
EndPage();
if (Canceled)
break;
}
/*
* Shutdown the printer...
*/
Shutdown();
if (ppd)
ppdClose(ppd);
/*
* Close the raster stream...
*/
cupsRasterClose(ras);
if (fd != 0)
close(fd);
/*
* If no pages were printed, send an error message...
*/
if (Page == 0)
{
_cupsLangPrintFilter(stderr, "ERROR", _("No pages were found."));
return (1);
}
else
return (0);
}