/* * Hewlett-Packard Page Control Language filter for CUPS. * * Copyright 2007-2015 by Apple Inc. * Copyright 1993-2007 by Easy Software Products. * * Licensed under Apache License v2.0. See the file "LICENSE" for more information. */ /* * Include necessary headers... */ #include #include #include #include #include #include #include #include /* * 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 */ cups_bool_t Duplex; /* Current duplex mode */ int 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(); 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); }