filter/rastertohp.c

   1 /*
   2  * Hewlett-Packard Page Control Language filter for CUPS.
   3  *
   4  * Copyright 2007-2015 by Apple Inc.
   5  * Copyright 1993-2007 by Easy Software Products.
   6  *
   7  * These coded instructions, statements, and computer programs are the
   8  * property of Apple Inc. and are protected by Federal copyright
   9  * law.  Distribution and use rights are outlined in the file "LICENSE.txt"
  10  * which should have been included with this file.  If this file is
  11  * missing or damaged, see the license at "http://www.cups.org/".
  12  *
  13  * This file is subject to the Apple OS-Developed Software exception.
  14  */
  15
  16 /*
  17  * Include necessary headers...
  18  */
  19
  20 #include <cups/cups.h>
  21 #include <cups/ppd.h>
  22 #include <cups/string-private.h>
  23 #include <cups/language-private.h>
  24 #include <cups/raster.h>
  25 #include <unistd.h>
  26 #include <fcntl.h>
  27 #include <signal.h>
  28
  29
  30 /*
  31  * Globals...
  32  */
  33
  34 unsigned char   *Planes[4],             /* Output buffers */
  35                 *CompBuffer,            /* Compression buffer */
  36                 *BitBuffer;             /* Buffer for output bits */
  37 unsigned        NumPlanes,              /* Number of color planes */
  38                 ColorBits,              /* Number of bits per color */
  39                 Feed;                   /* Number of lines to skip */
  40 int             Duplex,                 /* Current duplex mode */
  41                 Page,                   /* Current page number */
  42                 Canceled;               /* Has the current job been canceled? */
  43
  44
  45 /*
  46  * Prototypes...
  47  */
  48
  49 void    Setup(void);
  50 void    StartPage(ppd_file_t *ppd, cups_page_header2_t *header);
  51 void    EndPage(void);
  52 void    Shutdown(void);
  53
  54 void    CancelJob(int sig);
  55 void    CompressData(unsigned char *line, unsigned length, unsigned plane, unsigned type);
  56 void    OutputLine(cups_page_header2_t *header);
  57
  58
  59 /*
  60  * 'Setup()' - Prepare the printer for printing.
  61  */
  62
  63 void
  64 Setup(void)
  65 {
  66  /*
  67   * Send a PCL reset sequence.
  68   */
  69
  70   putchar(0x1b);
  71   putchar('E');
  72 }
  73
  74
  75 /*
  76  * 'StartPage()' - Start a page of graphics.
  77  */
  78
  79 void
  80 StartPage(ppd_file_t         *ppd,      /* I - PPD file */
  81           cups_page_header2_t *header)  /* I - Page header */
  82 {
  83   unsigned      plane;                  /* Looping var */
  84
  85
  86  /*
  87   * Show page device dictionary...
  88   */
  89
  90   fprintf(stderr, "DEBUG: StartPage...\n");
  91   fprintf(stderr, "DEBUG: Duplex = %d\n", header->Duplex);
  92   fprintf(stderr, "DEBUG: HWResolution = [ %d %d ]\n", header->HWResolution[0], header->HWResolution[1]);
  93   fprintf(stderr, "DEBUG: ImagingBoundingBox = [ %d %d %d %d ]\n", header->ImagingBoundingBox[0], header->ImagingBoundingBox[1], header->ImagingBoundingBox[2], header->ImagingBoundingBox[3]);
  94   fprintf(stderr, "DEBUG: Margins = [ %d %d ]\n", header->Margins[0], header->Margins[1]);
  95   fprintf(stderr, "DEBUG: ManualFeed = %d\n", header->ManualFeed);
  96   fprintf(stderr, "DEBUG: MediaPosition = %d\n", header->MediaPosition);
  97   fprintf(stderr, "DEBUG: NumCopies = %d\n", header->NumCopies);
  98   fprintf(stderr, "DEBUG: Orientation = %d\n", header->Orientation);
  99   fprintf(stderr, "DEBUG: PageSize = [ %d %d ]\n", header->PageSize[0], header->PageSize[1]);
 100   fprintf(stderr, "DEBUG: cupsWidth = %d\n", header->cupsWidth);
 101   fprintf(stderr, "DEBUG: cupsHeight = %d\n", header->cupsHeight);
 102   fprintf(stderr, "DEBUG: cupsMediaType = %d\n", header->cupsMediaType);
 103   fprintf(stderr, "DEBUG: cupsBitsPerColor = %d\n", header->cupsBitsPerColor);
 104   fprintf(stderr, "DEBUG: cupsBitsPerPixel = %d\n", header->cupsBitsPerPixel);
 105   fprintf(stderr, "DEBUG: cupsBytesPerLine = %d\n", header->cupsBytesPerLine);
 106   fprintf(stderr, "DEBUG: cupsColorOrder = %d\n", header->cupsColorOrder);
 107   fprintf(stderr, "DEBUG: cupsColorSpace = %d\n", header->cupsColorSpace);
 108   fprintf(stderr, "DEBUG: cupsCompression = %d\n", header->cupsCompression);
 109
 110  /*
 111   * Setup printer/job attributes...
 112   */
 113
 114   Duplex    = header->Duplex;
 115   ColorBits = header->cupsBitsPerColor;
 116
 117   if ((!Duplex || (Page & 1)) && header->MediaPosition)
 118     printf("\033&l%dH",                         /* Set media position */
 119            header->MediaPosition);
 120
 121   if (Duplex && ppd && ppd->model_number == 2)
 122   {
 123    /*
 124     * Handle duplexing on new DeskJet printers...
 125     */
 126
 127     printf("\033&l-2H");                        /* Load media */
 128
 129     if (Page & 1)
 130       printf("\033&l2S");                       /* Set duplex mode */
 131   }
 132
 133   if (!Duplex || (Page & 1) || (ppd && ppd->model_number == 2))
 134   {
 135    /*
 136     * Set the media size...
 137     */
 138
 139     printf("\033&l6D\033&k12H");                /* Set 6 LPI, 10 CPI */
 140     printf("\033&l0O");                         /* Set portrait orientation */
 141
 142     switch (header->PageSize[1])
 143     {
 144       case 540 : /* Monarch Envelope */
 145           printf("\033&l80A");                  /* Set page size */
 146           break;
 147
 148       case 595 : /* A5 */
 149           printf("\033&l25A");                  /* Set page size */
 150           break;
 151
 152       case 624 : /* DL Envelope */
 153           printf("\033&l90A");                  /* Set page size */
 154           break;
 155
 156       case 649 : /* C5 Envelope */
 157           printf("\033&l91A");                  /* Set page size */
 158           break;
 159
 160       case 684 : /* COM-10 Envelope */
 161           printf("\033&l81A");                  /* Set page size */
 162           break;
 163
 164       case 709 : /* B5 Envelope */
 165           printf("\033&l100A");                 /* Set page size */
 166           break;
 167
 168       case 756 : /* Executive */
 169           printf("\033&l1A");                   /* Set page size */
 170           break;
 171
 172       case 792 : /* Letter */
 173           printf("\033&l2A");                   /* Set page size */
 174           break;
 175
 176       case 842 : /* A4 */
 177           printf("\033&l26A");                  /* Set page size */
 178           break;
 179
 180       case 1008 : /* Legal */
 181           printf("\033&l3A");                   /* Set page size */
 182           break;
 183
 184       case 1191 : /* A3 */
 185           printf("\033&l27A");                  /* Set page size */
 186           break;
 187
 188       case 1224 : /* Tabloid */
 189           printf("\033&l6A");                   /* Set page size */
 190           break;
 191     }
 192
 193     printf("\033&l%dP",                         /* Set page length */
 194            header->PageSize[1] / 12);
 195     printf("\033&l0E");                         /* Set top margin to 0 */
 196   }
 197
 198   if (!Duplex || (Page & 1))
 199   {
 200    /*
 201     * Set other job options...
 202     */
 203
 204     printf("\033&l%dX", header->NumCopies);     /* Set number copies */
 205
 206     if (header->cupsMediaType &&
 207         (!ppd || ppd->model_number != 2 || header->HWResolution[0] == 600))
 208       printf("\033&l%dM",                       /* Set media type */
 209              header->cupsMediaType);
 210
 211     if (!ppd || ppd->model_number != 2)
 212     {
 213       int mode = Duplex ? 1 + header->Tumble != 0 : 0;
 214
 215       printf("\033&l%dS", mode);                /* Set duplex mode */
 216       printf("\033&l0L");                       /* Turn off perforation skip */
 217     }
 218   }
 219   else if (!ppd || ppd->model_number != 2)
 220     printf("\033&a2G");                         /* Set back side */
 221
 222  /*
 223   * Set graphics mode...
 224   */
 225
 226   if (ppd && ppd->model_number == 2)
 227   {
 228    /*
 229     * Figure out the number of color planes...
 230     */
 231
 232     if (header->cupsColorSpace == CUPS_CSPACE_KCMY)
 233       NumPlanes = 4;
 234     else
 235       NumPlanes = 1;
 236
 237    /*
 238     * Set the resolution and top-of-form...
 239     */
 240
 241     printf("\033&u%dD", header->HWResolution[0]);
 242                                                 /* Resolution */
 243     printf("\033&l0e0L");                       /* Reset top and don't skip */
 244     printf("\033*p0Y\033*p0X");                 /* Set top of form */
 245
 246    /*
 247     * Send 26-byte configure image data command with horizontal and
 248     * vertical resolutions as well as a color count...
 249     */
 250
 251     printf("\033*g26W");
 252     putchar(2);                                 /* Format 2 */
 253     putchar((int)NumPlanes);                    /* Output planes */
 254
 255     putchar((int)(header->HWResolution[0] >> 8));/* Black resolution */
 256     putchar((int)header->HWResolution[0]);
 257     putchar((int)(header->HWResolution[1] >> 8));
 258     putchar((int)header->HWResolution[1]);
 259     putchar(0);
 260     putchar(1 << ColorBits);                    /* # of black levels */
 261
 262     putchar((int)(header->HWResolution[0] >> 8));/* Cyan resolution */
 263     putchar((int)header->HWResolution[0]);
 264     putchar((int)(header->HWResolution[1] >> 8));
 265     putchar((int)header->HWResolution[1]);
 266     putchar(0);
 267     putchar(1 << ColorBits);                    /* # of cyan levels */
 268
 269     putchar((int)(header->HWResolution[0] >> 8));/* Magenta resolution */
 270     putchar((int)header->HWResolution[0]);
 271     putchar((int)(header->HWResolution[1] >> 8));
 272     putchar((int)header->HWResolution[1]);
 273     putchar(0);
 274     putchar(1 << ColorBits);                    /* # of magenta levels */
 275
 276     putchar((int)(header->HWResolution[0] >> 8));/* Yellow resolution */
 277     putchar((int)header->HWResolution[0]);
 278     putchar((int)(header->HWResolution[1] >> 8));
 279     putchar((int)header->HWResolution[1]);
 280     putchar(0);
 281     putchar(1 << ColorBits);                    /* # of yellow levels */
 282
 283     printf("\033&l0H");                         /* Set media position */
 284   }
 285   else
 286   {
 287     printf("\033*t%uR", header->HWResolution[0]);
 288                                                 /* Set resolution */
 289
 290     if (header->cupsColorSpace == CUPS_CSPACE_KCMY)
 291     {
 292       NumPlanes = 4;
 293       printf("\033*r-4U");                      /* Set KCMY graphics */
 294     }
 295     else if (header->cupsColorSpace == CUPS_CSPACE_CMY)
 296     {
 297       NumPlanes = 3;
 298       printf("\033*r-3U");                      /* Set CMY graphics */
 299     }
 300     else
 301       NumPlanes = 1;                            /* Black&white graphics */
 302
 303    /*
 304     * Set size and position of graphics...
 305     */
 306
 307     printf("\033*r%uS", header->cupsWidth);     /* Set width */
 308     printf("\033*r%uT", header->cupsHeight);    /* Set height */
 309
 310     printf("\033&a0H");                         /* Set horizontal position */
 311
 312     if (ppd)
 313       printf("\033&a%.0fV",                     /* Set vertical position */
 314              10.0 * (ppd->sizes[0].length - ppd->sizes[0].top));
 315     else
 316       printf("\033&a0V");                       /* Set top-of-page */
 317   }
 318
 319   printf("\033*r1A");                           /* Start graphics */
 320
 321   if (header->cupsCompression)
 322     printf("\033*b%uM",                         /* Set compression */
 323            header->cupsCompression);
 324
 325   Feed = 0;                                     /* No blank lines yet */
 326
 327  /*
 328   * Allocate memory for a line of graphics...
 329   */
 330
 331   if ((Planes[0] = malloc(header->cupsBytesPerLine + NumPlanes)) == NULL)
 332   {
 333     fputs("ERROR: Unable to allocate memory\n", stderr);
 334     exit(1);
 335   }
 336
 337   for (plane = 1; plane < NumPlanes; plane ++)
 338     Planes[plane] = Planes[0] + plane * header->cupsBytesPerLine / NumPlanes;
 339
 340   if (ColorBits > 1)
 341     BitBuffer = malloc(ColorBits * ((header->cupsWidth + 7) / 8));
 342   else
 343     BitBuffer = NULL;
 344
 345   if (header->cupsCompression)
 346     CompBuffer = malloc(header->cupsBytesPerLine * 2 + 2);
 347   else
 348     CompBuffer = NULL;
 349 }
 350
 351
 352 /*
 353  * 'EndPage()' - Finish a page of graphics.
 354  */
 355
 356 void
 357 EndPage(void)
 358 {
 359  /*
 360   * Eject the current page...
 361   */
 362
 363   if (NumPlanes > 1)
 364   {
 365      printf("\033*rC");                 /* End color GFX */
 366
 367      if (!(Duplex && (Page & 1)))
 368        printf("\033&l0H");              /* Eject current page */
 369   }
 370   else
 371   {
 372      printf("\033*r0B");                /* End GFX */
 373
 374      if (!(Duplex && (Page & 1)))
 375        printf("\014");                  /* Eject current page */
 376   }
 377
 378   fflush(stdout);
 379
 380  /*
 381   * Free memory...
 382   */
 383
 384   free(Planes[0]);
 385
 386   if (BitBuffer)
 387     free(BitBuffer);
 388
 389   if (CompBuffer)
 390     free(CompBuffer);
 391 }
 392
 393
 394 /*
 395  * 'Shutdown()' - Shutdown the printer.
 396  */
 397
 398 void
 399 Shutdown(void)
 400 {
 401  /*
 402   * Send a PCL reset sequence.
 403   */
 404
 405   putchar(0x1b);
 406   putchar('E');
 407 }
 408
 409
 410 /*
 411  * 'CancelJob()' - Cancel the current job...
 412  */
 413
 414 void
 415 CancelJob(int sig)                      /* I - Signal */
 416 {
 417   (void)sig;
 418
 419   Canceled = 1;
 420 }
 421
 422
 423 /*
 424  * 'CompressData()' - Compress a line of graphics.
 425  */
 426
 427 void
 428 CompressData(unsigned char *line,       /* I - Data to compress */
 429              unsigned      length,      /* I - Number of bytes */
 430              unsigned      plane,       /* I - Color plane */
 431              unsigned      type)        /* I - Type of compression */
 432 {
 433   unsigned char *line_ptr,              /* Current byte pointer */
 434                 *line_end,              /* End-of-line byte pointer */
 435                 *comp_ptr,              /* Pointer into compression buffer */
 436                 *start;                 /* Start of compression sequence */
 437   unsigned      count;                  /* Count of bytes for output */
 438
 439
 440   switch (type)
 441   {
 442     default :
 443        /*
 444         * Do no compression...
 445         */
 446
 447         line_ptr = line;
 448         line_end = line + length;
 449         break;
 450
 451     case 1 :
 452        /*
 453         * Do run-length encoding...
 454         */
 455
 456         line_end = line + length;
 457         for (line_ptr = line, comp_ptr = CompBuffer;
 458              line_ptr < line_end;
 459              comp_ptr += 2, line_ptr += count)
 460         {
 461           for (count = 1;
 462                (line_ptr + count) < line_end &&
 463                    line_ptr[0] == line_ptr[count] &&
 464                    count < 256;
 465                count ++);
 466
 467           comp_ptr[0] = (unsigned char)(count - 1);
 468           comp_ptr[1] = line_ptr[0];
 469         }
 470
 471         line_ptr = CompBuffer;
 472         line_end = comp_ptr;
 473         break;
 474
 475     case 2 :
 476        /*
 477         * Do TIFF pack-bits encoding...
 478         */
 479
 480         line_ptr = line;
 481         line_end = line + length;
 482         comp_ptr = CompBuffer;
 483
 484         while (line_ptr < line_end)
 485         {
 486           if ((line_ptr + 1) >= line_end)
 487           {
 488            /*
 489             * Single byte on the end...
 490             */
 491
 492             *comp_ptr++ = 0x00;
 493             *comp_ptr++ = *line_ptr++;
 494           }
 495           else if (line_ptr[0] == line_ptr[1])
 496           {
 497            /*
 498             * Repeated sequence...
 499             */
 500
 501             line_ptr ++;
 502             count = 2;
 503
 504             while (line_ptr < (line_end - 1) &&
 505                    line_ptr[0] == line_ptr[1] &&
 506                    count < 127)
 507             {
 508               line_ptr ++;
 509               count ++;
 510             }
 511
 512             *comp_ptr++ = (unsigned char)(257 - count);
 513             *comp_ptr++ = *line_ptr++;
 514           }
 515           else
 516           {
 517            /*
 518             * Non-repeated sequence...
 519             */
 520
 521             start    = line_ptr;
 522             line_ptr ++;
 523             count    = 1;
 524
 525             while (line_ptr < (line_end - 1) &&
 526                    line_ptr[0] != line_ptr[1] &&
 527                    count < 127)
 528             {
 529               line_ptr ++;
 530               count ++;
 531             }
 532
 533             *comp_ptr++ = (unsigned char)(count - 1);
 534
 535             memcpy(comp_ptr, start, count);
 536             comp_ptr += count;
 537           }
 538         }
 539
 540         line_ptr = CompBuffer;
 541         line_end = comp_ptr;
 542         break;
 543   }
 544
 545  /*
 546   * Set the length of the data and write a raster plane...
 547   */
 548
 549   printf("\033*b%d%c", (int)(line_end - line_ptr), plane);
 550   fwrite(line_ptr, (size_t)(line_end - line_ptr), 1, stdout);
 551 }
 552
 553
 554 /*
 555  * 'OutputLine()' - Output a line of graphics.
 556  */
 557
 558 void
 559 OutputLine(cups_page_header2_t *header) /* I - Page header */
 560 {
 561   unsigned      plane,                  /* Current plane */
 562                 bytes,                  /* Bytes to write */
 563                 count;                  /* Bytes to convert */
 564   unsigned char bit,                    /* Current plane data */
 565                 bit0,                   /* Current low bit data */
 566                 bit1,                   /* Current high bit data */
 567                 *plane_ptr,             /* Pointer into Planes */
 568                 *bit_ptr;               /* Pointer into BitBuffer */
 569
 570
 571  /*
 572   * Output whitespace as needed...
 573   */
 574
 575   if (Feed > 0)
 576   {
 577     printf("\033*b%dY", Feed);
 578     Feed = 0;
 579   }
 580
 581  /*
 582   * Write bitmap data as needed...
 583   */
 584
 585   bytes = (header->cupsWidth + 7) / 8;
 586
 587   for (plane = 0; plane < NumPlanes; plane ++)
 588     if (ColorBits == 1)
 589     {
 590      /*
 591       * Send bits as-is...
 592       */
 593
 594       CompressData(Planes[plane], bytes, plane < (NumPlanes - 1) ? 'V' : 'W',
 595                    header->cupsCompression);
 596     }
 597     else
 598     {
 599      /*
 600       * Separate low and high bit data into separate buffers.
 601       */
 602
 603       for (count = header->cupsBytesPerLine / NumPlanes,
 604                plane_ptr = Planes[plane], bit_ptr = BitBuffer;
 605            count > 0;
 606            count -= 2, plane_ptr += 2, bit_ptr ++)
 607       {
 608         bit = plane_ptr[0];
 609
 610         bit0 = (unsigned char)(((bit & 64) << 1) | ((bit & 16) << 2) | ((bit & 4) << 3) | ((bit & 1) << 4));
 611         bit1 = (unsigned char)((bit & 128) | ((bit & 32) << 1) | ((bit & 8) << 2) | ((bit & 2) << 3));
 612
 613         if (count > 1)
 614         {
 615           bit = plane_ptr[1];
 616
 617           bit0 |= (unsigned char)((bit & 1) | ((bit & 4) >> 1) | ((bit & 16) >> 2) | ((bit & 64) >> 3));
 618           bit1 |= (unsigned char)(((bit & 2) >> 1) | ((bit & 8) >> 2) | ((bit & 32) >> 3) | ((bit & 128) >> 4));
 619         }
 620
 621         bit_ptr[0]     = bit0;
 622         bit_ptr[bytes] = bit1;
 623       }
 624
 625      /*
 626       * Send low and high bits...
 627       */
 628
 629       CompressData(BitBuffer, bytes, 'V', header->cupsCompression);
 630       CompressData(BitBuffer + bytes, bytes, plane < (NumPlanes - 1) ? 'V' : 'W',
 631                    header->cupsCompression);
 632     }
 633
 634   fflush(stdout);
 635 }
 636
 637
 638 /*
 639  * 'main()' - Main entry and processing of driver.
 640  */
 641
 642 int                                     /* O - Exit status */
 643 main(int  argc,                         /* I - Number of command-line arguments */
 644      char *argv[])                      /* I - Command-line arguments */
 645 {
 646   int                   fd;             /* File descriptor */
 647   cups_raster_t         *ras;           /* Raster stream for printing */
 648   cups_page_header2_t   header;         /* Page header from file */
 649   unsigned              y;              /* Current line */
 650   ppd_file_t            *ppd;           /* PPD file */
 651 #if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
 652   struct sigaction action;              /* Actions for POSIX signals */
 653 #endif /* HAVE_SIGACTION && !HAVE_SIGSET */
 654
 655
 656  /*
 657   * Make sure status messages are not buffered...
 658   */
 659
 660   setbuf(stderr, NULL);
 661
 662  /*
 663   * Check command-line...
 664   */
 665
 666   if (argc < 6 || argc > 7)
 667   {
 668    /*
 669     * We don't have the correct number of arguments; write an error message
 670     * and return.
 671     */
 672
 673     _cupsLangPrintFilter(stderr, "ERROR",
 674                          _("%s job-id user title copies options [file]"),
 675                          "rastertohp");
 676     return (1);
 677   }
 678
 679  /*
 680   * Open the page stream...
 681   */
 682
 683   if (argc == 7)
 684   {
 685     if ((fd = open(argv[6], O_RDONLY)) == -1)
 686     {
 687       _cupsLangPrintError("ERROR", _("Unable to open raster file"));
 688       sleep(1);
 689       return (1);
 690     }
 691   }
 692   else
 693     fd = 0;
 694
 695   ras = cupsRasterOpen(fd, CUPS_RASTER_READ);
 696
 697  /*
 698   * Register a signal handler to eject the current page if the
 699   * job is cancelled.
 700   */
 701
 702   Canceled = 0;
 703
 704 #ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
 705   sigset(SIGTERM, CancelJob);
 706 #elif defined(HAVE_SIGACTION)
 707   memset(&action, 0, sizeof(action));
 708
 709   sigemptyset(&action.sa_mask);
 710   action.sa_handler = CancelJob;
 711   sigaction(SIGTERM, &action, NULL);
 712 #else
 713   signal(SIGTERM, CancelJob);
 714 #endif /* HAVE_SIGSET */
 715
 716  /*
 717   * Initialize the print device...
 718   */
 719
 720   ppd = ppdOpenFile(getenv("PPD"));
 721   if (!ppd)
 722   {
 723     ppd_status_t        status;         /* PPD error */
 724     int                 linenum;        /* Line number */
 725
 726     _cupsLangPrintFilter(stderr, "ERROR",
 727                          _("The PPD file could not be opened."));
 728
 729     status = ppdLastError(&linenum);
 730
 731     fprintf(stderr, "DEBUG: %s on line %d.\n", ppdErrorString(status), linenum);
 732
 733     return (1);
 734   }
 735
 736   Setup();
 737
 738  /*
 739   * Process pages as needed...
 740   */
 741
 742   Page = 0;
 743
 744   while (cupsRasterReadHeader2(ras, &header))
 745   {
 746    /*
 747     * Write a status message with the page number and number of copies.
 748     */
 749
 750     if (Canceled)
 751       break;
 752
 753     Page ++;
 754
 755     fprintf(stderr, "PAGE: %d %d\n", Page, header.NumCopies);
 756     _cupsLangPrintFilter(stderr, "INFO", _("Starting page %d."), Page);
 757
 758    /*
 759     * Start the page...
 760     */
 761
 762     StartPage(ppd, &header);
 763
 764    /*
 765     * Loop for each line on the page...
 766     */
 767
 768     for (y = 0; y < header.cupsHeight; y ++)
 769     {
 770      /*
 771       * Let the user know how far we have progressed...
 772       */
 773
 774       if (Canceled)
 775         break;
 776
 777       if ((y & 127) == 0)
 778       {
 779         _cupsLangPrintFilter(stderr, "INFO",
 780                              _("Printing page %d, %u%% complete."),
 781                              Page, 100 * y / header.cupsHeight);
 782         fprintf(stderr, "ATTR: job-media-progress=%u\n",
 783                 100 * y / header.cupsHeight);
 784       }
 785
 786      /*
 787       * Read a line of graphics...
 788       */
 789
 790       if (cupsRasterReadPixels(ras, Planes[0], header.cupsBytesPerLine) < 1)
 791         break;
 792
 793      /*
 794       * See if the line is blank; if not, write it to the printer...
 795       */
 796
 797       if (Planes[0][0] ||
 798           memcmp(Planes[0], Planes[0] + 1, header.cupsBytesPerLine - 1))
 799         OutputLine(&header);
 800       else
 801         Feed ++;
 802     }
 803
 804    /*
 805     * Eject the page...
 806     */
 807
 808     _cupsLangPrintFilter(stderr, "INFO", _("Finished page %d."), Page);
 809
 810     EndPage();
 811
 812     if (Canceled)
 813       break;
 814   }
 815
 816  /*
 817   * Shutdown the printer...
 818   */
 819
 820   Shutdown();
 821
 822   if (ppd)
 823     ppdClose(ppd);
 824
 825  /*
 826   * Close the raster stream...
 827   */
 828
 829   cupsRasterClose(ras);
 830   if (fd != 0)
 831     close(fd);
 832
 833  /*
 834   * If no pages were printed, send an error message...
 835   */
 836
 837   if (Page == 0)
 838   {
 839     _cupsLangPrintFilter(stderr, "ERROR", _("No pages were found."));
 840     return (1);
 841   }
 842   else
 843     return (0);
 844 }