1 
2 /* tarith.c
3  *
4  * Copyright (c) 2011-2013 John Cunningham Bowler
5  *
6  * Last changed in libpng 1.6.0 [February 14, 2013]
7  *
8  * This code is released under the libpng license.
9  * For conditions of distribution and use, see the disclaimer
10  * and license in png.h
11  *
12  * Test internal arithmetic functions of libpng.
13  *
14  * This code must be linked against a math library (-lm), but does not require
15  * libpng or zlib to work.  Because it includes the complete source of 'png.c'
16  * it tests the code with whatever compiler options are used to build it.
17  * Changing these options can substantially change the errors in the
18  * calculations that the compiler chooses!
19  */
20 #define _POSIX_SOURCE 1
21 #define _ISOC99_SOURCE 1
22 
23 /* Obtain a copy of the code to be tested (plus other things), disabling
24  * stuff that is not required.
25  */
26 #include <math.h>
27 #include <stdlib.h>
28 #include <ctype.h>
29 #include <string.h>
30 #include <assert.h>
31 
32 #include "../../pngpriv.h"
33 
34 #define png_error png_warning
35 
png_warning(png_const_structrp png_ptr,png_const_charp msg)36 void png_warning(png_const_structrp png_ptr, png_const_charp msg)
37 {
38    fprintf(stderr, "validation: %s\n", msg);
39 }
40 
41 #define png_fixed_error png_fixed_warning
42 
png_fixed_warning(png_const_structrp png_ptr,png_const_charp msg)43 void png_fixed_warning(png_const_structrp png_ptr, png_const_charp msg)
44 {
45    fprintf(stderr, "overflow in: %s\n", msg);
46 }
47 
48 #define png_set_error_fn(pp, ep, efp, wfp) ((void)0)
49 #define png_malloc(pp, s) malloc(s)
50 #define png_malloc_warn(pp, s) malloc(s)
51 #define png_malloc_base(pp, s) malloc(s)
52 #define png_calloc(pp, s) calloc(1, (s))
53 #define png_free(pp, s) free(s)
54 
55 #define png_safecat(b, sb, pos, str) (pos)
56 #define png_format_number(start, end, format, number) (start)
57 
58 #define crc32(crc, pp, s) (crc)
59 #define inflateReset(zs) Z_OK
60 
61 #define png_create_struct(type) (0)
62 #define png_destroy_struct(pp) ((void)0)
63 #define png_create_struct_2(type, m, mm) (0)
64 #define png_destroy_struct_2(pp, f, mm) ((void)0)
65 
66 #undef PNG_SIMPLIFIED_READ_SUPPORTED
67 #undef PNG_SIMPLIFIED_WRITE_SUPPORTED
68 #undef PNG_USER_MEM_SUPPORTED
69 
70 #include "../../png.c"
71 
72 /* Validate ASCII to fp routines. */
73 static int verbose = 0;
74 
validation_ascii_to_fp(int count,int argc,char ** argv)75 int validation_ascii_to_fp(int count, int argc, char **argv)
76 {
77    int    showall = 0;
78    double max_error=2;      /* As a percentage error-in-last-digit/.5 */
79    double max_error_abs=17; /* Used when precision is DBL_DIG */
80    double max = 0;
81    double max_abs = 0;
82    double test = 0; /* Important to test this. */
83    int    precision = 5;
84    int    nonfinite = 0;
85    int    finite = 0;
86    int    ok = 0;
87    int    failcount = 0;
88    int    minorarith = 0;
89 
90    while (--argc > 0)
91       if (strcmp(*++argv, "-a") == 0)
92          showall = 1;
93       else if (strcmp(*argv, "-e") == 0 && argc > 0)
94       {
95          --argc;
96          max_error = atof(*++argv);
97       }
98       else if (strcmp(*argv, "-E") == 0 && argc > 0)
99       {
100          --argc;
101          max_error_abs = atof(*++argv);
102       }
103       else
104       {
105          fprintf(stderr, "unknown argument %s\n", *argv);
106          return 1;
107       }
108 
109    do
110    {
111       png_size_t index;
112       int state, failed = 0;
113       char buffer[64];
114 
115       if (isfinite(test))
116          ++finite;
117       else
118          ++nonfinite;
119 
120       if (verbose)
121          fprintf(stderr, "%.*g %d\n", DBL_DIG, test, precision);
122 
123       /* Check for overflow in the buffer by setting a marker. */
124       memset(buffer, 71, sizeof buffer);
125 
126       png_ascii_from_fp(0, buffer, precision+10, test, precision);
127 
128       /* Allow for a three digit exponent, this stuff will fail if
129        * the exponent is bigger than this!
130        */
131       if (buffer[precision+7] != 71)
132       {
133          fprintf(stderr, "%g[%d] -> '%s'[%lu] buffer overflow\n", test,
134             precision, buffer, (unsigned long)strlen(buffer));
135          failed = 1;
136       }
137 
138       /* Following are used for the number parser below and must be
139        * initialized to zero.
140        */
141       state = 0;
142       index = 0;
143       if (!isfinite(test))
144       {
145          /* Expect 'inf' */
146          if (test >= 0 && strcmp(buffer, "inf") ||
147              test <  0 && strcmp(buffer, "-inf"))
148          {
149             fprintf(stderr, "%g[%d] -> '%s' but expected 'inf'\n", test,
150                precision, buffer);
151             failed = 1;
152          }
153       }
154       else if (!png_check_fp_number(buffer, precision+10, &state, &index) ||
155           buffer[index] != 0)
156       {
157          fprintf(stderr, "%g[%d] -> '%s' but has bad format ('%c')\n", test,
158          precision, buffer, buffer[index]);
159          failed = 1;
160       }
161       else if (PNG_FP_IS_NEGATIVE(state) && !(test < 0))
162       {
163          fprintf(stderr, "%g[%d] -> '%s' but negative value not so reported\n",
164             test, precision, buffer);
165          failed = 1;
166          assert(!PNG_FP_IS_ZERO(state));
167          assert(!PNG_FP_IS_POSITIVE(state));
168       }
169       else if (PNG_FP_IS_ZERO(state) && !(test == 0))
170       {
171          fprintf(stderr, "%g[%d] -> '%s' but zero value not so reported\n",
172             test, precision, buffer);
173          failed = 1;
174          assert(!PNG_FP_IS_NEGATIVE(state));
175          assert(!PNG_FP_IS_POSITIVE(state));
176       }
177       else if (PNG_FP_IS_POSITIVE(state) && !(test > 0))
178       {
179          fprintf(stderr, "%g[%d] -> '%s' but postive value not so reported\n",
180             test, precision, buffer);
181          failed = 1;
182          assert(!PNG_FP_IS_NEGATIVE(state));
183          assert(!PNG_FP_IS_ZERO(state));
184       }
185       else
186       {
187          /* Check the result against the original. */
188          double out = atof(buffer);
189          double change = fabs((out - test)/test);
190          double allow = .5/pow(10,
191             (precision >= DBL_DIG) ? DBL_DIG-1 : precision-1);
192 
193          /* NOTE: if you hit this error case are you compiling with gcc
194           * and -O0?  Try -O2 - the errors can accumulate if the FP
195           * code above is not optimized and may drift outside the .5 in
196           * DBL_DIG allowed.  In any case a small number of errors may
197           * occur (very small ones - 1 or 2%) because of rounding in the
198           * calculations, either in the conversion API or in atof.
199           */
200          if (change >= allow && (isfinite(out) ||
201              fabs(test/DBL_MAX) <= 1-allow))
202          {
203             double percent = (precision >= DBL_DIG) ? max_error_abs : max_error;
204             double allowp = (change-allow)*100/allow;
205 
206             if (precision >= DBL_DIG)
207             {
208                if (max_abs < allowp) max_abs = allowp;
209             }
210 
211             else
212             {
213                if (max < allowp) max = allowp;
214             }
215 
216             if (showall || allowp >= percent)
217             {
218                fprintf(stderr,
219                   "%.*g[%d] -> '%s' -> %.*g number changed (%g > %g (%d%%))\n",
220                   DBL_DIG, test, precision, buffer, DBL_DIG, out, change, allow,
221                   (int)round(allowp));
222                failed = 1;
223             }
224             else
225                ++minorarith;
226          }
227       }
228 
229       if (failed)
230          ++failcount;
231       else
232          ++ok;
233 
234 skip:
235       /* Generate a new number and precision. */
236       precision = rand();
237       if (precision & 1) test = -test;
238       precision >>= 1;
239 
240       /* Generate random numbers. */
241       if (test == 0 || !isfinite(test))
242          test = precision+1;
243       else
244       {
245          /* Derive the exponent from the previous rand() value. */
246          int exponent = precision % (DBL_MAX_EXP - DBL_MIN_EXP) + DBL_MIN_EXP;
247          int tmp;
248          test = frexp(test * rand(), &tmp);
249          test = ldexp(test, exponent);
250          precision >>= 8; /* arbitrary */
251       }
252 
253       /* This limits the precision to 32 digits, enough for standard
254        * IEEE implementations which have at most 15 digits.
255        */
256       precision = (precision & 0x1f) + 1;
257    }
258    while (--count);
259 
260    printf("Tested %d finite values, %d non-finite, %d OK (%d failed) %d minor "
261       "arithmetic errors\n", finite, nonfinite, ok, failcount, minorarith);
262    printf(" Error with >=%d digit precision %.2f%%\n", DBL_DIG, max_abs);
263    printf(" Error with < %d digit precision %.2f%%\n", DBL_DIG, max);
264 
265    return 0;
266 }
267 
268 /* Observe that valid FP numbers have the forms listed in the PNG extensions
269  * specification:
270  *
271  * [+,-]{integer,integer.fraction,.fraction}[{e,E}[+,-]integer]
272  *
273  * Test each of these in turn, including invalid cases.
274  */
275 typedef enum checkfp_state
276 {
277    start, fraction, exponent, states
278 } checkfp_state;
279 
280 /* The characters (other than digits) that characterize the states: */
281 static const char none[] = "";
282 static const char hexdigits[16] = "0123456789ABCDEF";
283 
284 static const struct
285 {
286    const char *start; /* Characters valid at the start */
287    const char *end;   /* Valid characters that end the state */
288    const char *tests; /* Characters to test after 2 digits seen */
289 }
290 state_characters[states] =
291 {
292    /* start:    */ { "+-.", ".eE", "+-.e*0369" },
293    /* fraction: */ { none, "eE",  "+-.E#0147" },
294    /* exponent: */ { "+-", none,  "+-.eE^0258" }
295 };
296 
297 typedef struct
298 {
299    char number[1024];  /* Buffer for number being tested */
300    int  limit;         /* Command line limit */
301    int  verbose;       /* Shadows global variable */
302    int  ctimes;        /* Number of numbers tested */
303    int  cmillions;     /* Count of millions of numbers */
304    int  cinvalid;      /* Invalid strings checked */
305    int  cnoaccept;     /* Characters not accepted */
306 }
307 checkfp_command;
308 
309 typedef struct
310 {
311    int           cnumber;          /* Index into number string */
312    checkfp_state check_state;      /* Current number state */
313    int           at_start;         /* At start (first character) of state */
314    int           cdigits_in_state; /* Digits seen in that state */
315    int           limit;            /* Limit on same for checking all chars */
316    int           state;            /* Current parser state */
317    int           is_negative;      /* Number is negative */
318    int           is_zero;          /* Number is (still) zero */
319    int           number_was_valid; /* Previous character validity */
320 }
321 checkfp_control;
322 
323 static int check_all_characters(checkfp_command *co, checkfp_control c);
324 
325 static int check_some_characters(checkfp_command *co, checkfp_control c,
326    const char *tests);
327 
check_one_character(checkfp_command * co,checkfp_control c,int ch)328 static int check_one_character(checkfp_command *co, checkfp_control c, int ch)
329 {
330    /* Test this character (ch) to ensure the parser does the correct thing.
331     */
332    png_size_t index = 0;
333    const char test = (char)ch;
334    const int number_is_valid = png_check_fp_number(&test, 1, &c.state, &index);
335    const int character_accepted = (index == 1);
336 
337    if (c.check_state != exponent && isdigit(ch) && ch != '0')
338       c.is_zero = 0;
339 
340    if (c.check_state == start && c.at_start && ch == '-')
341       c.is_negative = 1;
342 
343    if (isprint(ch))
344       co->number[c.cnumber++] = (char)ch;
345    else
346    {
347       co->number[c.cnumber++] = '<';
348       co->number[c.cnumber++] = hexdigits[(ch >> 4) & 0xf];
349       co->number[c.cnumber++] = hexdigits[ch & 0xf];
350       co->number[c.cnumber++] = '>';
351    }
352    co->number[c.cnumber] = 0;
353 
354    if (co->verbose > 1)
355       fprintf(stderr, "%s\n", co->number);
356 
357    if (++(co->ctimes) == 1000000)
358    {
359       if (co->verbose == 1)
360          fputc('.', stderr);
361       co->ctimes = 0;
362       ++(co->cmillions);
363    }
364 
365    if (!number_is_valid)
366       ++(co->cinvalid);
367 
368    if (!character_accepted)
369       ++(co->cnoaccept);
370 
371    /* This should never fail (it's a serious bug if it does): */
372    if (index != 0 && index != 1)
373    {
374       fprintf(stderr, "%s: read beyond end of string (%lu)\n", co->number,
375          (unsigned long)index);
376       return 0;
377    }
378 
379    /* Validate the new state, note that the PNG_FP_IS_ macros all return
380     * false unless the number is valid.
381     */
382    if (PNG_FP_IS_NEGATIVE(c.state) !=
383       (number_is_valid && !c.is_zero && c.is_negative))
384    {
385       fprintf(stderr, "%s: negative when it is not\n", co->number);
386       return 0;
387    }
388 
389    if (PNG_FP_IS_ZERO(c.state) != (number_is_valid && c.is_zero))
390    {
391       fprintf(stderr, "%s: zero when it is not\n", co->number);
392       return 0;
393    }
394 
395    if (PNG_FP_IS_POSITIVE(c.state) !=
396       (number_is_valid && !c.is_zero && !c.is_negative))
397    {
398       fprintf(stderr, "%s: positive when it is not\n", co->number);
399       return 0;
400    }
401 
402    /* Testing a digit */
403    if (isdigit(ch))
404    {
405       if (!character_accepted)
406       {
407          fprintf(stderr, "%s: digit '%c' not accepted\n", co->number, ch);
408          return 0;
409       }
410 
411       if (!number_is_valid)
412       {
413          fprintf(stderr, "%s: saw a digit (%c) but number not valid\n",
414             co->number, ch);
415          return 0;
416       }
417 
418       ++c.cdigits_in_state;
419       c.at_start = 0;
420       c.number_was_valid = 1;
421 
422       /* Continue testing characters in this state.  Either test all of
423        * them or, if we have already seen one digit in this state, just test a
424        * limited set.
425        */
426       if (c.cdigits_in_state < 1)
427          return check_all_characters(co, c);
428 
429       else
430          return check_some_characters(co, c,
431             state_characters[c.check_state].tests);
432    }
433 
434    /* A non-digit; is it allowed here? */
435    else if (((ch == '+' || ch == '-') && c.check_state != fraction &&
436                c.at_start) ||
437             (ch == '.' && c.check_state == start) ||
438             ((ch == 'e' || ch == 'E') && c.number_was_valid &&
439                c.check_state != exponent))
440    {
441       if (!character_accepted)
442       {
443          fprintf(stderr, "%s: character '%c' not accepted\n", co->number, ch);
444          return 0;
445       }
446 
447       /* The number remains valid after start of fraction but nowhere else. */
448       if (number_is_valid && (c.check_state != start || ch != '.'))
449       {
450          fprintf(stderr, "%s: saw a non-digit (%c) but number valid\n",
451             co->number, ch);
452          return 0;
453       }
454 
455       c.number_was_valid = number_is_valid;
456 
457       /* Check for a state change.  When changing to 'fraction' if the number
458        * is valid at this point set the at_start to false to allow an exponent
459        * 'e' to come next.
460        */
461       if (c.check_state == start && ch == '.')
462       {
463          c.check_state = fraction;
464          c.at_start = !number_is_valid;
465          c.cdigits_in_state = 0;
466          c.limit = co->limit;
467          return check_all_characters(co, c);
468       }
469 
470       else if (c.check_state < exponent && (ch == 'e' || ch == 'E'))
471       {
472          c.check_state = exponent;
473          c.at_start = 1;
474          c.cdigits_in_state = 0;
475          c.limit = co->limit;
476          return check_all_characters(co, c);
477       }
478 
479       /* Else it was a sign, and the state doesn't change. */
480       else
481       {
482          if (ch != '-' && ch != '+')
483          {
484             fprintf(stderr, "checkfp: internal error (1)\n");
485             return 0;
486          }
487 
488          c.at_start = 0;
489          return check_all_characters(co, c);
490       }
491    }
492 
493    /* Testing an invalid character */
494    else
495    {
496       if (character_accepted)
497       {
498          fprintf(stderr, "%s: character '%c' [0x%.2x] accepted\n", co->number,
499             ch, ch);
500          return 0;
501       }
502 
503       if (number_is_valid != c.number_was_valid)
504       {
505          fprintf(stderr,
506             "%s: character '%c' [0x%.2x] changed number validity\n", co->number,
507             ch, ch);
508          return 0;
509       }
510 
511       /* Do nothing - the parser has stuck; return success and keep going with
512        * the next character.
513        */
514    }
515 
516    /* Successful return (the caller will try the next character.) */
517    return 1;
518 }
519 
check_all_characters(checkfp_command * co,checkfp_control c)520 static int check_all_characters(checkfp_command *co, checkfp_control c)
521 {
522    int ch;
523 
524    if (c.cnumber+4 < sizeof co->number) for (ch=0; ch<256; ++ch)
525    {
526       if (!check_one_character(co, c, ch))
527          return 0;
528    }
529 
530    return 1;
531 }
532 
check_some_characters(checkfp_command * co,checkfp_control c,const char * tests)533 static int check_some_characters(checkfp_command *co, checkfp_control c,
534    const char *tests)
535 {
536    int i;
537 
538    --(c.limit);
539 
540    if (c.cnumber+4 < sizeof co->number && c.limit >= 0)
541    {
542       if (c.limit > 0) for (i=0; tests[i]; ++i)
543       {
544          if (!check_one_character(co, c, tests[i]))
545                return 0;
546       }
547 
548       /* At the end check all the characters. */
549       else
550          return check_all_characters(co, c);
551    }
552 
553    return 1;
554 }
555 
validation_checkfp(int count,int argc,char ** argv)556 int validation_checkfp(int count, int argc, char **argv)
557 {
558    int result;
559    checkfp_command command;
560    checkfp_control control;
561 
562    command.number[0] = 0;
563    command.limit = 3;
564    command.verbose = verbose;
565    command.ctimes = 0;
566    command.cmillions = 0;
567    command.cinvalid = 0;
568    command.cnoaccept = 0;
569 
570    while (--argc > 0)
571    {
572       ++argv;
573       if (argc > 1 && strcmp(*argv, "-l") == 0)
574       {
575          --argc;
576          command.limit = atoi(*++argv);
577       }
578 
579       else
580       {
581          fprintf(stderr, "unknown argument %s\n", *argv);
582          return 1;
583       }
584    }
585 
586    control.cnumber = 0;
587    control.check_state = start;
588    control.at_start = 1;
589    control.cdigits_in_state = 0;
590    control.limit = command.limit;
591    control.state = 0;
592    control.is_negative = 0;
593    control.is_zero = 1;
594    control.number_was_valid = 0;
595 
596    result = check_all_characters(&command, control);
597 
598    printf("checkfp: %s: checked %d,%.3d,%.3d,%.3d strings (%d invalid)\n",
599       result ? "pass" : "FAIL", command.cmillions / 1000,
600       command.cmillions % 1000, command.ctimes / 1000, command.ctimes % 1000,
601       command.cinvalid);
602 
603    return result;
604 }
605 
validation_muldiv(int count,int argc,char ** argv)606 int validation_muldiv(int count, int argc, char **argv)
607 {
608    int tested = 0;
609    int overflow = 0;
610    int error = 0;
611    int error64 = 0;
612    int passed = 0;
613    int randbits = 0;
614    png_uint_32 randbuffer;
615    png_fixed_point a;
616    png_int_32 times, div;
617 
618    while (--argc > 0)
619       {
620          fprintf(stderr, "unknown argument %s\n", *++argv);
621          return 1;
622       }
623 
624    /* Find out about the random number generator. */
625    randbuffer = RAND_MAX;
626    while (randbuffer != 0) ++randbits, randbuffer >>= 1;
627    printf("Using random number generator that makes %d bits\n", randbits);
628    for (div=0; div<32; div += randbits)
629       randbuffer = (randbuffer << randbits) ^ rand();
630 
631    a = 0;
632    times = div = 0;
633    do
634    {
635       png_fixed_point result;
636       /* NOTE: your mileage may vary, a type is required below that can
637        * hold 64 bits or more, if floating point is used a 64-bit or
638        * better mantissa is required.
639        */
640       long long int fp, fpround;
641       unsigned long hi, lo;
642       int ok;
643 
644       /* Check the values, png_64bit_product can only handle positive
645        * numbers, so correct for that here.
646        */
647       {
648          long u1, u2;
649          int n = 0;
650          if (a < 0) u1 = -a, n = 1; else u1 = a;
651          if (times < 0) u2 = -times, n = !n; else u2 = times;
652          png_64bit_product(u1, u2, &hi, &lo);
653          if (n)
654          {
655             /* -x = ~x+1 */
656             lo = ((~lo) + 1) & 0xffffffff;
657             hi = ~hi;
658             if (lo == 0) ++hi;
659          }
660       }
661 
662       fp = a;
663       fp *= times;
664       if ((fp & 0xffffffff) != lo || ((fp >> 32) & 0xffffffff) != hi)
665       {
666          fprintf(stderr, "png_64bit_product %d * %d -> %lx|%.8lx not %llx\n",
667             a, times, hi, lo, fp);
668          ++error64;
669       }
670 
671       if (div != 0)
672       {
673          /* Round - this is C round to zero. */
674          if ((fp < 0) != (div < 0))
675            fp -= div/2;
676          else
677            fp += div/2;
678 
679          fp /= div;
680          fpround = fp;
681          /* Assume 2's complement here: */
682          ok = fpround <= PNG_UINT_31_MAX &&
683               fpround >= -1-(long long int)PNG_UINT_31_MAX;
684          if (!ok) ++overflow;
685       }
686       else
687         ok = 0, ++overflow, fpround = fp/*misleading*/;
688 
689       if (verbose)
690          fprintf(stderr, "TEST %d * %d / %d -> %lld (%s)\n", a, times, div,
691             fp, ok ? "ok" : "overflow");
692 
693       ++tested;
694       if (png_muldiv(&result, a, times, div) != ok)
695       {
696          ++error;
697          if (ok)
698              fprintf(stderr, "%d * %d / %d -> overflow (expected %lld)\n", a,
699                 times, div, fp);
700          else
701              fprintf(stderr, "%d * %d / %d -> %d (expected overflow %lld)\n", a,
702                 times, div, result, fp);
703       }
704       else if (ok && result != fpround)
705       {
706          ++error;
707          fprintf(stderr, "%d * %d / %d -> %d not %lld\n", a, times, div, result,
708             fp);
709       }
710       else
711          ++passed;
712 
713       /* Generate three new values, this uses rand() and rand() only returns
714        * up to RAND_MAX.
715        */
716       /* CRUDE */
717       a += times;
718       times += div;
719       div = randbuffer;
720       randbuffer = (randbuffer << randbits) ^ rand();
721    }
722    while (--count > 0);
723 
724    printf("%d tests including %d overflows, %d passed, %d failed (%d 64-bit "
725       "errors)\n", tested, overflow, passed, error, error64);
726    return 0;
727 }
728 
729 /* When FP is on this just becomes a speed test - compile without FP to get real
730  * validation.
731  */
732 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
733 #define LN2 .000010576586617430806112933839 /* log(2)/65536 */
734 #define L2INV 94548.46219969910586572651    /* 65536/log(2) */
735 
736 /* For speed testing, need the internal functions too: */
png_log8bit(unsigned x)737 static png_uint_32 png_log8bit(unsigned x)
738 {
739    if (x > 0)
740       return (png_uint_32)floor(.5-log(x/255.)*L2INV);
741 
742    return 0xffffffff;
743 }
744 
png_log16bit(png_uint_32 x)745 static png_uint_32 png_log16bit(png_uint_32 x)
746 {
747    if (x > 0)
748       return (png_uint_32)floor(.5-log(x/65535.)*L2INV);
749 
750    return 0xffffffff;
751 }
752 
png_exp(png_uint_32 x)753 static png_uint_32 png_exp(png_uint_32 x)
754 {
755    return (png_uint_32)floor(.5 + exp(x * -LN2) * 0xffffffffU);
756 }
757 
png_exp8bit(png_uint_32 log)758 static png_byte png_exp8bit(png_uint_32 log)
759 {
760    return (png_byte)floor(.5 + exp(log * -LN2) * 255);
761 }
762 
png_exp16bit(png_uint_32 log)763 static png_uint_16 png_exp16bit(png_uint_32 log)
764 {
765    return (png_uint_16)floor(.5 + exp(log * -LN2) * 65535);
766 }
767 #endif /* FLOATING_ARITHMETIC */
768 
validation_gamma(int argc,char ** argv)769 int validation_gamma(int argc, char **argv)
770 {
771    double gamma[9] = { 2.2, 1.8, 1.52, 1.45, 1., 1/1.45, 1/1.52, 1/1.8, 1/2.2 };
772    double maxerr;
773    int i, silent=0, onlygamma=0;
774 
775    /* Silence the output with -s, just test the gamma functions with -g: */
776    while (--argc > 0)
777       if (strcmp(*++argv, "-s") == 0)
778          silent = 1;
779       else if (strcmp(*argv, "-g") == 0)
780          onlygamma = 1;
781       else
782       {
783          fprintf(stderr, "unknown argument %s\n", *argv);
784          return 1;
785       }
786 
787    if (!onlygamma)
788    {
789       /* First validate the log functions: */
790       maxerr = 0;
791       for (i=0; i<256; ++i)
792       {
793          double correct = -log(i/255.)/log(2.)*65536;
794          double error = png_log8bit(i) - correct;
795 
796          if (i != 0 && fabs(error) > maxerr)
797             maxerr = fabs(error);
798 
799          if (i == 0 && png_log8bit(i) != 0xffffffff ||
800              i != 0 && png_log8bit(i) != floor(correct+.5))
801          {
802             fprintf(stderr, "8-bit log error: %d: got %u, expected %f\n",
803                i, png_log8bit(i), correct);
804          }
805       }
806 
807       if (!silent)
808          printf("maximum 8-bit log error = %f\n", maxerr);
809 
810       maxerr = 0;
811       for (i=0; i<65536; ++i)
812       {
813          double correct = -log(i/65535.)/log(2.)*65536;
814          double error = png_log16bit(i) - correct;
815 
816          if (i != 0 && fabs(error) > maxerr)
817             maxerr = fabs(error);
818 
819          if (i == 0 && png_log16bit(i) != 0xffffffff ||
820              i != 0 && png_log16bit(i) != floor(correct+.5))
821          {
822             if (error > .68) /* By experiment error is less than .68 */
823             {
824                fprintf(stderr, "16-bit log error: %d: got %u, expected %f"
825                   " error: %f\n", i, png_log16bit(i), correct, error);
826             }
827          }
828       }
829 
830       if (!silent)
831          printf("maximum 16-bit log error = %f\n", maxerr);
832 
833       /* Now exponentiations. */
834       maxerr = 0;
835       for (i=0; i<=0xfffff; ++i)
836       {
837          double correct = exp(-i/65536. * log(2.)) * (65536. * 65536);
838          double error = png_exp(i) - correct;
839 
840          if (fabs(error) > maxerr)
841             maxerr = fabs(error);
842          if (fabs(error) > 1883) /* By experiment. */
843          {
844             fprintf(stderr, "32-bit exp error: %d: got %u, expected %f"
845                   " error: %f\n", i, png_exp(i), correct, error);
846          }
847       }
848 
849       if (!silent)
850          printf("maximum 32-bit exp error = %f\n", maxerr);
851 
852       maxerr = 0;
853       for (i=0; i<=0xfffff; ++i)
854       {
855          double correct = exp(-i/65536. * log(2.)) * 255;
856          double error = png_exp8bit(i) - correct;
857 
858          if (fabs(error) > maxerr)
859             maxerr = fabs(error);
860          if (fabs(error) > .50002) /* By experiment */
861          {
862             fprintf(stderr, "8-bit exp error: %d: got %u, expected %f"
863                   " error: %f\n", i, png_exp8bit(i), correct, error);
864          }
865       }
866 
867       if (!silent)
868          printf("maximum 8-bit exp error = %f\n", maxerr);
869 
870       maxerr = 0;
871       for (i=0; i<=0xfffff; ++i)
872       {
873          double correct = exp(-i/65536. * log(2.)) * 65535;
874          double error = png_exp16bit(i) - correct;
875 
876          if (fabs(error) > maxerr)
877             maxerr = fabs(error);
878          if (fabs(error) > .524) /* By experiment */
879          {
880             fprintf(stderr, "16-bit exp error: %d: got %u, expected %f"
881                   " error: %f\n", i, png_exp16bit(i), correct, error);
882          }
883       }
884 
885       if (!silent)
886          printf("maximum 16-bit exp error = %f\n", maxerr);
887    } /* !onlygamma */
888 
889    /* Test the overall gamma correction. */
890    for (i=0; i<9; ++i)
891    {
892       unsigned j;
893       double g = gamma[i];
894       png_fixed_point gfp = floor(g * PNG_FP_1 + .5);
895 
896       if (!silent)
897          printf("Test gamma %f\n", g);
898 
899       maxerr = 0;
900       for (j=0; j<256; ++j)
901       {
902          double correct = pow(j/255., g) * 255;
903          png_byte out = png_gamma_8bit_correct(j, gfp);
904          double error = out - correct;
905 
906          if (fabs(error) > maxerr)
907             maxerr = fabs(error);
908          if (out != floor(correct+.5))
909          {
910             fprintf(stderr, "8bit %d ^ %f: got %d expected %f error %f\n",
911                j, g, out, correct, error);
912          }
913       }
914 
915       if (!silent)
916          printf("gamma %f: maximum 8-bit error %f\n", g, maxerr);
917 
918       maxerr = 0;
919       for (j=0; j<65536; ++j)
920       {
921          double correct = pow(j/65535., g) * 65535;
922          png_uint_16 out = png_gamma_16bit_correct(j, gfp);
923          double error = out - correct;
924 
925          if (fabs(error) > maxerr)
926             maxerr = fabs(error);
927          if (fabs(error) > 1.62)
928          {
929             fprintf(stderr, "16bit %d ^ %f: got %d expected %f error %f\n",
930                j, g, out, correct, error);
931          }
932       }
933 
934       if (!silent)
935          printf("gamma %f: maximum 16-bit error %f\n", g, maxerr);
936    }
937 
938    return 0;
939 }
940 
941 /**************************** VALIDATION TESTS ********************************/
942 /* Various validation routines are included herein, they require some
943  * definition for png_warning and png_error, seetings of VALIDATION:
944  *
945  * 1: validates the ASCII to floating point conversions
946  * 2: validates png_muldiv
947  * 3: accuracy test of fixed point gamma tables
948  */
949 
950 /* The following COUNT (10^8) takes about 1 hour on a 1GHz Pentium IV
951  * processor.
952  */
953 #define COUNT 1000000000
954 
main(int argc,char ** argv)955 int main(int argc, char **argv)
956 {
957    int count = COUNT;
958 
959    while (argc > 1)
960    {
961       if (argc > 2 && strcmp(argv[1], "-c") == 0)
962       {
963          count = atoi(argv[2]);
964          argc -= 2;
965          argv += 2;
966       }
967 
968       else if (strcmp(argv[1], "-v") == 0)
969       {
970          ++verbose;
971          --argc;
972          ++argv;
973       }
974 
975       else
976          break;
977    }
978 
979    if (count > 0 && argc > 1)
980    {
981       if (strcmp(argv[1], "ascii") == 0)
982          return validation_ascii_to_fp(count, argc-1, argv+1);
983       else if (strcmp(argv[1], "checkfp") == 0)
984          return validation_checkfp(count, argc-1, argv+1);
985       else if (strcmp(argv[1], "muldiv") == 0)
986          return validation_muldiv(count, argc-1, argv+1);
987       else if (strcmp(argv[1], "gamma") == 0)
988          return validation_gamma(argc-1, argv+1);
989    }
990 
991    /* Bad argument: */
992    fprintf(stderr,
993       "usage: tarith [-v] [-c count] {ascii,muldiv,gamma} [args]\n");
994    fprintf(stderr, " arguments: ascii [-a (all results)] [-e error%%]\n");
995    fprintf(stderr, "            checkfp [-l max-number-chars]\n");
996    fprintf(stderr, "            muldiv\n");
997    fprintf(stderr, "            gamma -s (silent) -g (only gamma; no log)\n");
998    return 1;
999 }
1000