contrib/libtests/timepng.c

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