1/* timepng.c
  2 *
  3 * Copyright (c) 2013 John Cunningham Bowler
  4 *
  5 * Last changed in libpng 1.6.1 [March 28, 2013]
  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.  The test does nothing with the read result and
 14 * does no transforms.  The only output is a time as a floating point number of
 15 * seconds with 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
 23#include <time.h>
 24
 25#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
 26#  include <config.h>
 27#endif
 28
 29/* Define the following to use this test against your installed libpng, rather
 30 * than the one being built here:
 31 */
 32#ifdef PNG_FREESTANDING_TESTS
 33#  include <png.h>
 34#else
 35#  include "../../png.h"
 36#endif
 37
 38static int read_png(FILE *fp)
 39{
 40   png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,0);
 41   png_infop info_ptr = NULL;
 42   png_bytep row = NULL, display = NULL;
 43
 44   if (png_ptr == NULL)
 45      return 0;
 46
 47   if (setjmp(png_jmpbuf(png_ptr)))
 48   {
 49      png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 50      if (row != NULL) free(row);
 51      if (display != NULL) free(display);
 52      return 0;
 53   }
 54
 55   png_init_io(png_ptr, fp);
 56
 57   info_ptr = png_create_info_struct(png_ptr);
 58   if (info_ptr == NULL)
 59      png_error(png_ptr, "OOM allocating info structure");
 60
 61   png_read_info(png_ptr, info_ptr);
 62
 63   {
 64      png_size_t rowbytes = png_get_rowbytes(png_ptr, info_ptr);
 65
 66      row = malloc(rowbytes);
 67      display = malloc(rowbytes);
 68
 69      if (row == NULL || display == NULL)
 70         png_error(png_ptr, "OOM allocating row buffers");
 71
 72      {
 73         png_uint_32 height = png_get_image_height(png_ptr, info_ptr);
 74         int passes = png_set_interlace_handling(png_ptr);
 75         int pass;
 76
 77         png_start_read_image(png_ptr);
 78
 79         for (pass = 0; pass < passes; ++pass)
 80         {
 81            png_uint_32 y = height;
 82
 83            /* NOTE: this trashes the row each time; interlace handling won't
 84             * work, but this avoids memory thrashing for speed testing.
 85             */
 86            while (y-- > 0)
 87               png_read_row(png_ptr, row, display);
 88         }
 89      }
 90   }
 91
 92   /* Make sure to read to the end of the file: */
 93   png_read_end(png_ptr, info_ptr);
 94   png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 95   free(row);
 96   free(display);
 97   return 1;
 98}
 99
100static int mytime(struct timespec *t)
101{
102   /* Do the timing using clock_gettime and the per-process timer. */
103   if (!clock_gettime(CLOCK_PROCESS_CPUTIME_ID, t))
104      return 1;
105
106   perror("CLOCK_PROCESS_CPUTIME_ID");
107   fprintf(stderr, "timepng: could not get the time\n");
108   return 0;
109}
110
111static int perform_one_test(FILE *fp, int nfiles)
112{
113   int i;
114   struct timespec before, after;
115
116   /* Clear out all errors: */
117   rewind(fp);
118
119   if (mytime(&before))
120   {
121      for (i=0; i<nfiles; ++i)
122      {
123         if (read_png(fp))
124         {
125            if (ferror(fp))
126            {
127               perror("temporary file");
128               fprintf(stderr, "file %d: error reading PNG data\n", i);
129               return 0;
130            }
131         }
132
133         else
134         {
135            perror("temporary file");
136            fprintf(stderr, "file %d: error from libpng\n", i);
137            return 0;
138         }
139      }
140   }
141
142   else
143      return 0;
144
145   if (mytime(&after))
146   {
147      /* Work out the time difference and print it - this is the only output,
148       * so flush it immediately.
149       */
150      unsigned long s = after.tv_sec - before.tv_sec;
151      long ns = after.tv_nsec - before.tv_nsec;
152
153      if (ns < 0)
154      {
155         --s;
156         ns += 1000000000;
157
158         if (ns < 0)
159         {
160            fprintf(stderr, "timepng: bad clock from kernel\n");
161            return 0;
162         }
163      }
164
165      printf("%lu.%.9ld\n", s, ns);
166      fflush(stdout);
167      if (ferror(stdout))
168      {
169         fprintf(stderr, "timepng: error writing output\n");
170         return 0;
171      }
172
173      /* Successful return */
174      return 1;
175   }
176
177   else
178      return 0;
179}
180
181static int add_one_file(FILE *fp, char *name)
182{
183   FILE *ip = fopen(name, "rb");
184
185   if (ip != NULL)
186   {
187      int ch;
188      for (;;)
189      {
190         ch = getc(ip);
191         if (ch == EOF) break;
192         putc(ch, fp);
193      }
194
195      if (ferror(ip))
196      {
197         perror(name);
198         fprintf(stderr, "%s: read error\n", name);
199         return 0;
200      }
201
202      (void)fclose(ip);
203
204      if (ferror(fp))
205      {
206         perror("temporary file");
207         fprintf(stderr, "temporary file write error\n");
208         return 0;
209      }
210   }
211
212   else
213   {
214      perror(name);
215      fprintf(stderr, "%s: open failed\n", name);
216      return 0;
217   }
218
219   return 1;
220}
221
222int main(int argc, char **argv)
223{
224   int ok = 0;
225   FILE *fp = tmpfile();
226
227   if (fp != NULL)
228   {
229      int err = 0;
230      int nfiles = 0;
231
232      if (argc > 1)
233      {
234         int i;
235
236         for (i=1; i<argc; ++i)
237         {
238            if (add_one_file(fp, argv[i]))
239               ++nfiles;
240
241            else
242            {
243               err = 1;
244               break;
245            }
246         }
247      }
248
249      else
250      {
251         char filename[FILENAME_MAX+1];
252
253         while (fgets(filename, FILENAME_MAX+1, stdin))
254         {
255            size_t len = strlen(filename);
256
257            if (filename[len-1] == '\n')
258            {
259               filename[len-1] = 0;
260               if (add_one_file(fp, filename))
261                  ++nfiles;
262
263               else
264               {
265                  err = 1;
266                  break;
267               }
268            }
269
270            else
271            {
272               fprintf(stderr, "timepng: truncated file name ...%s\n",
273                  filename+len-32);
274               err = 1;
275               break;
276            }
277         }
278
279         if (ferror(stdin))
280         {
281            fprintf(stderr, "timepng: stdin: read error\n");
282            err = 1;
283         }
284      }
285
286      if (!err)
287      {
288         if (nfiles > 0)
289            ok = perform_one_test(fp, nfiles);
290
291         else
292            fprintf(stderr, "usage: timepng {files} or ls files | timepng\n");
293      }
294
295      (void)fclose(fp);
296   }
297
298   else
299      fprintf(stderr, "timepng: could not open temporary file\n");
300
301   /* Exit code 0 on success. */
302   return ok == 0;
303}