filter/testraster.c

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