filter/testraster.c

   1 /*
   2  * "$Id$"
   3  *
   4  * Raster test program routines for CUPS.
   5  *
   6  * Copyright 2007-2014 by Apple Inc.
   7  * Copyright 1997-2007 by Easy Software Products.
   8  *
   9  * These coded instructions, statements, and computer programs are the
  10  * property of Apple Inc. and are protected by Federal copyright
  11  * law.  Distribution and use rights are outlined in the file "LICENSE.txt"
  12  * which should have been included with this file.  If this file is
  13  * file is missing or damaged, see the license at "http://www.cups.org/".
  14  *
  15  * This file is subject to the Apple OS-Developed Software exception.
  16  */
  17
  18 /*
  19  * Include necessary headers...
  20  */
  21
  22 #include <cups/raster-private.h>
  23 #include <math.h>
  24
  25
  26 /*
  27  * Test PS commands and header...
  28  */
  29
  30 static const char *dsc_code =
  31 "[{\n"
  32 "%%BeginFeature: *PageSize Tabloid\n"
  33 "<</PageSize[792 1224]>>setpagedevice\n"
  34 "%%EndFeature\n"
  35 "} stopped cleartomark\n";
  36 static const char *setpagedevice_code =
  37 "<<"
  38 "/MediaClass(Media Class)"
  39 "/MediaColor((Media Color))"
  40 "/MediaType(Media\\\\Type)"
  41 "/OutputType<416263>"
  42 "/AdvanceDistance 1000"
  43 "/AdvanceMedia 1"
  44 "/Collate false"
  45 "/CutMedia 2"
  46 "/Duplex true"
  47 "/HWResolution[100 200]"
  48 "/InsertSheet true"
  49 "/Jog 3"
  50 "/LeadingEdge 1"
  51 "/ManualFeed true"
  52 "/MediaPosition 8#777"
  53 "/MediaWeight 16#fe01"
  54 "/MirrorPrint true"
  55 "/NegativePrint true"
  56 "/NumCopies 1"
  57 "/Orientation 1"
  58 "/OutputFaceUp true"
  59 "/PageSize[612 792.1]"
  60 "/Separations true"
  61 "/TraySwitch true"
  62 "/Tumble true"
  63 "/cupsMediaType 2"
  64 "/cupsColorOrder 1"
  65 "/cupsColorSpace 1"
  66 "/cupsCompression 1"
  67 "/cupsRowCount 1"
  68 "/cupsRowFeed 1"
  69 "/cupsRowStep 1"
  70 "/cupsBorderlessScalingFactor 1.001"
  71 "/cupsInteger0 1"
  72 "/cupsInteger1 2"
  73 "/cupsInteger2 3"
  74 "/cupsInteger3 4"
  75 "/cupsInteger4 5"
  76 "/cupsInteger5 6"
  77 "/cupsInteger6 7"
  78 "/cupsInteger7 8"
  79 "/cupsInteger8 9"
  80 "/cupsInteger9 10"
  81 "/cupsInteger10 11"
  82 "/cupsInteger11 12"
  83 "/cupsInteger12 13"
  84 "/cupsInteger13 14"
  85 "/cupsInteger14 15"
  86 "/cupsInteger15 16"
  87 "/cupsReal0 1.1"
  88 "/cupsReal1 2.1"
  89 "/cupsReal2 3.1"
  90 "/cupsReal3 4.1"
  91 "/cupsReal4 5.1"
  92 "/cupsReal5 6.1"
  93 "/cupsReal6 7.1"
  94 "/cupsReal7 8.1"
  95 "/cupsReal8 9.1"
  96 "/cupsReal9 10.1"
  97 "/cupsReal10 11.1"
  98 "/cupsReal11 12.1"
  99 "/cupsReal12 13.1"
 100 "/cupsReal13 14.1"
 101 "/cupsReal14 15.1"
 102 "/cupsReal15 16.1"
 103 "/cupsString0(1)"
 104 "/cupsString1(2)"
 105 "/cupsString2(3)"
 106 "/cupsString3(4)"
 107 "/cupsString4(5)"
 108 "/cupsString5(6)"
 109 "/cupsString6(7)"
 110 "/cupsString7(8)"
 111 "/cupsString8(9)"
 112 "/cupsString9(10)"
 113 "/cupsString10(11)"
 114 "/cupsString11(12)"
 115 "/cupsString12(13)"
 116 "/cupsString13(14)"
 117 "/cupsString14(15)"
 118 "/cupsString15(16)"
 119 "/cupsMarkerType(Marker Type)"
 120 "/cupsRenderingIntent(Rendering Intent)"
 121 "/cupsPageSizeName(Letter)"
 122 "/cupsPreferredBitsPerColor 17"
 123 ">> setpagedevice";
 124
 125 static cups_page_header2_t setpagedevice_header =
 126 {
 127   "Media Class",                        /* MediaClass */
 128   "(Media Color)",                      /* MediaColor */
 129   "Media\\Type",                        /* MediaType */
 130   "Abc",                                /* OutputType */
 131   1000,                                 /* AdvanceDistance */
 132   CUPS_ADVANCE_FILE,                    /* AdvanceMedia */
 133   CUPS_FALSE,                           /* Collate */
 134   CUPS_CUT_JOB,                         /* CutMedia */
 135   CUPS_TRUE,                            /* Duplex */
 136   { 100, 200 },                         /* HWResolution */
 137   { 0, 0, 0, 0 },                       /* ImagingBoundingBox */
 138   CUPS_TRUE,                            /* InsertSheet */
 139   CUPS_JOG_SET,                         /* Jog */
 140   CUPS_EDGE_RIGHT,                      /* LeadingEdge */
 141   { 0, 0 },                             /* Margins */
 142   CUPS_TRUE,                            /* ManualFeed */
 143   0777,                                 /* MediaPosition */
 144   0xfe01,                               /* MediaWeight */
 145   CUPS_TRUE,                            /* MirrorPrint */
 146   CUPS_TRUE,                            /* NegativePrint */
 147   1,                                    /* NumCopies */
 148   CUPS_ORIENT_90,                       /* Orientation */
 149   CUPS_TRUE,                            /* OutputFaceUp */
 150   { 612, 792 },                         /* PageSize */
 151   CUPS_TRUE,                            /* Separations */
 152   CUPS_TRUE,                            /* TraySwitch */
 153   CUPS_TRUE,                            /* Tumble */
 154   0,                                    /* cupsWidth */
 155   0,                                    /* cupsHeight */
 156   2,                                    /* cupsMediaType */
 157   0,                                    /* cupsBitsPerColor */
 158   0,                                    /* cupsBitsPerPixel */
 159   0,                                    /* cupsBytesPerLine */
 160   CUPS_ORDER_BANDED,                    /* cupsColorOrder */
 161   CUPS_CSPACE_RGB,                      /* cupsColorSpace */
 162   1,                                    /* cupsCompression */
 163   1,                                    /* cupsRowCount */
 164   1,                                    /* cupsRowFeed */
 165   1,                                    /* cupsRowStep */
 166   0,                                    /* cupsNumColors */
 167   1.001f,                               /* cupsBorderlessScalingFactor */
 168   { 612.0f, 792.1f },                   /* cupsPageSize */
 169   { 0.0f, 0.0f, 0.0f, 0.0f },           /* cupsImagingBBox */
 170   { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },
 171                                         /* cupsInteger[16] */
 172   { 1.1f, 2.1f, 3.1f, 4.1f, 5.1f, 6.1f, 7.1f, 8.1f, 9.1f, 10.1f, 11.1f, 12.1f, 13.1f, 14.1f, 15.1f, 16.1f },                    /* cupsReal[16] */
 173   { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13",
 174     "14", "15", "16" },                 /* cupsString[16] */
 175   "Marker Type",                        /* cupsMarkerType */
 176   "Rendering Intent",                   /* cupsRenderingIntent */
 177   "Letter"                              /* cupsPageSizeName */
 178 };
 179
 180
 181 /*
 182  * Local functions...
 183  */
 184
 185 static int      do_ppd_tests(const char *filename, int num_options,
 186                              cups_option_t *options);
 187 static int      do_ps_tests(void);
 188 static int      do_ras_file(const char *filename);
 189 static int      do_raster_tests(cups_mode_t mode);
 190 static void     print_changes(cups_page_header2_t *header,
 191                               cups_page_header2_t *expected);
 192
 193
 194 /*
 195  * 'main()' - Test the raster functions.
 196  */
 197
 198 int                                     /* O - Exit status */
 199 main(int  argc,                         /* I - Number of command-line args */
 200      char *argv[])                      /* I - Command-line arguments */
 201 {
 202   int           errors;                 /* Number of errors */
 203   const char    *ext;                   /* Filename extension */
 204
 205
 206   if (argc == 1)
 207   {
 208     errors = do_ps_tests();
 209     errors += do_raster_tests(CUPS_RASTER_WRITE);
 210     errors += do_raster_tests(CUPS_RASTER_WRITE_COMPRESSED);
 211     errors += do_raster_tests(CUPS_RASTER_WRITE_PWG);
 212   }
 213   else
 214   {
 215     int                 i;              /* Looping var */
 216     int                 num_options;    /* Number of options */
 217     cups_option_t       *options;       /* Options */
 218
 219
 220     for (errors = 0, num_options = 0, options = NULL, i = 1; i < argc; i ++)
 221     {
 222       if (argv[i][0] == '-')
 223       {
 224         if (argv[i][1] == 'o')
 225         {
 226           if (argv[i][2])
 227             num_options = cupsParseOptions(argv[i] + 2, num_options, &options);
 228           else
 229           {
 230             i ++;
 231             if (i < argc)
 232               num_options = cupsParseOptions(argv[i], num_options, &options);
 233             else
 234             {
 235               puts("Usage: testraster [-o name=value ...] [filename.ppd ...]");
 236               puts("       testraster [filename.ras ...]");
 237               return (1);
 238             }
 239           }
 240         }
 241         else
 242         {
 243           puts("Usage: testraster [-o name=value ...] [filename.ppd ...]");
 244           puts("       testraster [filename.ras ...]");
 245           return (1);
 246         }
 247       }
 248       else if ((ext = strrchr(argv[i], '.')) != NULL)
 249       {
 250         if (!strcmp(ext, ".ppd"))
 251           errors += do_ppd_tests(argv[i], num_options, options);
 252         else
 253           errors += do_ras_file(argv[i]);
 254       }
 255       else
 256       {
 257         puts("Usage: testraster [-o name=value ...] [filename.ppd ...]");
 258         puts("       testraster [filename.ras ...]");
 259         return (1);
 260       }
 261     }
 262
 263     cupsFreeOptions(num_options, options);
 264   }
 265
 266   return (errors);
 267 }
 268
 269
 270 /*
 271  * 'do_ppd_tests()' - Test the default option commands in a PPD file.
 272  */
 273
 274 static int                              /* O - Number of errors */
 275 do_ppd_tests(const char    *filename,   /* I - PPD file */
 276              int           num_options, /* I - Number of options */
 277              cups_option_t *options)    /* I - Options */
 278 {
 279   ppd_file_t            *ppd;           /* PPD file data */
 280   cups_page_header2_t   header;         /* Page header */
 281
 282
 283   printf("\"%s\": ", filename);
 284   fflush(stdout);
 285
 286   if ((ppd = ppdOpenFile(filename)) == NULL)
 287   {
 288     ppd_status_t        status;         /* Status from PPD loader */
 289     int                 line;           /* Line number containing error */
 290
 291
 292     status = ppdLastError(&line);
 293
 294     puts("FAIL (bad PPD file)");
 295     printf("    %s on line %d\n", ppdErrorString(status), line);
 296
 297     return (1);
 298   }
 299
 300   ppdMarkDefaults(ppd);
 301   cupsMarkOptions(ppd, num_options, options);
 302
 303   if (cupsRasterInterpretPPD(&header, ppd, 0, NULL, NULL))
 304   {
 305     puts("FAIL (error from function)");
 306     puts(cupsRasterErrorString());
 307
 308     return (1);
 309   }
 310   else
 311   {
 312     puts("PASS");
 313
 314     return (0);
 315   }
 316 }
 317
 318
 319 /*
 320  * 'do_ps_tests()' - Test standard PostScript commands.
 321  */
 322
 323 static int
 324 do_ps_tests(void)
 325 {
 326   cups_page_header2_t   header;         /* Page header */
 327   int                   preferred_bits; /* Preferred bits */
 328   int                   errors = 0;     /* Number of errors */
 329
 330
 331  /*
 332   * Test PS exec code...
 333   */
 334
 335   fputs("_cupsRasterExecPS(\"setpagedevice\"): ", stdout);
 336   fflush(stdout);
 337
 338   memset(&header, 0, sizeof(header));
 339   header.Collate = CUPS_TRUE;
 340   preferred_bits = 0;
 341
 342   if (_cupsRasterExecPS(&header, &preferred_bits, setpagedevice_code))
 343   {
 344     puts("FAIL (error from function)");
 345     puts(cupsRasterErrorString());
 346     errors ++;
 347   }
 348   else if (preferred_bits != 17 ||
 349            memcmp(&header, &setpagedevice_header, sizeof(header)))
 350   {
 351     puts("FAIL (bad header)");
 352
 353     if (preferred_bits != 17)
 354       printf("    cupsPreferredBitsPerColor %d, expected 17\n",
 355              preferred_bits);
 356
 357     print_changes(&setpagedevice_header, &header);
 358     errors ++;
 359   }
 360   else
 361     puts("PASS");
 362
 363   fputs("_cupsRasterExecPS(\"roll\"): ", stdout);
 364   fflush(stdout);
 365
 366   if (_cupsRasterExecPS(&header, &preferred_bits,
 367                         "792 612 0 0 0\n"
 368                         "pop pop pop\n"
 369                         "<</PageSize[5 -2 roll]/ImagingBBox null>>"
 370                         "setpagedevice\n"))
 371   {
 372     puts("FAIL (error from function)");
 373     puts(cupsRasterErrorString());
 374     errors ++;
 375   }
 376   else if (header.PageSize[0] != 792 || header.PageSize[1] != 612)
 377   {
 378     printf("FAIL (PageSize [%d %d], expected [792 612])\n", header.PageSize[0],
 379            header.PageSize[1]);
 380     errors ++;
 381   }
 382   else
 383     puts("PASS");
 384
 385   fputs("_cupsRasterExecPS(\"dup index\"): ", stdout);
 386   fflush(stdout);
 387
 388   if (_cupsRasterExecPS(&header, &preferred_bits,
 389                         "true false dup\n"
 390                         "<</Collate 4 index"
 391                         "/Duplex 5 index"
 392                         "/Tumble 6 index>>setpagedevice\n"
 393                         "pop pop pop"))
 394   {
 395     puts("FAIL (error from function)");
 396     puts(cupsRasterErrorString());
 397     errors ++;
 398   }
 399   else
 400   {
 401     if (!header.Collate)
 402     {
 403       printf("FAIL (Collate false, expected true)\n");
 404       errors ++;
 405     }
 406
 407     if (header.Duplex)
 408     {
 409       printf("FAIL (Duplex true, expected false)\n");
 410       errors ++;
 411     }
 412
 413     if (header.Tumble)
 414     {
 415       printf("FAIL (Tumble true, expected false)\n");
 416       errors ++;
 417     }
 418
 419     if(header.Collate && !header.Duplex && !header.Tumble)
 420       puts("PASS");
 421   }
 422
 423   fputs("_cupsRasterExecPS(\"%%Begin/EndFeature code\"): ", stdout);
 424   fflush(stdout);
 425
 426   if (_cupsRasterExecPS(&header, &preferred_bits, dsc_code))
 427   {
 428     puts("FAIL (error from function)");
 429     puts(cupsRasterErrorString());
 430     errors ++;
 431   }
 432   else if (header.PageSize[0] != 792 || header.PageSize[1] != 1224)
 433   {
 434     printf("FAIL (bad PageSize [%d %d], expected [792 1224])\n",
 435            header.PageSize[0], header.PageSize[1]);
 436     errors ++;
 437   }
 438   else
 439     puts("PASS");
 440
 441   return (errors);
 442 }
 443
 444
 445 /*
 446  * 'do_ras_file()' - Test reading of a raster file.
 447  */
 448
 449 static int                              /* O - Number of errors */
 450 do_ras_file(const char *filename)       /* I - Filename */
 451 {
 452   unsigned              y;              /* Looping vars */
 453   int                   fd;             /* File descriptor */
 454   cups_raster_t         *ras;           /* Raster stream */
 455   cups_page_header2_t   header;         /* Page header */
 456   unsigned char         *data;          /* Raster data */
 457   int                   errors = 0;     /* Number of errors */
 458   unsigned              pages = 0;      /* Number of pages */
 459
 460
 461   if ((fd = open(filename, O_RDONLY)) < 0)
 462   {
 463     printf("%s: %s\n", filename, strerror(errno));
 464     return (1);
 465   }
 466
 467   if ((ras = cupsRasterOpen(fd, CUPS_RASTER_READ)) == NULL)
 468   {
 469     printf("%s: cupsRasterOpen failed.\n", filename);
 470     close(fd);
 471     return (1);
 472   }
 473
 474   printf("%s:\n", filename);
 475
 476   while (cupsRasterReadHeader2(ras, &header))
 477   {
 478     pages ++;
 479     data = malloc(header.cupsBytesPerLine);
 480
 481     printf("    Page %u: %ux%ux%u@%ux%udpi", pages,
 482            header.cupsWidth, header.cupsHeight, header.cupsBitsPerPixel,
 483            header.HWResolution[0], header.HWResolution[1]);
 484     fflush(stdout);
 485
 486     for (y = 0; y < header.cupsHeight; y ++)
 487       if (cupsRasterReadPixels(ras, data, header.cupsBytesPerLine) <
 488               header.cupsBytesPerLine)
 489         break;
 490
 491     if (y < header.cupsHeight)
 492       printf(" ERROR AT LINE %d\n", y);
 493     else
 494       putchar('\n');
 495
 496     free(data);
 497   }
 498
 499   printf("EOF at %ld\n", (long)lseek(fd, SEEK_CUR, 0));
 500
 501   cupsRasterClose(ras);
 502   close(fd);
 503
 504   return (errors);
 505 }
 506
 507
 508 /*
 509  * 'do_raster_tests()' - Test reading and writing of raster data.
 510  */
 511
 512 static int                              /* O - Number of errors */
 513 do_raster_tests(cups_mode_t mode)       /* O - Write mode */
 514 {
 515   unsigned              page, x, y;     /* Looping vars */
 516   FILE                  *fp;            /* Raster file */
 517   cups_raster_t         *r;             /* Raster stream */
 518   cups_page_header2_t   header,         /* Page header */
 519                         expected;       /* Expected page header */
 520   unsigned char         data[2048];     /* Raster data */
 521   int                   errors = 0;     /* Number of errors */
 522
 523
 524  /*
 525   * Test writing...
 526   */
 527
 528   printf("cupsRasterOpen(%s): ",
 529          mode == CUPS_RASTER_WRITE ? "CUPS_RASTER_WRITE" :
 530              mode == CUPS_RASTER_WRITE ? "CUPS_RASTER_WRITE_COMPRESSED" :
 531                                          "CUPS_RASTER_WRITE_PWG");
 532   fflush(stdout);
 533
 534   if ((fp = fopen("test.raster", "wb")) == NULL)
 535   {
 536     printf("FAIL (%s)\n", strerror(errno));
 537     return (1);
 538   }
 539
 540   if ((r = cupsRasterOpen(fileno(fp), mode)) == NULL)
 541   {
 542     printf("FAIL (%s)\n", strerror(errno));
 543     fclose(fp);
 544     return (1);
 545   }
 546
 547   puts("PASS");
 548
 549   for (page = 0; page < 4; page ++)
 550   {
 551     memset(&header, 0, sizeof(header));
 552     header.cupsWidth        = 256;
 553     header.cupsHeight       = 256;
 554     header.cupsBytesPerLine = 256;
 555
 556     if (page & 1)
 557     {
 558       header.cupsBytesPerLine *= 2;
 559       header.cupsColorSpace = CUPS_CSPACE_CMYK;
 560       header.cupsColorOrder = CUPS_ORDER_CHUNKED;
 561       header.cupsNumColors  = 4;
 562     }
 563     else
 564     {
 565       header.cupsColorSpace = CUPS_CSPACE_K;
 566       header.cupsColorOrder = CUPS_ORDER_BANDED;
 567       header.cupsNumColors  = 1;
 568     }
 569
 570     if (page & 2)
 571     {
 572       header.cupsBytesPerLine *= 2;
 573       header.cupsBitsPerColor = 16;
 574       header.cupsBitsPerPixel = (page & 1) ? 64 : 16;
 575     }
 576     else
 577     {
 578       header.cupsBitsPerColor = 8;
 579       header.cupsBitsPerPixel = (page & 1) ? 32 : 8;
 580     }
 581
 582     if (cupsRasterWriteHeader2(r, &header))
 583       puts("cupsRasterWriteHeader2: PASS");
 584     else
 585     {
 586       puts("cupsRasterWriteHeader2: FAIL");
 587       errors ++;
 588     }
 589
 590     fputs("cupsRasterWritePixels: ", stdout);
 591     fflush(stdout);
 592
 593     memset(data, 0, header.cupsBytesPerLine);
 594     for (y = 0; y < 64; y ++)
 595       if (!cupsRasterWritePixels(r, data, header.cupsBytesPerLine))
 596         break;
 597
 598     if (y < 64)
 599     {
 600       puts("FAIL");
 601       errors ++;
 602     }
 603     else
 604     {
 605       for (x = 0; x < header.cupsBytesPerLine; x ++)
 606         data[x] = (unsigned char)x;
 607
 608       for (y = 0; y < 64; y ++)
 609         if (!cupsRasterWritePixels(r, data, header.cupsBytesPerLine))
 610           break;
 611
 612       if (y < 64)
 613       {
 614         puts("FAIL");
 615         errors ++;
 616       }
 617       else
 618       {
 619         memset(data, 255, header.cupsBytesPerLine);
 620         for (y = 0; y < 64; y ++)
 621           if (!cupsRasterWritePixels(r, data, header.cupsBytesPerLine))
 622             break;
 623
 624         if (y < 64)
 625         {
 626           puts("FAIL");
 627           errors ++;
 628         }
 629         else
 630         {
 631           for (x = 0; x < header.cupsBytesPerLine; x ++)
 632             data[x] = (unsigned char)(x / 4);
 633
 634           for (y = 0; y < 64; y ++)
 635             if (!cupsRasterWritePixels(r, data, header.cupsBytesPerLine))
 636               break;
 637
 638           if (y < 64)
 639           {
 640             puts("FAIL");
 641             errors ++;
 642           }
 643           else
 644             puts("PASS");
 645         }
 646       }
 647     }
 648   }
 649
 650   cupsRasterClose(r);
 651   fclose(fp);
 652
 653  /*
 654   * Test reading...
 655   */
 656
 657   fputs("cupsRasterOpen(CUPS_RASTER_READ): ", stdout);
 658   fflush(stdout);
 659
 660   if ((fp = fopen("test.raster", "rb")) == NULL)
 661   {
 662     printf("FAIL (%s)\n", strerror(errno));
 663     return (1);
 664   }
 665
 666   if ((r = cupsRasterOpen(fileno(fp), CUPS_RASTER_READ)) == NULL)
 667   {
 668     printf("FAIL (%s)\n", strerror(errno));
 669     fclose(fp);
 670     return (1);
 671   }
 672
 673   puts("PASS");
 674
 675   for (page = 0; page < 4; page ++)
 676   {
 677     memset(&expected, 0, sizeof(expected));
 678     expected.cupsWidth        = 256;
 679     expected.cupsHeight       = 256;
 680     expected.cupsBytesPerLine = 256;
 681
 682     if (mode == CUPS_RASTER_WRITE_PWG)
 683     {
 684       strlcpy(expected.MediaClass, "PwgRaster", sizeof(expected.MediaClass));
 685       expected.cupsInteger[7] = 0xffffff;
 686     }
 687
 688     if (page & 1)
 689     {
 690       expected.cupsBytesPerLine *= 2;
 691       expected.cupsColorSpace = CUPS_CSPACE_CMYK;
 692       expected.cupsColorOrder = CUPS_ORDER_CHUNKED;
 693       expected.cupsNumColors  = 4;
 694     }
 695     else
 696     {
 697       expected.cupsColorSpace = CUPS_CSPACE_K;
 698       expected.cupsColorOrder = CUPS_ORDER_BANDED;
 699       expected.cupsNumColors  = 1;
 700     }
 701
 702     if (page & 2)
 703     {
 704       expected.cupsBytesPerLine *= 2;
 705       expected.cupsBitsPerColor = 16;
 706       expected.cupsBitsPerPixel = (page & 1) ? 64 : 16;
 707     }
 708     else
 709     {
 710       expected.cupsBitsPerColor = 8;
 711       expected.cupsBitsPerPixel = (page & 1) ? 32 : 8;
 712     }
 713
 714     fputs("cupsRasterReadHeader2: ", stdout);
 715     fflush(stdout);
 716
 717     if (!cupsRasterReadHeader2(r, &header))
 718     {
 719       puts("FAIL (read error)");
 720       errors ++;
 721       break;
 722     }
 723
 724     if (memcmp(&header, &expected, sizeof(header)))
 725     {
 726       puts("FAIL (bad page header)");
 727       errors ++;
 728       print_changes(&header, &expected);
 729     }
 730
 731     fputs("cupsRasterReadPixels: ", stdout);
 732     fflush(stdout);
 733
 734     for (y = 0; y < 64; y ++)
 735     {
 736       if (!cupsRasterReadPixels(r, data, header.cupsBytesPerLine))
 737       {
 738         puts("FAIL (read error)");
 739         errors ++;
 740         break;
 741       }
 742
 743       if (data[0] != 0 || memcmp(data, data + 1, header.cupsBytesPerLine - 1))
 744       {
 745         printf("FAIL (raster line %d corrupt)\n", y);
 746         errors ++;
 747         break;
 748       }
 749     }
 750
 751     if (y == 64)
 752     {
 753       for (y = 0; y < 64; y ++)
 754       {
 755         if (!cupsRasterReadPixels(r, data, header.cupsBytesPerLine))
 756         {
 757           puts("FAIL (read error)");
 758           errors ++;
 759           break;
 760         }
 761
 762         for (x = 0; x < header.cupsBytesPerLine; x ++)
 763           if (data[x] != (x & 255))
 764             break;
 765
 766         if (x < header.cupsBytesPerLine)
 767         {
 768           printf("FAIL (raster line %d corrupt)\n", y + 64);
 769           errors ++;
 770           break;
 771         }
 772       }
 773
 774       if (y == 64)
 775       {
 776         for (y = 0; y < 64; y ++)
 777         {
 778           if (!cupsRasterReadPixels(r, data, header.cupsBytesPerLine))
 779           {
 780             puts("FAIL (read error)");
 781             errors ++;
 782             break;
 783           }
 784
 785           if (data[0] != 255 || memcmp(data, data + 1, header.cupsBytesPerLine - 1))
 786           {
 787             printf("fail (raster line %d corrupt)\n", y + 128);
 788             errors ++;
 789             break;
 790           }
 791         }
 792
 793         if (y == 64)
 794         {
 795           for (y = 0; y < 64; y ++)
 796           {
 797             if (!cupsRasterReadPixels(r, data, header.cupsBytesPerLine))
 798             {
 799               puts("FAIL (read error)");
 800               errors ++;
 801               break;
 802             }
 803
 804             for (x = 0; x < header.cupsBytesPerLine; x ++)
 805               if (data[x] != ((x / 4) & 255))
 806                 break;
 807
 808             if (x < header.cupsBytesPerLine)
 809             {
 810               printf("FAIL (raster line %d corrupt)\n", y + 192);
 811               errors ++;
 812               break;
 813             }
 814           }
 815
 816           if (y == 64)
 817             puts("PASS");
 818         }
 819       }
 820     }
 821   }
 822
 823   cupsRasterClose(r);
 824   fclose(fp);
 825
 826   return (errors);
 827 }
 828
 829
 830 /*
 831  * 'print_changes()' - Print differences in the page header.
 832  */
 833
 834 static void
 835 print_changes(
 836     cups_page_header2_t *header,        /* I - Actual page header */
 837     cups_page_header2_t *expected)      /* I - Expected page header */
 838 {
 839   int   i;                              /* Looping var */
 840
 841
 842   if (strcmp(header->MediaClass, expected->MediaClass))
 843     printf("    MediaClass (%s), expected (%s)\n", header->MediaClass,
 844            expected->MediaClass);
 845
 846   if (strcmp(header->MediaColor, expected->MediaColor))
 847     printf("    MediaColor (%s), expected (%s)\n", header->MediaColor,
 848            expected->MediaColor);
 849
 850   if (strcmp(header->MediaType, expected->MediaType))
 851     printf("    MediaType (%s), expected (%s)\n", header->MediaType,
 852            expected->MediaType);
 853
 854   if (strcmp(header->OutputType, expected->OutputType))
 855     printf("    OutputType (%s), expected (%s)\n", header->OutputType,
 856            expected->OutputType);
 857
 858   if (header->AdvanceDistance != expected->AdvanceDistance)
 859     printf("    AdvanceDistance %d, expected %d\n", header->AdvanceDistance,
 860            expected->AdvanceDistance);
 861
 862   if (header->AdvanceMedia != expected->AdvanceMedia)
 863     printf("    AdvanceMedia %d, expected %d\n", header->AdvanceMedia,
 864            expected->AdvanceMedia);
 865
 866   if (header->Collate != expected->Collate)
 867     printf("    Collate %d, expected %d\n", header->Collate,
 868            expected->Collate);
 869
 870   if (header->CutMedia != expected->CutMedia)
 871     printf("    CutMedia %d, expected %d\n", header->CutMedia,
 872            expected->CutMedia);
 873
 874   if (header->Duplex != expected->Duplex)
 875     printf("    Duplex %d, expected %d\n", header->Duplex,
 876            expected->Duplex);
 877
 878   if (header->HWResolution[0] != expected->HWResolution[0] ||
 879       header->HWResolution[1] != expected->HWResolution[1])
 880     printf("    HWResolution [%d %d], expected [%d %d]\n",
 881            header->HWResolution[0], header->HWResolution[1],
 882            expected->HWResolution[0], expected->HWResolution[1]);
 883
 884   if (memcmp(header->ImagingBoundingBox, expected->ImagingBoundingBox,
 885              sizeof(header->ImagingBoundingBox)))
 886     printf("    ImagingBoundingBox [%d %d %d %d], expected [%d %d %d %d]\n",
 887            header->ImagingBoundingBox[0],
 888            header->ImagingBoundingBox[1],
 889            header->ImagingBoundingBox[2],
 890            header->ImagingBoundingBox[3],
 891            expected->ImagingBoundingBox[0],
 892            expected->ImagingBoundingBox[1],
 893            expected->ImagingBoundingBox[2],
 894            expected->ImagingBoundingBox[3]);
 895
 896   if (header->InsertSheet != expected->InsertSheet)
 897     printf("    InsertSheet %d, expected %d\n", header->InsertSheet,
 898            expected->InsertSheet);
 899
 900   if (header->Jog != expected->Jog)
 901     printf("    Jog %d, expected %d\n", header->Jog,
 902            expected->Jog);
 903
 904   if (header->LeadingEdge != expected->LeadingEdge)
 905     printf("    LeadingEdge %d, expected %d\n", header->LeadingEdge,
 906            expected->LeadingEdge);
 907
 908   if (header->Margins[0] != expected->Margins[0] ||
 909       header->Margins[1] != expected->Margins[1])
 910     printf("    Margins [%d %d], expected [%d %d]\n",
 911            header->Margins[0], header->Margins[1],
 912            expected->Margins[0], expected->Margins[1]);
 913
 914   if (header->ManualFeed != expected->ManualFeed)
 915     printf("    ManualFeed %d, expected %d\n", header->ManualFeed,
 916            expected->ManualFeed);
 917
 918   if (header->MediaPosition != expected->MediaPosition)
 919     printf("    MediaPosition %d, expected %d\n", header->MediaPosition,
 920            expected->MediaPosition);
 921
 922   if (header->MediaWeight != expected->MediaWeight)
 923     printf("    MediaWeight %d, expected %d\n", header->MediaWeight,
 924            expected->MediaWeight);
 925
 926   if (header->MirrorPrint != expected->MirrorPrint)
 927     printf("    MirrorPrint %d, expected %d\n", header->MirrorPrint,
 928            expected->MirrorPrint);
 929
 930   if (header->NegativePrint != expected->NegativePrint)
 931     printf("    NegativePrint %d, expected %d\n", header->NegativePrint,
 932            expected->NegativePrint);
 933
 934   if (header->NumCopies != expected->NumCopies)
 935     printf("    NumCopies %d, expected %d\n", header->NumCopies,
 936            expected->NumCopies);
 937
 938   if (header->Orientation != expected->Orientation)
 939     printf("    Orientation %d, expected %d\n", header->Orientation,
 940            expected->Orientation);
 941
 942   if (header->OutputFaceUp != expected->OutputFaceUp)
 943     printf("    OutputFaceUp %d, expected %d\n", header->OutputFaceUp,
 944            expected->OutputFaceUp);
 945
 946   if (header->PageSize[0] != expected->PageSize[0] ||
 947       header->PageSize[1] != expected->PageSize[1])
 948     printf("    PageSize [%d %d], expected [%d %d]\n",
 949            header->PageSize[0], header->PageSize[1],
 950            expected->PageSize[0], expected->PageSize[1]);
 951
 952   if (header->Separations != expected->Separations)
 953     printf("    Separations %d, expected %d\n", header->Separations,
 954            expected->Separations);
 955
 956   if (header->TraySwitch != expected->TraySwitch)
 957     printf("    TraySwitch %d, expected %d\n", header->TraySwitch,
 958            expected->TraySwitch);
 959
 960   if (header->Tumble != expected->Tumble)
 961     printf("    Tumble %d, expected %d\n", header->Tumble,
 962            expected->Tumble);
 963
 964   if (header->cupsWidth != expected->cupsWidth)
 965     printf("    cupsWidth %d, expected %d\n", header->cupsWidth,
 966            expected->cupsWidth);
 967
 968   if (header->cupsHeight != expected->cupsHeight)
 969     printf("    cupsHeight %d, expected %d\n", header->cupsHeight,
 970            expected->cupsHeight);
 971
 972   if (header->cupsMediaType != expected->cupsMediaType)
 973     printf("    cupsMediaType %d, expected %d\n", header->cupsMediaType,
 974            expected->cupsMediaType);
 975
 976   if (header->cupsBitsPerColor != expected->cupsBitsPerColor)
 977     printf("    cupsBitsPerColor %d, expected %d\n", header->cupsBitsPerColor,
 978            expected->cupsBitsPerColor);
 979
 980   if (header->cupsBitsPerPixel != expected->cupsBitsPerPixel)
 981     printf("    cupsBitsPerPixel %d, expected %d\n", header->cupsBitsPerPixel,
 982            expected->cupsBitsPerPixel);
 983
 984   if (header->cupsBytesPerLine != expected->cupsBytesPerLine)
 985     printf("    cupsBytesPerLine %d, expected %d\n", header->cupsBytesPerLine,
 986            expected->cupsBytesPerLine);
 987
 988   if (header->cupsColorOrder != expected->cupsColorOrder)
 989     printf("    cupsColorOrder %d, expected %d\n", header->cupsColorOrder,
 990            expected->cupsColorOrder);
 991
 992   if (header->cupsColorSpace != expected->cupsColorSpace)
 993     printf("    cupsColorSpace %d, expected %d\n", header->cupsColorSpace,
 994            expected->cupsColorSpace);
 995
 996   if (header->cupsCompression != expected->cupsCompression)
 997     printf("    cupsCompression %d, expected %d\n", header->cupsCompression,
 998            expected->cupsCompression);
 999
1000   if (header->cupsRowCount != expected->cupsRowCount)
1001     printf("    cupsRowCount %d, expected %d\n", header->cupsRowCount,
1002            expected->cupsRowCount);
1003
1004   if (header->cupsRowFeed != expected->cupsRowFeed)
1005     printf("    cupsRowFeed %d, expected %d\n", header->cupsRowFeed,
1006            expected->cupsRowFeed);
1007
1008   if (header->cupsRowStep != expected->cupsRowStep)
1009     printf("    cupsRowStep %d, expected %d\n", header->cupsRowStep,
1010            expected->cupsRowStep);
1011
1012   if (header->cupsNumColors != expected->cupsNumColors)
1013     printf("    cupsNumColors %d, expected %d\n", header->cupsNumColors,
1014            expected->cupsNumColors);
1015
1016   if (fabs(header->cupsBorderlessScalingFactor - expected->cupsBorderlessScalingFactor) > 0.001)
1017     printf("    cupsBorderlessScalingFactor %g, expected %g\n",
1018            header->cupsBorderlessScalingFactor,
1019            expected->cupsBorderlessScalingFactor);
1020
1021   if (fabs(header->cupsPageSize[0] - expected->cupsPageSize[0]) > 0.001 ||
1022       fabs(header->cupsPageSize[1] - expected->cupsPageSize[1]) > 0.001)
1023     printf("    cupsPageSize [%g %g], expected [%g %g]\n",
1024            header->cupsPageSize[0], header->cupsPageSize[1],
1025            expected->cupsPageSize[0], expected->cupsPageSize[1]);
1026
1027   if (fabs(header->cupsImagingBBox[0] - expected->cupsImagingBBox[0]) > 0.001 ||
1028       fabs(header->cupsImagingBBox[1] - expected->cupsImagingBBox[1]) > 0.001 ||
1029       fabs(header->cupsImagingBBox[2] - expected->cupsImagingBBox[2]) > 0.001 ||
1030       fabs(header->cupsImagingBBox[3] - expected->cupsImagingBBox[3]) > 0.001)
1031     printf("    cupsImagingBBox [%g %g %g %g], expected [%g %g %g %g]\n",
1032            header->cupsImagingBBox[0], header->cupsImagingBBox[1],
1033            header->cupsImagingBBox[2], header->cupsImagingBBox[3],
1034            expected->cupsImagingBBox[0], expected->cupsImagingBBox[1],
1035            expected->cupsImagingBBox[2], expected->cupsImagingBBox[3]);
1036
1037   for (i = 0; i < 16; i ++)
1038     if (header->cupsInteger[i] != expected->cupsInteger[i])
1039       printf("    cupsInteger%d %d, expected %d\n", i, header->cupsInteger[i],
1040              expected->cupsInteger[i]);
1041
1042   for (i = 0; i < 16; i ++)
1043     if (fabs(header->cupsReal[i] - expected->cupsReal[i]) > 0.001)
1044       printf("    cupsReal%d %g, expected %g\n", i, header->cupsReal[i],
1045              expected->cupsReal[i]);
1046
1047   for (i = 0; i < 16; i ++)
1048     if (strcmp(header->cupsString[i], expected->cupsString[i]))
1049       printf("    cupsString%d (%s), expected (%s)\n", i,
1050              header->cupsString[i], expected->cupsString[i]);
1051
1052   if (strcmp(header->cupsMarkerType, expected->cupsMarkerType))
1053     printf("    cupsMarkerType (%s), expected (%s)\n", header->cupsMarkerType,
1054            expected->cupsMarkerType);
1055
1056   if (strcmp(header->cupsRenderingIntent, expected->cupsRenderingIntent))
1057     printf("    cupsRenderingIntent (%s), expected (%s)\n",
1058            header->cupsRenderingIntent,
1059            expected->cupsRenderingIntent);
1060
1061   if (strcmp(header->cupsPageSizeName, expected->cupsPageSizeName))
1062     printf("    cupsPageSizeName (%s), expected (%s)\n",
1063            header->cupsPageSizeName,
1064            expected->cupsPageSizeName);
1065 }
1066
1067
1068 /*
1069  * End of "$Id$".
1070  */