contrib/libtests/timepng.c

   1 /* timepng.c
   2  *
   3  * Copyright (c) 2013,2016 John Cunningham Bowler
   4  *
   5  * Last changed in libpng 1.6.22 [May 26, 2016]
   6  *
   7  * This code is released under the libpng license.
   8  * For conditions of distribution and use, see the disclaimer
   9  * and license in png.h
  10  *
  11  * Load an arbitrary number of PNG files (from the command line, or, if there
  12  * are no arguments on the command line, from stdin) then run a time test by
  13  * reading each file by row or by image (possibly with transforms in the latter
  14  * case).  The only output is a time as a floating point number of seconds with
  15  * 9 decimal digits.
  16  */
  17 #define _POSIX_C_SOURCE 199309L /* for clock_gettime */
  18
  19 #include <stdlib.h>
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <errno.h>
  23 #include <limits.h>
  24
  25 #include <time.h>
  26
  27 #if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
  28 #  include <config.h>
  29 #endif
  30
  31 /* Define the following to use this test against your installed libpng, rather
  32  * than the one being built here:
  33  */
  34 #ifdef PNG_FREESTANDING_TESTS
  35 #  include <png.h>
  36 #else
  37 #  include "../../png.h"
  38 #endif
  39
  40 /* The following is to support direct compilation of this file as C++ */
  41 #ifdef __cplusplus
  42 #  define voidcast(type, value) static_cast<type>(value)
  43 #else
  44 #  define voidcast(type, value) (value)
  45 #endif /* __cplusplus */
  46
  47 /* 'CLOCK_PROCESS_CPUTIME_ID' is one of the clock timers for clock_gettime.  It
  48  * need not be supported even when clock_gettime is available.  It returns the
  49  * 'CPU' time the process has consumed.  'CPU' time is assumed to include time
  50  * when the CPU is actually blocked by a pending cache fill but not time
  51  * waiting for page faults.  The attempt is to get a measure of the actual time
  52  * the implementation takes to read a PNG ignoring the potentially very large IO
  53  * overhead.
  54  */
  55 #if defined (CLOCK_PROCESS_CPUTIME_ID) && defined(PNG_STDIO_SUPPORTED) &&\
  56     defined(PNG_EASY_ACCESS_SUPPORTED) &&\
  57     (PNG_LIBPNG_VER >= 10700 ? defined(PNG_READ_PNG_SUPPORTED) :\
  58      defined (PNG_SEQUENTIAL_READ_SUPPORTED) &&\
  59      defined(PNG_INFO_IMAGE_SUPPORTED))
  60
  61 typedef struct
  62 {
  63    FILE *input;
  64    FILE *output;
  65 }  io_data;
  66
  67 static PNG_CALLBACK(void, read_and_copy,
  68       (png_structp png_ptr, png_bytep buffer, size_t cb))
  69 {
  70    io_data *io = (io_data*)png_get_io_ptr(png_ptr);
  71
  72    if (fread(buffer, cb, 1, io->input) != 1)
  73       png_error(png_ptr, strerror(errno));
  74
  75    if (fwrite(buffer, cb, 1, io->output) != 1)
  76    {
  77       perror("temporary file");
  78       fprintf(stderr, "temporary file PNG write failed\n");
  79       exit(1);
  80    }
  81 }
  82
  83 static void read_by_row(png_structp png_ptr, png_infop info_ptr,
  84       FILE *write_ptr, FILE *read_ptr)
  85 {
  86    /* These don't get freed on error, this is fine; the program immediately
  87     * exits.
  88     */
  89    png_bytep row = NULL, display = NULL;
  90    io_data io_copy;
  91
  92    if (write_ptr != NULL)
  93    {
  94       /* Set up for a copy to the temporary file: */
  95       io_copy.input = read_ptr;
  96       io_copy.output = write_ptr;
  97       png_set_read_fn(png_ptr, &io_copy, read_and_copy);
  98    }
  99
 100    png_read_info(png_ptr, info_ptr);
 101
 102    {
 103       size_t rowbytes = png_get_rowbytes(png_ptr, info_ptr);
 104
 105       row = voidcast(png_bytep,malloc(rowbytes));
 106       display = voidcast(png_bytep,malloc(rowbytes));
 107
 108       if (row == NULL || display == NULL)
 109          png_error(png_ptr, "OOM allocating row buffers");
 110
 111       {
 112          png_uint_32 height = png_get_image_height(png_ptr, info_ptr);
 113          int passes = png_set_interlace_handling(png_ptr);
 114          int pass;
 115
 116          png_start_read_image(png_ptr);
 117
 118          for (pass = 0; pass < passes; ++pass)
 119          {
 120             png_uint_32 y = height;
 121
 122             /* NOTE: this trashes the row each time; interlace handling won't
 123              * work, but this avoids memory thrashing for speed testing and is
 124              * somewhat representative of an application that works row-by-row.
 125              */
 126             while (y-- > 0)
 127                png_read_row(png_ptr, row, display);
 128          }
 129       }
 130    }
 131
 132    /* Make sure to read to the end of the file: */
 133    png_read_end(png_ptr, info_ptr);
 134
 135    /* Free this up: */
 136    free(row);
 137    free(display);
 138 }
 139
 140 static PNG_CALLBACK(void, no_warnings, (png_structp png_ptr,
 141          png_const_charp warning))
 142 {
 143    (void)png_ptr;
 144    (void)warning;
 145 }
 146
 147 static int read_png(FILE *fp, png_int_32 transforms, FILE *write_file)
 148 {
 149    png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,
 150          no_warnings);
 151    png_infop info_ptr = NULL;
 152
 153    if (png_ptr == NULL)
 154       return 0;
 155
 156    if (setjmp(png_jmpbuf(png_ptr)))
 157    {
 158       png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 159       return 0;
 160    }
 161
 162 #  ifdef PNG_BENIGN_ERRORS_SUPPORTED
 163       png_set_benign_errors(png_ptr, 1/*allowed*/);
 164 #  endif
 165    png_init_io(png_ptr, fp);
 166
 167    info_ptr = png_create_info_struct(png_ptr);
 168
 169    if (info_ptr == NULL)
 170       png_error(png_ptr, "OOM allocating info structure");
 171
 172    if (transforms < 0)
 173       read_by_row(png_ptr, info_ptr, write_file, fp);
 174
 175    else
 176       png_read_png(png_ptr, info_ptr, transforms, NULL/*params*/);
 177
 178    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 179    return 1;
 180 }
 181
 182 static int mytime(struct timespec *t)
 183 {
 184    /* Do the timing using clock_gettime and the per-process timer. */
 185    if (!clock_gettime(CLOCK_PROCESS_CPUTIME_ID, t))
 186       return 1;
 187
 188    perror("CLOCK_PROCESS_CPUTIME_ID");
 189    fprintf(stderr, "timepng: could not get the time\n");
 190    return 0;
 191 }
 192
 193 static int perform_one_test(FILE *fp, int nfiles, png_int_32 transforms)
 194 {
 195    int i;
 196    struct timespec before, after;
 197
 198    /* Clear out all errors: */
 199    rewind(fp);
 200
 201    if (mytime(&before))
 202    {
 203       for (i=0; i<nfiles; ++i)
 204       {
 205          if (read_png(fp, transforms, NULL/*write*/))
 206          {
 207             if (ferror(fp))
 208             {
 209                perror("temporary file");
 210                fprintf(stderr, "file %d: error reading PNG data\n", i);
 211                return 0;
 212             }
 213          }
 214
 215          else
 216          {
 217             perror("temporary file");
 218             fprintf(stderr, "file %d: error from libpng\n", i);
 219             return 0;
 220          }
 221       }
 222    }
 223
 224    else
 225       return 0;
 226
 227    if (mytime(&after))
 228    {
 229       /* Work out the time difference and print it - this is the only output,
 230        * so flush it immediately.
 231        */
 232       unsigned long s = after.tv_sec - before.tv_sec;
 233       long ns = after.tv_nsec - before.tv_nsec;
 234
 235       if (ns < 0)
 236       {
 237          --s;
 238          ns += 1000000000;
 239
 240          if (ns < 0)
 241          {
 242             fprintf(stderr, "timepng: bad clock from kernel\n");
 243             return 0;
 244          }
 245       }
 246
 247       printf("%lu.%.9ld\n", s, ns);
 248       fflush(stdout);
 249       if (ferror(stdout))
 250       {
 251          fprintf(stderr, "timepng: error writing output\n");
 252          return 0;
 253       }
 254
 255       /* Successful return */
 256       return 1;
 257    }
 258
 259    else
 260       return 0;
 261 }
 262
 263 static int add_one_file(FILE *fp, char *name)
 264 {
 265    FILE *ip = fopen(name, "rb");
 266
 267    if (ip != NULL)
 268    {
 269       /* Read the file using libpng; this detects errors and also deals with
 270        * files which contain data beyond the end of the file.
 271        */
 272       int ok = 0;
 273       fpos_t pos;
 274
 275       if (fgetpos(fp, &pos))
 276       {
 277          /* Fatal error reading the start: */
 278          perror("temporary file");
 279          fprintf(stderr, "temporary file fgetpos error\n");
 280          exit(1);
 281       }
 282
 283       if (read_png(ip, -1/*by row*/, fp/*output*/))
 284       {
 285          if (ferror(ip))
 286          {
 287             perror(name);
 288             fprintf(stderr, "%s: read error\n", name);
 289          }
 290
 291          else
 292             ok = 1; /* read ok */
 293       }
 294
 295       else
 296          fprintf(stderr, "%s: file not added\n", name);
 297
 298       (void)fclose(ip);
 299
 300       /* An error in the output is fatal; exit immediately: */
 301       if (ferror(fp))
 302       {
 303          perror("temporary file");
 304          fprintf(stderr, "temporary file write error\n");
 305          exit(1);
 306       }
 307
 308       if (ok)
 309          return 1;
 310
 311       /* Did not read the file successfully, simply rewind the temporary
 312        * file.  This must happen after the ferror check above to avoid clearing
 313        * the error.
 314        */
 315       if (fsetpos(fp, &pos))
 316       {
 317          perror("temporary file");
 318          fprintf(stderr, "temporary file fsetpos error\n");
 319          exit(1);
 320       }
 321    }
 322
 323    else
 324    {
 325       /* file open error: */
 326       perror(name);
 327       fprintf(stderr, "%s: open failed\n", name);
 328    }
 329
 330    return 0; /* file not added */
 331 }
 332
 333 static void
 334 usage(FILE *fp)
 335 {
 336    if (fp != NULL) fclose(fp);
 337
 338    fprintf(stderr,
 339 "Usage:\n"
 340 " timepng --assemble <assembly> {files}\n"
 341 "  Read the files into <assembly>, output the count.  Options are ignored.\n"
 342 " timepng --dissemble <assembly> <count> [options]\n"
 343 "  Time <count> files from <assembly>, additional files may not be given.\n"
 344 " Otherwise:\n"
 345 "  Read the files into a temporary file and time the decode\n"
 346 "Transforms:\n"
 347 "  --by-image: read by image with png_read_png\n"
 348 "  --<transform>: implies by-image, use PNG_TRANSFORM_<transform>\n"
 349 "  Otherwise: read by row using png_read_row (to a single row buffer)\n"
 350    /* ISO C90 string length max 509 */);fprintf(stderr,
 351 "{files}:\n"
 352 "  PNG files to copy into the assembly and time.  Invalid files are skipped\n"
 353 "  with appropriate error messages.  If no files are given the list of files\n"
 354 "  is read from stdin with each file name terminated by a newline\n"
 355 "Output:\n"
 356 "  For --assemble the output is the name of the assembly file followed by the\n"
 357 "  count of the files it contains; the arguments for --dissemble.  Otherwise\n"
 358 "  the output is the total decode time in seconds.\n");
 359
 360    exit(99);
 361 }
 362
 363 int main(int argc, char **argv)
 364 {
 365    int ok = 0;
 366    int err = 0;
 367    int nfiles = 0;
 368    int transforms = -1; /* by row */
 369    const char *assembly = NULL;
 370    FILE *fp;
 371
 372    if (argc > 2 && strcmp(argv[1], "--assemble") == 0)
 373    {
 374       /* Just build the test file, argv[2] is the file name. */
 375       assembly = argv[2];
 376       fp = fopen(assembly, "wb");
 377       if (fp == NULL)
 378       {
 379          perror(assembly);
 380          fprintf(stderr, "timepng --assemble %s: could not open for write\n",
 381                assembly);
 382          usage(NULL);
 383       }
 384
 385       argv += 2;
 386       argc -= 2;
 387    }
 388
 389    else if (argc > 3 && strcmp(argv[1], "--dissemble") == 0)
 390    {
 391       fp = fopen(argv[2], "rb");
 392
 393       if (fp == NULL)
 394       {
 395          perror(argv[2]);
 396          fprintf(stderr, "timepng --dissemble %s: could not open for read\n",
 397                argv[2]);
 398          usage(NULL);
 399       }
 400
 401       nfiles = atoi(argv[3]);
 402       if (nfiles <= 0)
 403       {
 404          fprintf(stderr,
 405                "timepng --dissemble <file> <count>: %s is not a count\n",
 406                argv[3]);
 407          exit(99);
 408       }
 409 #ifdef __COVERITY__
 410       else
 411       {
 412          nfiles &= PNG_UINT_31_MAX;
 413       }
 414 #endif
 415
 416       argv += 3;
 417       argc -= 3;
 418    }
 419
 420    else /* Else use a temporary file */
 421    {
 422 #ifndef __COVERITY__
 423       fp = tmpfile();
 424 #else
 425       /* Experimental. Coverity says tmpfile() is insecure because it
 426        * generates predictable names.
 427        *
 428        * It is possible to satisfy Coverity by using mkstemp(); however,
 429        * any platform supporting mkstemp() undoubtedly has a secure tmpfile()
 430        * implementation as well, and doesn't need the fix.  Note that
 431        * the fix won't work on platforms that don't support mkstemp().
 432        *
 433        * https://www.securecoding.cert.org/confluence/display/c/
 434        * FIO21-C.+Do+not+create+temporary+files+in+shared+directories
 435        * says that most historic implementations of tmpfile() provide
 436        * only a limited number of possible temporary file names
 437        * (usually 26) before file names are recycled. That article also
 438        * provides a secure solution that unfortunately depends upon mkstemp().
 439        */
 440       char tmpfile[] = "timepng-XXXXXX";
 441       int filedes;
 442       umask(0177);
 443       filedes = mkstemp(tmpfile);
 444       if (filedes < 0)
 445         fp = NULL;
 446       else
 447       {
 448         fp = fdopen(filedes,"w+");
 449         /* Hide the filename immediately and ensure that the file does
 450          * not exist after the program ends
 451          */
 452         (void) unlink(tmpfile);
 453       }
 454 #endif
 455
 456       if (fp == NULL)
 457       {
 458          perror("tmpfile");
 459          fprintf(stderr, "timepng: could not open the temporary file\n");
 460          exit(1); /* not a user error */
 461       }
 462    }
 463
 464    /* Handle the transforms: */
 465    while (argc > 1 && argv[1][0] == '-' && argv[1][1] == '-')
 466    {
 467       const char *opt = *++argv + 2;
 468
 469       --argc;
 470
 471       /* Transforms turn on the by-image processing and maybe set some
 472        * transforms:
 473        */
 474       if (transforms == -1)
 475          transforms = PNG_TRANSFORM_IDENTITY;
 476
 477       if (strcmp(opt, "by-image") == 0)
 478       {
 479          /* handled above */
 480       }
 481
 482 #        define OPT(name) else if (strcmp(opt, #name) == 0)\
 483          transforms |= PNG_TRANSFORM_ ## name
 484
 485       OPT(STRIP_16);
 486       OPT(STRIP_ALPHA);
 487       OPT(PACKING);
 488       OPT(PACKSWAP);
 489       OPT(EXPAND);
 490       OPT(INVERT_MONO);
 491       OPT(SHIFT);
 492       OPT(BGR);
 493       OPT(SWAP_ALPHA);
 494       OPT(SWAP_ENDIAN);
 495       OPT(INVERT_ALPHA);
 496       OPT(STRIP_FILLER);
 497       OPT(STRIP_FILLER_BEFORE);
 498       OPT(STRIP_FILLER_AFTER);
 499       OPT(GRAY_TO_RGB);
 500       OPT(EXPAND_16);
 501       OPT(SCALE_16);
 502
 503       else
 504       {
 505          fprintf(stderr, "timepng %s: unrecognized transform\n", opt);
 506          usage(fp);
 507       }
 508    }
 509
 510    /* Handle the files: */
 511    if (argc > 1 && nfiles > 0)
 512       usage(fp); /* Additional files not valid with --dissemble */
 513
 514    else if (argc > 1)
 515    {
 516       int i;
 517
 518       for (i=1; i<argc; ++i)
 519       {
 520          if (nfiles == INT_MAX)
 521          {
 522             fprintf(stderr, "%s: skipped, too many files\n", argv[i]);
 523             break;
 524          }
 525
 526          else if (add_one_file(fp, argv[i]))
 527             ++nfiles;
 528       }
 529    }
 530
 531    else if (nfiles == 0) /* Read from stdin withoout --dissemble */
 532    {
 533       char filename[FILENAME_MAX+1];
 534
 535       while (fgets(filename, FILENAME_MAX+1, stdin))
 536       {
 537          size_t len = strlen(filename);
 538
 539          if (filename[len-1] == '\n')
 540          {
 541             filename[len-1] = 0;
 542             if (nfiles == INT_MAX)
 543             {
 544                fprintf(stderr, "%s: skipped, too many files\n", filename);
 545                break;
 546             }
 547
 548             else if (add_one_file(fp, filename))
 549                ++nfiles;
 550          }
 551
 552          else
 553          {
 554             fprintf(stderr, "timepng: file name too long: ...%s\n",
 555                filename+len-32);
 556             err = 1;
 557             break;
 558          }
 559       }
 560
 561       if (ferror(stdin))
 562       {
 563          fprintf(stderr, "timepng: stdin: read error\n");
 564          err = 1;
 565       }
 566    }
 567
 568    /* Perform the test, or produce the --assemble output: */
 569    if (!err)
 570    {
 571       if (nfiles > 0)
 572       {
 573          if (assembly != NULL)
 574          {
 575             if (fflush(fp) && !ferror(fp) && fclose(fp))
 576             {
 577                perror(assembly);
 578                fprintf(stderr, "%s: close failed\n", assembly);
 579             }
 580
 581             else
 582             {
 583                printf("%s %d\n", assembly, nfiles);
 584                fflush(stdout);
 585                ok = !ferror(stdout);
 586             }
 587          }
 588
 589          else
 590          {
 591             ok = perform_one_test(fp, nfiles, transforms);
 592             (void)fclose(fp);
 593          }
 594       }
 595
 596       else
 597          usage(fp);
 598    }
 599
 600    else
 601       (void)fclose(fp);
 602
 603    /* Exit code 0 on success. */
 604    return ok == 0;
 605 }
 606 #else /* !sufficient support */
 607 int main(void) { return 77; }
 608 #endif /* !sufficient support */