contrib/libtests/pngstest.c

   1 /*-
   2  * pngstest.c
   3  *
   4  * Copyright (c) 2013 John Cunningham Bowler
   5  *
   6  * Last changed in libpng 1.6.8 [December 19, 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 for the PNG 'simplified' APIs.
  13  */
  14 #define _ISOC90_SOURCE 1
  15 #define MALLOC_CHECK_ 2/*glibc facility: turn on debugging*/
  16
  17 #include <stddef.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <stdio.h>
  21 #include <errno.h>
  22 #include <ctype.h>
  23 #include <math.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
  38 #ifdef PNG_SIMPLIFIED_READ_SUPPORTED /* Else nothing can be done */
  39 #include "../tools/sRGB.h"
  40
  41 /* KNOWN ISSUES
  42  *
  43  * These defines switch on alternate algorithms for format conversions to match
  44  * the current libpng implementation; they are set to allow pngstest to pass
  45  * even though libpng is producing answers that are not as correct as they
  46  * should be.
  47  */
  48 #define ALLOW_UNUSED_GPC 0
  49    /* If true include unused static GPC functions and declare an external array
  50     * of them to hide the fact that they are unused.  This is for development
  51     * use while testing the correct function to use to take into account libpng
  52     * misbehavior, such as using a simple power law to correct sRGB to linear.
  53     */
  54
  55 /* The following is to support direct compilation of this file as C++ */
  56 #ifdef __cplusplus
  57 #  define voidcast(type, value) static_cast<type>(value)
  58 #  define aligncastconst(type, value) \
  59       static_cast<type>(static_cast<const void*>(value))
  60 #else
  61 #  define voidcast(type, value) (value)
  62 #  define aligncastconst(type, value) ((const void*)(value))
  63 #endif /* __cplusplus */
  64
  65 /* During parallel runs of pngstest each temporary file needs a unique name,
  66  * this is used to permit uniqueness using a command line argument which can be
  67  * up to 22 characters long.
  68  */
  69 static char tmpf[23] = "TMP";
  70
  71 /* Generate random bytes.  This uses a boring repeatable algorithm and it
  72  * is implemented here so that it gives the same set of numbers on every
  73  * architecture.  It's a linear congruential generator (Knuth or Sedgewick
  74  * "Algorithms") but it comes from the 'feedback taps' table in Horowitz and
  75  * Hill, "The Art of Electronics".
  76  */
  77 static void
  78 make_random_bytes(png_uint_32* seed, void* pv, size_t size)
  79 {
  80    png_uint_32 u0 = seed[0], u1 = seed[1];
  81    png_bytep bytes = voidcast(png_bytep, pv);
  82
  83    /* There are thirty three bits, the next bit in the sequence is bit-33 XOR
  84     * bit-20.  The top 1 bit is in u1, the bottom 32 are in u0.
  85     */
  86    size_t i;
  87    for (i=0; i<size; ++i)
  88    {
  89       /* First generate 8 new bits then shift them in at the end. */
  90       png_uint_32 u = ((u0 >> (20-8)) ^ ((u1 << 7) | (u0 >> (32-7)))) & 0xff;
  91       u1 <<= 8;
  92       u1 |= u0 >> 24;
  93       u0 <<= 8;
  94       u0 |= u;
  95       *bytes++ = (png_byte)u;
  96    }
  97
  98    seed[0] = u0;
  99    seed[1] = u1;
 100 }
 101
 102 static void
 103 random_color(png_colorp color)
 104 {
 105    static png_uint_32 color_seed[2] = { 0x12345678, 0x9abcdef };
 106    make_random_bytes(color_seed, color, sizeof *color);
 107 }
 108
 109 /* Math support - neither Cygwin nor Visual Studio have C99 support and we need
 110  * a predictable rounding function, so make one here:
 111  */
 112 static double
 113 closestinteger(double x)
 114 {
 115    return floor(x + .5);
 116 }
 117
 118 /* Cast support: remove GCC whines. */
 119 static png_byte
 120 u8d(double d)
 121 {
 122    d = closestinteger(d);
 123    return (png_byte)d;
 124 }
 125
 126 static png_uint_16
 127 u16d(double d)
 128 {
 129    d = closestinteger(d);
 130    return (png_uint_16)d;
 131 }
 132
 133 /* sRGB support: use exact calculations rounded to the nearest int, see the
 134  * fesetround() call in main().  sRGB_to_d optimizes the 8 to 16-bit conversion.
 135  */
 136 static double sRGB_to_d[256];
 137 static double g22_to_d[256];
 138
 139 static void
 140 init_sRGB_to_d(void)
 141 {
 142    int i;
 143
 144    sRGB_to_d[0] = 0;
 145    for (i=1; i<255; ++i)
 146       sRGB_to_d[i] = linear_from_sRGB(i/255.);
 147    sRGB_to_d[255] = 1;
 148
 149    g22_to_d[0] = 0;
 150    for (i=1; i<255; ++i)
 151       g22_to_d[i] = pow(i/255., 1/.45455);
 152    g22_to_d[255] = 1;
 153 }
 154
 155 static png_byte
 156 sRGB(double linear /*range 0.0 .. 1.0*/)
 157 {
 158    return u8d(255 * sRGB_from_linear(linear));
 159 }
 160
 161 static png_byte
 162 isRGB(int fixed_linear)
 163 {
 164    return sRGB(fixed_linear / 65535.);
 165 }
 166
 167 #if 0 /* not used */
 168 static png_byte
 169 unpremultiply(int component, int alpha)
 170 {
 171    if (alpha <= component)
 172       return 255; /* Arbitrary, but consistent with the libpng code */
 173
 174    else if (alpha >= 65535)
 175       return isRGB(component);
 176
 177    else
 178       return sRGB((double)component / alpha);
 179 }
 180 #endif
 181
 182 static png_uint_16
 183 ilinear(int fixed_srgb)
 184 {
 185    return u16d(65535 * sRGB_to_d[fixed_srgb]);
 186 }
 187
 188 static png_uint_16
 189 ilineara(int fixed_srgb, int alpha)
 190 {
 191    return u16d((257 * alpha) * sRGB_to_d[fixed_srgb]);
 192 }
 193
 194 static png_uint_16
 195 ilinear_g22(int fixed_srgb)
 196 {
 197    return u16d(65535 * g22_to_d[fixed_srgb]);
 198 }
 199
 200 #if ALLOW_UNUSED_GPC
 201 static png_uint_16
 202 ilineara_g22(int fixed_srgb, int alpha)
 203 {
 204    return u16d((257 * alpha) * g22_to_d[fixed_srgb]);
 205 }
 206 #endif
 207
 208 static double
 209 YfromRGBint(int ir, int ig, int ib)
 210 {
 211    double r = ir;
 212    double g = ig;
 213    double b = ib;
 214    return YfromRGB(r, g, b);
 215 }
 216
 217 #if 0 /* unused */
 218 /* The error that results from using a 2.2 power law in place of the correct
 219  * sRGB transform, given an 8-bit value which might be either sRGB or power-law.
 220  */
 221 static int
 222 power_law_error8(int value)
 223 {
 224    if (value > 0 && value < 255)
 225    {
 226       double vd = value / 255.;
 227       double e = fabs(
 228          pow(sRGB_to_d[value], 1/2.2) - sRGB_from_linear(pow(vd, 2.2)));
 229
 230       /* Always allow an extra 1 here for rounding errors */
 231       e = 1+floor(255 * e);
 232       return (int)e;
 233    }
 234
 235    return 0;
 236 }
 237
 238 static int error_in_sRGB_roundtrip = 56; /* by experiment */
 239 static int
 240 power_law_error16(int value)
 241 {
 242    if (value > 0 && value < 65535)
 243    {
 244       /* Round trip the value through an 8-bit representation but using
 245        * non-matching to/from conversions.
 246        */
 247       double vd = value / 65535.;
 248       double e = fabs(
 249          pow(sRGB_from_linear(vd), 2.2) - linear_from_sRGB(pow(vd, 1/2.2)));
 250
 251       /* Always allow an extra 1 here for rounding errors */
 252       e = error_in_sRGB_roundtrip+floor(65535 * e);
 253       return (int)e;
 254    }
 255
 256    return 0;
 257 }
 258
 259 static int
 260 compare_8bit(int v1, int v2, int error_limit, int multiple_algorithms)
 261 {
 262    int e = abs(v1-v2);
 263    int ev1, ev2;
 264
 265    if (e <= error_limit)
 266       return 1;
 267
 268    if (!multiple_algorithms)
 269       return 0;
 270
 271    ev1 = power_law_error8(v1);
 272    if (e <= ev1)
 273       return 1;
 274
 275    ev2 = power_law_error8(v2);
 276    if (e <= ev2)
 277       return 1;
 278
 279    return 0;
 280 }
 281
 282 static int
 283 compare_16bit(int v1, int v2, int error_limit, int multiple_algorithms)
 284 {
 285    int e = abs(v1-v2);
 286    int ev1, ev2;
 287
 288    if (e <= error_limit)
 289       return 1;
 290
 291    /* "multiple_algorithms" in this case means that a color-map has been
 292     * involved somewhere, so we can deduce that the values were forced to 8-bit
 293     * (like the via_linear case for 8-bit.)
 294     */
 295    if (!multiple_algorithms)
 296       return 0;
 297
 298    ev1 = power_law_error16(v1);
 299    if (e <= ev1)
 300       return 1;
 301
 302    ev2 = power_law_error16(v2);
 303    if (e <= ev2)
 304       return 1;
 305
 306    return 0;
 307 }
 308 #endif /* unused */
 309
 310 #define READ_FILE 1      /* else memory */
 311 #define USE_STDIO 2      /* else use file name */
 312 #define STRICT 4         /* fail on warnings too */
 313 #define VERBOSE 8
 314 #define KEEP_TMPFILES 16 /* else delete temporary files */
 315 #define KEEP_GOING 32
 316 #define ACCUMULATE 64
 317 #define FAST_WRITE 128
 318 #define sRGB_16BIT 256
 319
 320 static void
 321 print_opts(png_uint_32 opts)
 322 {
 323    if (opts & READ_FILE)
 324       printf(" --file");
 325    if (opts & USE_STDIO)
 326       printf(" --stdio");
 327    if (opts & STRICT)
 328       printf(" --strict");
 329    if (opts & VERBOSE)
 330       printf(" --verbose");
 331    if (opts & KEEP_TMPFILES)
 332       printf(" --preserve");
 333    if (opts & KEEP_GOING)
 334       printf(" --keep-going");
 335    if (opts & ACCUMULATE)
 336       printf(" --accumulate");
 337    if (!(opts & FAST_WRITE)) /* --fast is currently the default */
 338       printf(" --slow");
 339    if (opts & sRGB_16BIT)
 340       printf(" --sRGB-16bit");
 341 }
 342
 343 #define FORMAT_NO_CHANGE 0x80000000 /* additional flag */
 344
 345 /* A name table for all the formats - defines the format of the '+' arguments to
 346  * pngstest.
 347  */
 348 #define FORMAT_COUNT 64
 349 #define FORMAT_MASK 0x3f
 350 static PNG_CONST char * PNG_CONST format_names[FORMAT_COUNT] =
 351 {
 352    "sRGB-gray",
 353    "sRGB-gray+alpha",
 354    "sRGB-rgb",
 355    "sRGB-rgb+alpha",
 356    "linear-gray",
 357    "linear-gray+alpha",
 358    "linear-rgb",
 359    "linear-rgb+alpha",
 360
 361    "color-mapped-sRGB-gray",
 362    "color-mapped-sRGB-gray+alpha",
 363    "color-mapped-sRGB-rgb",
 364    "color-mapped-sRGB-rgb+alpha",
 365    "color-mapped-linear-gray",
 366    "color-mapped-linear-gray+alpha",
 367    "color-mapped-linear-rgb",
 368    "color-mapped-linear-rgb+alpha",
 369
 370    "sRGB-gray",
 371    "sRGB-gray+alpha",
 372    "sRGB-bgr",
 373    "sRGB-bgr+alpha",
 374    "linear-gray",
 375    "linear-gray+alpha",
 376    "linear-bgr",
 377    "linear-bgr+alpha",
 378
 379    "color-mapped-sRGB-gray",
 380    "color-mapped-sRGB-gray+alpha",
 381    "color-mapped-sRGB-bgr",
 382    "color-mapped-sRGB-bgr+alpha",
 383    "color-mapped-linear-gray",
 384    "color-mapped-linear-gray+alpha",
 385    "color-mapped-linear-bgr",
 386    "color-mapped-linear-bgr+alpha",
 387
 388    "sRGB-gray",
 389    "alpha+sRGB-gray",
 390    "sRGB-rgb",
 391    "alpha+sRGB-rgb",
 392    "linear-gray",
 393    "alpha+linear-gray",
 394    "linear-rgb",
 395    "alpha+linear-rgb",
 396
 397    "color-mapped-sRGB-gray",
 398    "color-mapped-alpha+sRGB-gray",
 399    "color-mapped-sRGB-rgb",
 400    "color-mapped-alpha+sRGB-rgb",
 401    "color-mapped-linear-gray",
 402    "color-mapped-alpha+linear-gray",
 403    "color-mapped-linear-rgb",
 404    "color-mapped-alpha+linear-rgb",
 405
 406    "sRGB-gray",
 407    "alpha+sRGB-gray",
 408    "sRGB-bgr",
 409    "alpha+sRGB-bgr",
 410    "linear-gray",
 411    "alpha+linear-gray",
 412    "linear-bgr",
 413    "alpha+linear-bgr",
 414
 415    "color-mapped-sRGB-gray",
 416    "color-mapped-alpha+sRGB-gray",
 417    "color-mapped-sRGB-bgr",
 418    "color-mapped-alpha+sRGB-bgr",
 419    "color-mapped-linear-gray",
 420    "color-mapped-alpha+linear-gray",
 421    "color-mapped-linear-bgr",
 422    "color-mapped-alpha+linear-bgr",
 423 };
 424
 425 /* Decode an argument to a format number. */
 426 static png_uint_32
 427 formatof(const char *arg)
 428 {
 429    char *ep;
 430    unsigned long format = strtoul(arg, &ep, 0);
 431
 432    if (ep > arg && *ep == 0 && format < FORMAT_COUNT)
 433       return (png_uint_32)format;
 434
 435    else for (format=0; format < FORMAT_COUNT; ++format)
 436    {
 437       if (strcmp(format_names[format], arg) == 0)
 438          return (png_uint_32)format;
 439    }
 440
 441    fprintf(stderr, "pngstest: format name '%s' invalid\n", arg);
 442    return FORMAT_COUNT;
 443 }
 444
 445 /* Bitset/test functions for formats */
 446 #define FORMAT_SET_COUNT (FORMAT_COUNT / 32)
 447 typedef struct
 448 {
 449    png_uint_32 bits[FORMAT_SET_COUNT];
 450 }
 451 format_list;
 452
 453 static void format_init(format_list *pf)
 454 {
 455    int i;
 456    for (i=0; i<FORMAT_SET_COUNT; ++i)
 457       pf->bits[i] = 0; /* All off */
 458 }
 459
 460 #if 0 /* currently unused */
 461 static void format_clear(format_list *pf)
 462 {
 463    int i;
 464    for (i=0; i<FORMAT_SET_COUNT; ++i)
 465       pf->bits[i] = 0;
 466 }
 467 #endif
 468
 469 static int format_is_initial(format_list *pf)
 470 {
 471    int i;
 472    for (i=0; i<FORMAT_SET_COUNT; ++i)
 473       if (pf->bits[i] != 0)
 474          return 0;
 475
 476    return 1;
 477 }
 478
 479 static int format_set(format_list *pf, png_uint_32 format)
 480 {
 481    if (format < FORMAT_COUNT)
 482       return pf->bits[format >> 5] |= ((png_uint_32)1) << (format & 31);
 483
 484    return 0;
 485 }
 486
 487 #if 0 /* currently unused */
 488 static int format_unset(format_list *pf, png_uint_32 format)
 489 {
 490    if (format < FORMAT_COUNT)
 491       return pf->bits[format >> 5] &= ~((png_uint_32)1) << (format & 31);
 492
 493    return 0;
 494 }
 495 #endif
 496
 497 static int format_isset(format_list *pf, png_uint_32 format)
 498 {
 499    return format < FORMAT_COUNT &&
 500       (pf->bits[format >> 5] & (((png_uint_32)1) << (format & 31))) != 0;
 501 }
 502
 503 static void format_default(format_list *pf, int redundant)
 504 {
 505    if (redundant)
 506    {
 507       int i;
 508
 509       /* set everything, including flags that are pointless */
 510       for (i=0; i<FORMAT_SET_COUNT; ++i)
 511          pf->bits[i] = ~(png_uint_32)0;
 512    }
 513
 514    else
 515    {
 516       png_uint_32 f;
 517
 518       for (f=0; f<FORMAT_COUNT; ++f)
 519       {
 520          /* Eliminate redundant and unsupported settings. */
 521 #        ifdef PNG_FORMAT_BGR_SUPPORTED
 522             /* BGR is meaningless if no color: */
 523             if ((f & PNG_FORMAT_FLAG_COLOR) == 0 &&
 524                (f & PNG_FORMAT_FLAG_BGR) != 0)
 525 #        else
 526             if ((f & 0x10U/*HACK: fixed value*/) != 0)
 527 #        endif
 528             continue;
 529
 530          /* AFIRST is meaningless if no alpha: */
 531 #        ifdef PNG_FORMAT_AFIRST_SUPPORTED
 532             if ((f & PNG_FORMAT_FLAG_ALPHA) == 0 &&
 533                (f & PNG_FORMAT_FLAG_AFIRST) != 0)
 534 #        else
 535             if ((f & 0x20U/*HACK: fixed value*/) != 0)
 536 #        endif
 537             continue;
 538
 539          format_set(pf, f);
 540       }
 541    }
 542 }
 543
 544 /* THE Image STRUCTURE */
 545 /* The super-class of a png_image, contains the decoded image plus the input
 546  * data necessary to re-read the file with a different format.
 547  */
 548 typedef struct
 549 {
 550    png_image   image;
 551    png_uint_32 opts;
 552    const char *file_name;
 553    int         stride_extra;
 554    FILE       *input_file;
 555    png_voidp   input_memory;
 556    png_size_t  input_memory_size;
 557    png_bytep   buffer;
 558    ptrdiff_t   stride;
 559    png_size_t  bufsize;
 560    png_size_t  allocsize;
 561    char        tmpfile_name[32];
 562    png_uint_16 colormap[256*4];
 563 }
 564 Image;
 565
 566 /* Initializer: also sets the permitted error limit for 16-bit operations. */
 567 static void
 568 newimage(Image *image)
 569 {
 570    memset(image, 0, sizeof *image);
 571 }
 572
 573 /* Reset the image to be read again - only needs to rewind the FILE* at present.
 574  */
 575 static void
 576 resetimage(Image *image)
 577 {
 578    if (image->input_file != NULL)
 579       rewind(image->input_file);
 580 }
 581
 582 /* Free the image buffer; the buffer is re-used on a re-read, this is just for
 583  * cleanup.
 584  */
 585 static void
 586 freebuffer(Image *image)
 587 {
 588    if (image->buffer) free(image->buffer);
 589    image->buffer = NULL;
 590    image->bufsize = 0;
 591    image->allocsize = 0;
 592 }
 593
 594 /* Delete function; cleans out all the allocated data and the temporary file in
 595  * the image.
 596  */
 597 static void
 598 freeimage(Image *image)
 599 {
 600    freebuffer(image);
 601    png_image_free(&image->image);
 602
 603    if (image->input_file != NULL)
 604    {
 605       fclose(image->input_file);
 606       image->input_file = NULL;
 607    }
 608
 609    if (image->input_memory != NULL)
 610    {
 611       free(image->input_memory);
 612       image->input_memory = NULL;
 613       image->input_memory_size = 0;
 614    }
 615
 616    if (image->tmpfile_name[0] != 0 && (image->opts & KEEP_TMPFILES) == 0)
 617    {
 618       remove(image->tmpfile_name);
 619       image->tmpfile_name[0] = 0;
 620    }
 621 }
 622
 623 /* This is actually a re-initializer; allows an image structure to be re-used by
 624  * freeing everything that relates to an old image.
 625  */
 626 static void initimage(Image *image, png_uint_32 opts, const char *file_name,
 627    int stride_extra)
 628 {
 629    freeimage(image);
 630    memset(&image->image, 0, sizeof image->image);
 631    image->opts = opts;
 632    image->file_name = file_name;
 633    image->stride_extra = stride_extra;
 634 }
 635
 636 /* Make sure the image buffer is big enough; allows re-use of the buffer if the
 637  * image is re-read.
 638  */
 639 #define BUFFER_INIT8 73
 640 static void
 641 allocbuffer(Image *image)
 642 {
 643    png_size_t size = PNG_IMAGE_BUFFER_SIZE(image->image, image->stride);
 644
 645    if (size+32 > image->bufsize)
 646    {
 647       freebuffer(image);
 648       image->buffer = voidcast(png_bytep, malloc(size+32));
 649       if (image->buffer == NULL)
 650       {
 651          fflush(stdout);
 652          fprintf(stderr,
 653             "simpletest: out of memory allocating %lu(+32) byte buffer\n",
 654             (unsigned long)size);
 655          exit(1);
 656       }
 657       image->bufsize = size+32;
 658    }
 659
 660    memset(image->buffer, 95, image->bufsize);
 661    memset(image->buffer+16, BUFFER_INIT8, size);
 662    image->allocsize = size;
 663 }
 664
 665 /* Make sure 16 bytes match the given byte. */
 666 static int
 667 check16(png_const_bytep bp, int b)
 668 {
 669    int i = 16;
 670
 671    do
 672       if (*bp != b) return 1;
 673    while (--i);
 674
 675    return 0;
 676 }
 677
 678 /* Check for overwrite in the image buffer. */
 679 static void
 680 checkbuffer(Image *image, const char *arg)
 681 {
 682    if (check16(image->buffer, 95))
 683    {
 684       fflush(stdout);
 685       fprintf(stderr, "%s: overwrite at start of image buffer\n", arg);
 686       exit(1);
 687    }
 688
 689    if (check16(image->buffer+16+image->allocsize, 95))
 690    {
 691       fflush(stdout);
 692       fprintf(stderr, "%s: overwrite at end of image buffer\n", arg);
 693       exit(1);
 694    }
 695 }
 696
 697 /* ERROR HANDLING */
 698 /* Log a terminal error, also frees the libpng part of the image if necessary.
 699  */
 700 static int
 701 logerror(Image *image, const char *a1, const char *a2, const char *a3)
 702 {
 703    fflush(stdout);
 704    if (image->image.warning_or_error)
 705       fprintf(stderr, "%s%s%s: %s\n", a1, a2, a3, image->image.message);
 706
 707    else
 708       fprintf(stderr, "%s%s%s\n", a1, a2, a3);
 709
 710    if (image->image.opaque != NULL)
 711    {
 712       fprintf(stderr, "%s: image opaque pointer non-NULL on error\n",
 713          image->file_name);
 714       png_image_free(&image->image);
 715    }
 716
 717    return 0;
 718 }
 719
 720 /* Log an error and close a file (just a utility to do both things in one
 721  * function call.)
 722  */
 723 static int
 724 logclose(Image *image, FILE *f, const char *name, const char *operation)
 725 {
 726    int e = errno;
 727
 728    fclose(f);
 729    return logerror(image, name, operation, strerror(e));
 730 }
 731
 732 /* Make sure the png_image has been freed - validates that libpng is doing what
 733  * the spec says and freeing the image.
 734  */
 735 static int
 736 checkopaque(Image *image)
 737 {
 738    if (image->image.opaque != NULL)
 739    {
 740       png_image_free(&image->image);
 741       return logerror(image, image->file_name, ": opaque not NULL", "");
 742    }
 743
 744    else if (image->image.warning_or_error != 0 && (image->opts & STRICT) != 0)
 745       return logerror(image, image->file_name, " --strict", "");
 746
 747    else
 748       return 1;
 749 }
 750
 751 /* IMAGE COMPARISON/CHECKING */
 752 /* Compare the pixels of two images, which should be the same but aren't.  The
 753  * images must have been checked for a size match.
 754  */
 755 typedef struct
 756 {
 757    /* The components, for grayscale images the gray value is in 'g' and if alpha
 758     * is not present 'a' is set to 255 or 65535 according to format.
 759     */
 760    int         r, g, b, a;
 761 } Pixel;
 762
 763 typedef struct
 764 {
 765    /* The background as the original sRGB 8-bit value converted to the final
 766     * integer format and as a double precision linear value in the range 0..1
 767     * for with partially transparent pixels.
 768     */
 769    int ir, ig, ib;
 770    double dr, dg, db; /* linear r,g,b scaled to 0..1 */
 771 } Background;
 772
 773 /* Basic image formats; control the data but not the layout thereof. */
 774 #define BASE_FORMATS\
 775    (PNG_FORMAT_FLAG_ALPHA|PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_LINEAR)
 776
 777 /* Read a Pixel from a buffer.  The code below stores the correct routine for
 778  * the format in a function pointer, these are the routines:
 779  */
 780 static void
 781 gp_g8(Pixel *p, png_const_voidp pb)
 782 {
 783    png_const_bytep pp = voidcast(png_const_bytep, pb);
 784
 785    p->r = p->g = p->b = pp[0];
 786    p->a = 255;
 787 }
 788
 789 static void
 790 gp_ga8(Pixel *p, png_const_voidp pb)
 791 {
 792    png_const_bytep pp = voidcast(png_const_bytep, pb);
 793
 794    p->r = p->g = p->b = pp[0];
 795    p->a = pp[1];
 796 }
 797
 798 #ifdef PNG_FORMAT_AFIRST_SUPPORTED
 799 static void
 800 gp_ag8(Pixel *p, png_const_voidp pb)
 801 {
 802    png_const_bytep pp = voidcast(png_const_bytep, pb);
 803
 804    p->r = p->g = p->b = pp[1];
 805    p->a = pp[0];
 806 }
 807 #endif
 808
 809 static void
 810 gp_rgb8(Pixel *p, png_const_voidp pb)
 811 {
 812    png_const_bytep pp = voidcast(png_const_bytep, pb);
 813
 814    p->r = pp[0];
 815    p->g = pp[1];
 816    p->b = pp[2];
 817    p->a = 255;
 818 }
 819
 820 #ifdef PNG_FORMAT_BGR_SUPPORTED
 821 static void
 822 gp_bgr8(Pixel *p, png_const_voidp pb)
 823 {
 824    png_const_bytep pp = voidcast(png_const_bytep, pb);
 825
 826    p->r = pp[2];
 827    p->g = pp[1];
 828    p->b = pp[0];
 829    p->a = 255;
 830 }
 831 #endif
 832
 833 static void
 834 gp_rgba8(Pixel *p, png_const_voidp pb)
 835 {
 836    png_const_bytep pp = voidcast(png_const_bytep, pb);
 837
 838    p->r = pp[0];
 839    p->g = pp[1];
 840    p->b = pp[2];
 841    p->a = pp[3];
 842 }
 843
 844 #ifdef PNG_FORMAT_BGR_SUPPORTED
 845 static void
 846 gp_bgra8(Pixel *p, png_const_voidp pb)
 847 {
 848    png_const_bytep pp = voidcast(png_const_bytep, pb);
 849
 850    p->r = pp[2];
 851    p->g = pp[1];
 852    p->b = pp[0];
 853    p->a = pp[3];
 854 }
 855 #endif
 856
 857 #ifdef PNG_FORMAT_AFIRST_SUPPORTED
 858 static void
 859 gp_argb8(Pixel *p, png_const_voidp pb)
 860 {
 861    png_const_bytep pp = voidcast(png_const_bytep, pb);
 862
 863    p->r = pp[1];
 864    p->g = pp[2];
 865    p->b = pp[3];
 866    p->a = pp[0];
 867 }
 868 #endif
 869
 870 #if defined(PNG_FORMAT_AFIRST_SUPPORTED) && defined(PNG_FORMAT_BGR_SUPPORTED)
 871 static void
 872 gp_abgr8(Pixel *p, png_const_voidp pb)
 873 {
 874    png_const_bytep pp = voidcast(png_const_bytep, pb);
 875
 876    p->r = pp[3];
 877    p->g = pp[2];
 878    p->b = pp[1];
 879    p->a = pp[0];
 880 }
 881 #endif
 882
 883 static void
 884 gp_g16(Pixel *p, png_const_voidp pb)
 885 {
 886    png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
 887
 888    p->r = p->g = p->b = pp[0];
 889    p->a = 65535;
 890 }
 891
 892 static void
 893 gp_ga16(Pixel *p, png_const_voidp pb)
 894 {
 895    png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
 896
 897    p->r = p->g = p->b = pp[0];
 898    p->a = pp[1];
 899 }
 900
 901 #ifdef PNG_FORMAT_AFIRST_SUPPORTED
 902 static void
 903 gp_ag16(Pixel *p, png_const_voidp pb)
 904 {
 905    png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
 906
 907    p->r = p->g = p->b = pp[1];
 908    p->a = pp[0];
 909 }
 910 #endif
 911
 912 static void
 913 gp_rgb16(Pixel *p, png_const_voidp pb)
 914 {
 915    png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
 916
 917    p->r = pp[0];
 918    p->g = pp[1];
 919    p->b = pp[2];
 920    p->a = 65535;
 921 }
 922
 923 #ifdef PNG_FORMAT_BGR_SUPPORTED
 924 static void
 925 gp_bgr16(Pixel *p, png_const_voidp pb)
 926 {
 927    png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
 928
 929    p->r = pp[2];
 930    p->g = pp[1];
 931    p->b = pp[0];
 932    p->a = 65535;
 933 }
 934 #endif
 935
 936 static void
 937 gp_rgba16(Pixel *p, png_const_voidp pb)
 938 {
 939    png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
 940
 941    p->r = pp[0];
 942    p->g = pp[1];
 943    p->b = pp[2];
 944    p->a = pp[3];
 945 }
 946
 947 #ifdef PNG_FORMAT_BGR_SUPPORTED
 948 static void
 949 gp_bgra16(Pixel *p, png_const_voidp pb)
 950 {
 951    png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
 952
 953    p->r = pp[2];
 954    p->g = pp[1];
 955    p->b = pp[0];
 956    p->a = pp[3];
 957 }
 958 #endif
 959
 960 #ifdef PNG_FORMAT_AFIRST_SUPPORTED
 961 static void
 962 gp_argb16(Pixel *p, png_const_voidp pb)
 963 {
 964    png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
 965
 966    p->r = pp[1];
 967    p->g = pp[2];
 968    p->b = pp[3];
 969    p->a = pp[0];
 970 }
 971 #endif
 972
 973 #if defined(PNG_FORMAT_AFIRST_SUPPORTED) && defined(PNG_FORMAT_BGR_SUPPORTED)
 974 static void
 975 gp_abgr16(Pixel *p, png_const_voidp pb)
 976 {
 977    png_const_uint_16p pp = voidcast(png_const_uint_16p, pb);
 978
 979    p->r = pp[3];
 980    p->g = pp[2];
 981    p->b = pp[1];
 982    p->a = pp[0];
 983 }
 984 #endif
 985
 986 /* Given a format, return the correct one of the above functions. */
 987 static void (*
 988 get_pixel(png_uint_32 format))(Pixel *p, png_const_voidp pb)
 989 {
 990    /* The color-map flag is irrelevant here - the caller of the function
 991     * returned must either pass the buffer or, for a color-mapped image, the
 992     * correct entry in the color-map.
 993     */
 994    if (format & PNG_FORMAT_FLAG_LINEAR)
 995    {
 996       if (format & PNG_FORMAT_FLAG_COLOR)
 997       {
 998 #        ifdef PNG_FORMAT_BGR_SUPPORTED
 999             if (format & PNG_FORMAT_FLAG_BGR)
1000             {
1001                if (format & PNG_FORMAT_FLAG_ALPHA)
1002                {
1003 #                 ifdef PNG_FORMAT_AFIRST_SUPPORTED
1004                      if (format & PNG_FORMAT_FLAG_AFIRST)
1005                         return gp_abgr16;
1006
1007                      else
1008 #                 endif
1009                      return gp_bgra16;
1010                }
1011
1012                else
1013                   return gp_bgr16;
1014             }
1015
1016             else
1017 #        endif
1018          {
1019             if (format & PNG_FORMAT_FLAG_ALPHA)
1020             {
1021 #              ifdef PNG_FORMAT_AFIRST_SUPPORTED
1022                   if (format & PNG_FORMAT_FLAG_AFIRST)
1023                      return gp_argb16;
1024
1025                   else
1026 #              endif
1027                   return gp_rgba16;
1028             }
1029
1030             else
1031                return gp_rgb16;
1032          }
1033       }
1034
1035       else
1036       {
1037          if (format & PNG_FORMAT_FLAG_ALPHA)
1038          {
1039 #           ifdef PNG_FORMAT_AFIRST_SUPPORTED
1040                if (format & PNG_FORMAT_FLAG_AFIRST)
1041                   return gp_ag16;
1042
1043                else
1044 #           endif
1045                return gp_ga16;
1046          }
1047
1048          else
1049             return gp_g16;
1050       }
1051    }
1052
1053    else
1054    {
1055       if (format & PNG_FORMAT_FLAG_COLOR)
1056       {
1057 #        ifdef PNG_FORMAT_BGR_SUPPORTED
1058             if (format & PNG_FORMAT_FLAG_BGR)
1059             {
1060                if (format & PNG_FORMAT_FLAG_ALPHA)
1061                {
1062 #                 ifdef PNG_FORMAT_AFIRST_SUPPORTED
1063                      if (format & PNG_FORMAT_FLAG_AFIRST)
1064                         return gp_abgr8;
1065
1066                      else
1067 #                 endif
1068                      return gp_bgra8;
1069                }
1070
1071                else
1072                   return gp_bgr8;
1073             }
1074
1075             else
1076 #        endif
1077          {
1078             if (format & PNG_FORMAT_FLAG_ALPHA)
1079             {
1080 #              ifdef PNG_FORMAT_AFIRST_SUPPORTED
1081                   if (format & PNG_FORMAT_FLAG_AFIRST)
1082                      return gp_argb8;
1083
1084                   else
1085 #              endif
1086                   return gp_rgba8;
1087             }
1088
1089             else
1090                return gp_rgb8;
1091          }
1092       }
1093
1094       else
1095       {
1096          if (format & PNG_FORMAT_FLAG_ALPHA)
1097          {
1098 #           ifdef PNG_FORMAT_AFIRST_SUPPORTED
1099                if (format & PNG_FORMAT_FLAG_AFIRST)
1100                   return gp_ag8;
1101
1102                else
1103 #           endif
1104                return gp_ga8;
1105          }
1106
1107          else
1108             return gp_g8;
1109       }
1110    }
1111 }
1112
1113 /* Convertion between pixel formats.  The code above effectively eliminates the
1114  * component ordering changes leaving three basic changes:
1115  *
1116  * 1) Remove an alpha channel by pre-multiplication or compositing on a
1117  *    background color.  (Adding an alpha channel is a no-op.)
1118  *
1119  * 2) Remove color by mapping to grayscale.  (Grayscale to color is a no-op.)
1120  *
1121  * 3) Convert between 8-bit and 16-bit components.  (Both directtions are
1122  *    relevant.)
1123  *
1124  * This gives the following base format conversion matrix:
1125  *
1126  *   OUT:    ----- 8-bit -----    ----- 16-bit -----
1127  *   IN     G    GA   RGB  RGBA  G    GA   RGB  RGBA
1128  *  8 G     .    .    .    .     lin  lin  lin  lin
1129  *  8 GA    bckg .    bckc .     pre' pre  pre' pre
1130  *  8 RGB   g8   g8   .    .     glin glin lin  lin
1131  *  8 RGBA  g8b  g8   bckc .     gpr' gpre pre' pre
1132  * 16 G     sRGB sRGB sRGB sRGB  .    .    .    .
1133  * 16 GA    b16g unpg b16c unpc  A    .    A    .
1134  * 16 RGB   sG   sG   sRGB sRGB  g16  g16  .    .
1135  * 16 RGBA  gb16 sGp  cb16 sCp   g16  g16' A    .
1136  *
1137  *  8-bit to 8-bit:
1138  * bckg: composite on gray background
1139  * bckc: composite on color background
1140  * g8:   convert sRGB components to sRGB grayscale
1141  * g8b:  convert sRGB components to grayscale and composite on gray background
1142  *
1143  *  8-bit to 16-bit:
1144  * lin:  make sRGB components linear, alpha := 65535
1145  * pre:  make sRGB components linear and premultiply by alpha  (scale alpha)
1146  * pre': as 'pre' but alpha := 65535
1147  * glin: make sRGB components linear, convert to grayscale, alpha := 65535
1148  * gpre: make sRGB components grayscale and linear and premultiply by alpha
1149  * gpr': as 'gpre' but alpha := 65535
1150  *
1151  *  16-bit to 8-bit:
1152  * sRGB: convert linear components to sRGB, alpha := 255
1153  * unpg: unpremultiply gray component and convert to sRGB (scale alpha)
1154  * unpc: unpremultiply color components and convert to sRGB (scale alpha)
1155  * b16g: composite linear onto gray background and convert the result to sRGB
1156  * b16c: composite linear onto color background and convert the result to sRGB
1157  * sG:   convert linear RGB to sRGB grayscale
1158  * sGp:  unpremultiply RGB then convert to sRGB grayscale
1159  * sCp:  unpremultiply RGB then convert to sRGB
1160  * gb16: composite linear onto background and convert to sRGB grayscale
1161  *       (order doesn't matter, the composite and grayscale operations permute)
1162  * cb16: composite linear onto background and convert to sRGB
1163  *
1164  *  16-bit to 16-bit:
1165  * A:    set alpha to 65535
1166  * g16:  convert linear RGB to linear grayscale (alpha := 65535)
1167  * g16': as 'g16' but alpha is unchanged
1168  */
1169 /* Simple copy: */
1170 static void
1171 gpc_noop(Pixel *out, const Pixel *in, const Background *back)
1172 {
1173    (void)back;
1174    out->r = in->r;
1175    out->g = in->g;
1176    out->b = in->b;
1177    out->a = in->a;
1178 }
1179
1180 #if ALLOW_UNUSED_GPC
1181 static void
1182 gpc_nop8(Pixel *out, const Pixel *in, const Background *back)
1183 {
1184    (void)back;
1185    if (in->a == 0)
1186       out->r = out->g = out->b = 255;
1187
1188    else
1189    {
1190       out->r = in->r;
1191       out->g = in->g;
1192       out->b = in->b;
1193    }
1194
1195    out->a = in->a;
1196 }
1197 #endif
1198
1199 #if ALLOW_UNUSED_GPC
1200 static void
1201 gpc_nop6(Pixel *out, const Pixel *in, const Background *back)
1202 {
1203    (void)back;
1204    if (in->a == 0)
1205       out->r = out->g = out->b = 65535;
1206
1207    else
1208    {
1209       out->r = in->r;
1210       out->g = in->g;
1211       out->b = in->b;
1212    }
1213
1214    out->a = in->a;
1215 }
1216 #endif
1217
1218 /* 8-bit to 8-bit conversions */
1219 /* bckg: composite on gray background */
1220 static void
1221 gpc_bckg(Pixel *out, const Pixel *in, const Background *back)
1222 {
1223    if (in->a <= 0)
1224       out->r = out->g = out->b = back->ig;
1225
1226    else if (in->a >= 255)
1227       out->r = out->g = out->b = in->g;
1228
1229    else
1230    {
1231       double a = in->a / 255.;
1232
1233       out->r = out->g = out->b = sRGB(sRGB_to_d[in->g] * a + back->dg * (1-a));
1234    }
1235
1236    out->a = 255;
1237 }
1238
1239 /* bckc: composite on color background */
1240 static void
1241 gpc_bckc(Pixel *out, const Pixel *in, const Background *back)
1242 {
1243    if (in->a <= 0)
1244    {
1245       out->r = back->ir;
1246       out->g = back->ig;
1247       out->b = back->ib;
1248    }
1249
1250    else if (in->a >= 255)
1251    {
1252       out->r = in->r;
1253       out->g = in->g;
1254       out->b = in->b;
1255    }
1256
1257    else
1258    {
1259       double a = in->a / 255.;
1260
1261       out->r = sRGB(sRGB_to_d[in->r] * a + back->dr * (1-a));
1262       out->g = sRGB(sRGB_to_d[in->g] * a + back->dg * (1-a));
1263       out->b = sRGB(sRGB_to_d[in->b] * a + back->db * (1-a));
1264    }
1265
1266    out->a = 255;
1267 }
1268
1269 /* g8: convert sRGB components to sRGB grayscale */
1270 static void
1271 gpc_g8(Pixel *out, const Pixel *in, const Background *back)
1272 {
1273    (void)back;
1274
1275    if (in->r == in->g && in->g == in->b)
1276       out->r = out->g = out->b = in->g;
1277
1278    else
1279       out->r = out->g = out->b =
1280          sRGB(YfromRGB(sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b]));
1281
1282    out->a = in->a;
1283 }
1284
1285 /* g8b: convert sRGB components to grayscale and composite on gray background */
1286 static void
1287 gpc_g8b(Pixel *out, const Pixel *in, const Background *back)
1288 {
1289    if (in->a <= 0)
1290       out->r = out->g = out->b = back->ig;
1291
1292    else if (in->a >= 255)
1293    {
1294       if (in->r == in->g && in->g == in->b)
1295          out->r = out->g = out->b = in->g;
1296
1297       else
1298          out->r = out->g = out->b = sRGB(YfromRGB(
1299             sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b]));
1300    }
1301
1302    else
1303    {
1304       double a = in->a/255.;
1305
1306       out->r = out->g = out->b = sRGB(a * YfromRGB(sRGB_to_d[in->r],
1307          sRGB_to_d[in->g], sRGB_to_d[in->b]) + back->dg * (1-a));
1308    }
1309
1310    out->a = 255;
1311 }
1312
1313 /* 8-bit to 16-bit conversions */
1314 /* lin: make sRGB components linear, alpha := 65535 */
1315 static void
1316 gpc_lin(Pixel *out, const Pixel *in, const Background *back)
1317 {
1318    (void)back;
1319
1320    out->r = ilinear(in->r);
1321
1322    if (in->g == in->r)
1323    {
1324       out->g = out->r;
1325
1326       if (in->b == in->r)
1327          out->b = out->r;
1328
1329       else
1330          out->b = ilinear(in->b);
1331    }
1332
1333    else
1334    {
1335       out->g = ilinear(in->g);
1336
1337       if (in->b == in->r)
1338          out->b = out->r;
1339
1340       else if (in->b == in->g)
1341          out->b = out->g;
1342
1343       else
1344          out->b = ilinear(in->b);
1345    }
1346
1347    out->a = 65535;
1348 }
1349
1350 /* pre: make sRGB components linear and premultiply by alpha (scale alpha) */
1351 static void
1352 gpc_pre(Pixel *out, const Pixel *in, const Background *back)
1353 {
1354    (void)back;
1355
1356    out->r = ilineara(in->r, in->a);
1357
1358    if (in->g == in->r)
1359    {
1360       out->g = out->r;
1361
1362       if (in->b == in->r)
1363          out->b = out->r;
1364
1365       else
1366          out->b = ilineara(in->b, in->a);
1367    }
1368
1369    else
1370    {
1371       out->g = ilineara(in->g, in->a);
1372
1373       if (in->b == in->r)
1374          out->b = out->r;
1375
1376       else if (in->b == in->g)
1377          out->b = out->g;
1378
1379       else
1380          out->b = ilineara(in->b, in->a);
1381    }
1382
1383    out->a = in->a * 257;
1384 }
1385
1386 /* pre': as 'pre' but alpha := 65535 */
1387 static void
1388 gpc_preq(Pixel *out, const Pixel *in, const Background *back)
1389 {
1390    (void)back;
1391
1392    out->r = ilineara(in->r, in->a);
1393
1394    if (in->g == in->r)
1395    {
1396       out->g = out->r;
1397
1398       if (in->b == in->r)
1399          out->b = out->r;
1400
1401       else
1402          out->b = ilineara(in->b, in->a);
1403    }
1404
1405    else
1406    {
1407       out->g = ilineara(in->g, in->a);
1408
1409       if (in->b == in->r)
1410          out->b = out->r;
1411
1412       else if (in->b == in->g)
1413          out->b = out->g;
1414
1415       else
1416          out->b = ilineara(in->b, in->a);
1417    }
1418
1419    out->a = 65535;
1420 }
1421
1422 /* glin: make sRGB components linear, convert to grayscale, alpha := 65535 */
1423 static void
1424 gpc_glin(Pixel *out, const Pixel *in, const Background *back)
1425 {
1426    (void)back;
1427
1428    if (in->r == in->g && in->g == in->b)
1429       out->r = out->g = out->b = ilinear(in->g);
1430
1431    else
1432       out->r = out->g = out->b = u16d(65535 *
1433          YfromRGB(sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b]));
1434
1435    out->a = 65535;
1436 }
1437
1438 /* gpre: make sRGB components grayscale and linear and premultiply by alpha */
1439 static void
1440 gpc_gpre(Pixel *out, const Pixel *in, const Background *back)
1441 {
1442    (void)back;
1443
1444    if (in->r == in->g && in->g == in->b)
1445       out->r = out->g = out->b = ilineara(in->g, in->a);
1446
1447    else
1448       out->r = out->g = out->b = u16d(in->a * 257 *
1449          YfromRGB(sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b]));
1450
1451    out->a = 257 * in->a;
1452 }
1453
1454 /* gpr': as 'gpre' but alpha := 65535 */
1455 static void
1456 gpc_gprq(Pixel *out, const Pixel *in, const Background *back)
1457 {
1458    (void)back;
1459
1460    if (in->r == in->g && in->g == in->b)
1461       out->r = out->g = out->b = ilineara(in->g, in->a);
1462
1463    else
1464       out->r = out->g = out->b = u16d(in->a * 257 *
1465          YfromRGB(sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b]));
1466
1467    out->a = 65535;
1468 }
1469
1470 /* 8-bit to 16-bit conversions for gAMA 45455 encoded values */
1471 /* Lin: make gAMA 45455 components linear, alpha := 65535 */
1472 static void
1473 gpc_Lin(Pixel *out, const Pixel *in, const Background *back)
1474 {
1475    (void)back;
1476
1477    out->r = ilinear_g22(in->r);
1478
1479    if (in->g == in->r)
1480    {
1481       out->g = out->r;
1482
1483       if (in->b == in->r)
1484          out->b = out->r;
1485
1486       else
1487          out->b = ilinear_g22(in->b);
1488    }
1489
1490    else
1491    {
1492       out->g = ilinear_g22(in->g);
1493
1494       if (in->b == in->r)
1495          out->b = out->r;
1496
1497       else if (in->b == in->g)
1498          out->b = out->g;
1499
1500       else
1501          out->b = ilinear_g22(in->b);
1502    }
1503
1504    out->a = 65535;
1505 }
1506
1507 #if ALLOW_UNUSED_GPC
1508 /* Pre: make gAMA 45455 components linear and premultiply by alpha (scale alpha)
1509  */
1510 static void
1511 gpc_Pre(Pixel *out, const Pixel *in, const Background *back)
1512 {
1513    (void)back;
1514
1515    out->r = ilineara_g22(in->r, in->a);
1516
1517    if (in->g == in->r)
1518    {
1519       out->g = out->r;
1520
1521       if (in->b == in->r)
1522          out->b = out->r;
1523
1524       else
1525          out->b = ilineara_g22(in->b, in->a);
1526    }
1527
1528    else
1529    {
1530       out->g = ilineara_g22(in->g, in->a);
1531
1532       if (in->b == in->r)
1533          out->b = out->r;
1534
1535       else if (in->b == in->g)
1536          out->b = out->g;
1537
1538       else
1539          out->b = ilineara_g22(in->b, in->a);
1540    }
1541
1542    out->a = in->a * 257;
1543 }
1544 #endif
1545
1546 #if ALLOW_UNUSED_GPC
1547 /* Pre': as 'Pre' but alpha := 65535 */
1548 static void
1549 gpc_Preq(Pixel *out, const Pixel *in, const Background *back)
1550 {
1551    (void)back;
1552
1553    out->r = ilineara_g22(in->r, in->a);
1554
1555    if (in->g == in->r)
1556    {
1557       out->g = out->r;
1558
1559       if (in->b == in->r)
1560          out->b = out->r;
1561
1562       else
1563          out->b = ilineara_g22(in->b, in->a);
1564    }
1565
1566    else
1567    {
1568       out->g = ilineara_g22(in->g, in->a);
1569
1570       if (in->b == in->r)
1571          out->b = out->r;
1572
1573       else if (in->b == in->g)
1574          out->b = out->g;
1575
1576       else
1577          out->b = ilineara_g22(in->b, in->a);
1578    }
1579
1580    out->a = 65535;
1581 }
1582 #endif
1583
1584 #if ALLOW_UNUSED_GPC
1585 /* Glin: make gAMA 45455 components linear, convert to grayscale, alpha := 65535
1586  */
1587 static void
1588 gpc_Glin(Pixel *out, const Pixel *in, const Background *back)
1589 {
1590    (void)back;
1591
1592    if (in->r == in->g && in->g == in->b)
1593       out->r = out->g = out->b = ilinear_g22(in->g);
1594
1595    else
1596       out->r = out->g = out->b = u16d(65535 *
1597          YfromRGB(g22_to_d[in->r], g22_to_d[in->g], g22_to_d[in->b]));
1598
1599    out->a = 65535;
1600 }
1601 #endif
1602
1603 #if ALLOW_UNUSED_GPC
1604 /* Gpre: make gAMA 45455 components grayscale and linear and premultiply by
1605  * alpha.
1606  */
1607 static void
1608 gpc_Gpre(Pixel *out, const Pixel *in, const Background *back)
1609 {
1610    (void)back;
1611
1612    if (in->r == in->g && in->g == in->b)
1613       out->r = out->g = out->b = ilineara_g22(in->g, in->a);
1614
1615    else
1616       out->r = out->g = out->b = u16d(in->a * 257 *
1617          YfromRGB(g22_to_d[in->r], g22_to_d[in->g], g22_to_d[in->b]));
1618
1619    out->a = 257 * in->a;
1620 }
1621 #endif
1622
1623 #if ALLOW_UNUSED_GPC
1624 /* Gpr': as 'Gpre' but alpha := 65535 */
1625 static void
1626 gpc_Gprq(Pixel *out, const Pixel *in, const Background *back)
1627 {
1628    (void)back;
1629
1630    if (in->r == in->g && in->g == in->b)
1631       out->r = out->g = out->b = ilineara_g22(in->g, in->a);
1632
1633    else
1634       out->r = out->g = out->b = u16d(in->a * 257 *
1635          YfromRGB(g22_to_d[in->r], g22_to_d[in->g], g22_to_d[in->b]));
1636
1637    out->a = 65535;
1638 }
1639 #endif
1640
1641 /* 16-bit to 8-bit conversions */
1642 /* sRGB: convert linear components to sRGB, alpha := 255 */
1643 static void
1644 gpc_sRGB(Pixel *out, const Pixel *in, const Background *back)
1645 {
1646    (void)back;
1647
1648    out->r = isRGB(in->r);
1649
1650    if (in->g == in->r)
1651    {
1652       out->g = out->r;
1653
1654       if (in->b == in->r)
1655          out->b = out->r;
1656
1657       else
1658          out->b = isRGB(in->b);
1659    }
1660
1661    else
1662    {
1663       out->g = isRGB(in->g);
1664
1665       if (in->b == in->r)
1666          out->b = out->r;
1667
1668       else if (in->b == in->g)
1669          out->b = out->g;
1670
1671       else
1672          out->b = isRGB(in->b);
1673    }
1674
1675    out->a = 255;
1676 }
1677
1678 /* unpg: unpremultiply gray component and convert to sRGB (scale alpha) */
1679 static void
1680 gpc_unpg(Pixel *out, const Pixel *in, const Background *back)
1681 {
1682    (void)back;
1683
1684    if (in->a <= 128)
1685    {
1686       out->r = out->g = out->b = 255;
1687       out->a = 0;
1688    }
1689
1690    else
1691    {
1692       out->r = out->g = out->b = sRGB((double)in->g / in->a);
1693       out->a = u8d(in->a / 257.);
1694    }
1695 }
1696
1697 /* unpc: unpremultiply color components and convert to sRGB (scale alpha) */
1698 static void
1699 gpc_unpc(Pixel *out, const Pixel *in, const Background *back)
1700 {
1701    (void)back;
1702
1703    if (in->a <= 128)
1704    {
1705       out->r = out->g = out->b = 255;
1706       out->a = 0;
1707    }
1708
1709    else
1710    {
1711       out->r = sRGB((double)in->r / in->a);
1712       out->g = sRGB((double)in->g / in->a);
1713       out->b = sRGB((double)in->b / in->a);
1714       out->a = u8d(in->a / 257.);
1715    }
1716 }
1717
1718 /* b16g: composite linear onto gray background and convert the result to sRGB */
1719 static void
1720 gpc_b16g(Pixel *out, const Pixel *in, const Background *back)
1721 {
1722    if (in->a <= 0)
1723       out->r = out->g = out->b = back->ig;
1724
1725    else
1726    {
1727       double a = in->a/65535.;
1728       double a1 = 1-a;
1729
1730       a /= 65535;
1731       out->r = out->g = out->b = sRGB(in->g * a + back->dg * a1);
1732    }
1733
1734    out->a = 255;
1735 }
1736
1737 /* b16c: composite linear onto color background and convert the result to sRGB*/
1738 static void
1739 gpc_b16c(Pixel *out, const Pixel *in, const Background *back)
1740 {
1741    if (in->a <= 0)
1742    {
1743       out->r = back->ir;
1744       out->g = back->ig;
1745       out->b = back->ib;
1746    }
1747
1748    else
1749    {
1750       double a = in->a/65535.;
1751       double a1 = 1-a;
1752
1753       a /= 65535;
1754       out->r = sRGB(in->r * a + back->dr * a1);
1755       out->g = sRGB(in->g * a + back->dg * a1);
1756       out->b = sRGB(in->b * a + back->db * a1);
1757    }
1758
1759    out->a = 255;
1760 }
1761
1762 /* sG: convert linear RGB to sRGB grayscale */
1763 static void
1764 gpc_sG(Pixel *out, const Pixel *in, const Background *back)
1765 {
1766    (void)back;
1767
1768    out->r = out->g = out->b = sRGB(YfromRGBint(in->r, in->g, in->b)/65535);
1769    out->a = 255;
1770 }
1771
1772 /* sGp: unpremultiply RGB then convert to sRGB grayscale */
1773 static void
1774 gpc_sGp(Pixel *out, const Pixel *in, const Background *back)
1775 {
1776    (void)back;
1777
1778    if (in->a <= 128)
1779    {
1780       out->r = out->g = out->b = 255;
1781       out->a = 0;
1782    }
1783
1784    else
1785    {
1786       out->r = out->g = out->b = sRGB(YfromRGBint(in->r, in->g, in->b)/in->a);
1787       out->a = u8d(in->a / 257.);
1788    }
1789 }
1790
1791 /* sCp: unpremultiply RGB then convert to sRGB */
1792 static void
1793 gpc_sCp(Pixel *out, const Pixel *in, const Background *back)
1794 {
1795    (void)back;
1796
1797    if (in->a <= 128)
1798    {
1799       out->r = out->g = out->b = 255;
1800       out->a = 0;
1801    }
1802
1803    else
1804    {
1805       out->r = sRGB((double)in->r / in->a);
1806       out->g = sRGB((double)in->g / in->a);
1807       out->b = sRGB((double)in->b / in->a);
1808       out->a = u8d(in->a / 257.);
1809    }
1810 }
1811
1812 /* gb16: composite linear onto background and convert to sRGB grayscale */
1813 /*  (order doesn't matter, the composite and grayscale operations permute) */
1814 static void
1815 gpc_gb16(Pixel *out, const Pixel *in, const Background *back)
1816 {
1817    if (in->a <= 0)
1818       out->r = out->g = out->b = back->ig;
1819
1820    else if (in->a >= 65535)
1821       out->r = out->g = out->b = isRGB(in->g);
1822
1823    else
1824    {
1825       double a = in->a / 65535.;
1826       double a1 = 1-a;
1827
1828       a /= 65535;
1829       out->r = out->g = out->b = sRGB(in->g * a + back->dg * a1);
1830    }
1831
1832    out->a = 255;
1833 }
1834
1835 /* cb16: composite linear onto background and convert to sRGB */
1836 static void
1837 gpc_cb16(Pixel *out, const Pixel *in, const Background *back)
1838 {
1839    if (in->a <= 0)
1840    {
1841       out->r = back->ir;
1842       out->g = back->ig;
1843       out->b = back->ib;
1844    }
1845
1846    else if (in->a >= 65535)
1847    {
1848       out->r = isRGB(in->r);
1849       out->g = isRGB(in->g);
1850       out->b = isRGB(in->b);
1851    }
1852
1853    else
1854    {
1855       double a = in->a / 65535.;
1856       double a1 = 1-a;
1857
1858       a /= 65535;
1859       out->r = sRGB(in->r * a + back->dr * a1);
1860       out->g = sRGB(in->g * a + back->dg * a1);
1861       out->b = sRGB(in->b * a + back->db * a1);
1862    }
1863
1864    out->a = 255;
1865 }
1866
1867 /* 16-bit to 16-bit conversions */
1868 /* A:    set alpha to 65535 */
1869 static void
1870 gpc_A(Pixel *out, const Pixel *in, const Background *back)
1871 {
1872    (void)back;
1873    out->r = in->r;
1874    out->g = in->g;
1875    out->b = in->b;
1876    out->a = 65535;
1877 }
1878
1879 /* g16:  convert linear RGB to linear grayscale (alpha := 65535) */
1880 static void
1881 gpc_g16(Pixel *out, const Pixel *in, const Background *back)
1882 {
1883    (void)back;
1884    out->r = out->g = out->b = u16d(YfromRGBint(in->r, in->g, in->b));
1885    out->a = 65535;
1886 }
1887
1888 /* g16': as 'g16' but alpha is unchanged */
1889 static void
1890 gpc_g16q(Pixel *out, const Pixel *in, const Background *back)
1891 {
1892    (void)back;
1893    out->r = out->g = out->b = u16d(YfromRGBint(in->r, in->g, in->b));
1894    out->a = in->a;
1895 }
1896
1897 #if ALLOW_UNUSED_GPC
1898 /* Unused functions (to hide them from GCC unused function warnings) */
1899 void (* const gpc_unused[])
1900    (Pixel *out, const Pixel *in, const Background *back) =
1901 {
1902    gpc_Pre, gpc_Preq, gpc_Glin, gpc_Gpre, gpc_Gprq, gpc_nop8, gpc_nop6
1903 };
1904 #endif
1905
1906 /*   OUT:    ----- 8-bit -----    ----- 16-bit -----
1907  *   IN     G    GA   RGB  RGBA  G    GA   RGB  RGBA
1908  *  8 G     .    .    .    .     lin  lin  lin  lin
1909  *  8 GA    bckg .    bckc .     pre' pre  pre' pre
1910  *  8 RGB   g8   g8   .    .     glin glin lin  lin
1911  *  8 RGBA  g8b  g8   bckc .     gpr' gpre pre' pre
1912  * 16 G     sRGB sRGB sRGB sRGB  .    .    .    .
1913  * 16 GA    b16g unpg b16c unpc  A    .    A    .
1914  * 16 RGB   sG   sG   sRGB sRGB  g16  g16  .    .
1915  * 16 RGBA  gb16 sGp  cb16 sCp   g16  g16' A    .
1916  *
1917  * The matrix is held in an array indexed thus:
1918  *
1919  *   gpc_fn[out_format & BASE_FORMATS][in_format & BASE_FORMATS];
1920  */
1921 /* This will produce a compile time error if the FORMAT_FLAG values don't
1922  * match the above matrix!
1923  */
1924 #if PNG_FORMAT_FLAG_ALPHA == 1 && PNG_FORMAT_FLAG_COLOR == 2 &&\
1925    PNG_FORMAT_FLAG_LINEAR == 4
1926 static void (* const gpc_fn[8/*in*/][8/*out*/])
1927    (Pixel *out, const Pixel *in, const Background *back) =
1928 {
1929 /*out: G-8     GA-8     RGB-8    RGBA-8    G-16     GA-16   RGB-16  RGBA-16 */
1930    {gpc_noop,gpc_noop,gpc_noop,gpc_noop, gpc_Lin, gpc_Lin, gpc_Lin, gpc_Lin },
1931    {gpc_bckg,gpc_noop,gpc_bckc,gpc_noop, gpc_preq,gpc_pre, gpc_preq,gpc_pre },
1932    {gpc_g8,  gpc_g8,  gpc_noop,gpc_noop, gpc_glin,gpc_glin,gpc_lin, gpc_lin },
1933    {gpc_g8b, gpc_g8,  gpc_bckc,gpc_noop, gpc_gprq,gpc_gpre,gpc_preq,gpc_pre },
1934    {gpc_sRGB,gpc_sRGB,gpc_sRGB,gpc_sRGB, gpc_noop,gpc_noop,gpc_noop,gpc_noop},
1935    {gpc_b16g,gpc_unpg,gpc_b16c,gpc_unpc, gpc_A,   gpc_noop,gpc_A,   gpc_noop},
1936    {gpc_sG,  gpc_sG,  gpc_sRGB,gpc_sRGB, gpc_g16, gpc_g16, gpc_noop,gpc_noop},
1937    {gpc_gb16,gpc_sGp, gpc_cb16,gpc_sCp,  gpc_g16, gpc_g16q,gpc_A,   gpc_noop}
1938 };
1939
1940 /* The array is repeated for the cases where both the input and output are color
1941  * mapped because then different algorithms are used.
1942  */
1943 static void (* const gpc_fn_colormapped[8/*in*/][8/*out*/])
1944    (Pixel *out, const Pixel *in, const Background *back) =
1945 {
1946 /*out: G-8     GA-8     RGB-8    RGBA-8    G-16     GA-16   RGB-16  RGBA-16 */
1947    {gpc_noop,gpc_noop,gpc_noop,gpc_noop, gpc_lin, gpc_lin, gpc_lin, gpc_lin },
1948    {gpc_bckg,gpc_noop,gpc_bckc,gpc_noop, gpc_preq,gpc_pre, gpc_preq,gpc_pre },
1949    {gpc_g8,  gpc_g8,  gpc_noop,gpc_noop, gpc_glin,gpc_glin,gpc_lin, gpc_lin },
1950    {gpc_g8b, gpc_g8,  gpc_bckc,gpc_noop, gpc_gprq,gpc_gpre,gpc_preq,gpc_pre },
1951    {gpc_sRGB,gpc_sRGB,gpc_sRGB,gpc_sRGB, gpc_noop,gpc_noop,gpc_noop,gpc_noop},
1952    {gpc_b16g,gpc_unpg,gpc_b16c,gpc_unpc, gpc_A,   gpc_noop,gpc_A,   gpc_noop},
1953    {gpc_sG,  gpc_sG,  gpc_sRGB,gpc_sRGB, gpc_g16, gpc_g16, gpc_noop,gpc_noop},
1954    {gpc_gb16,gpc_sGp, gpc_cb16,gpc_sCp,  gpc_g16, gpc_g16q,gpc_A,   gpc_noop}
1955 };
1956
1957 /* The error arrays record the error in the same matrix; 64 entries, however
1958  * the different algorithms used in libpng for colormap and direct conversions
1959  * mean that four separate matrices are used (for each combination of
1960  * colormapped and direct.)
1961  *
1962  * In some cases the conversion between sRGB formats goes via a linear
1963  * intermediate; an sRGB to linear conversion (as above) is followed by a simple
1964  * linear to sRGB step with no other conversions.  This is done by a separate
1965  * error array from an arbitrary 'in' format to one of the four basic outputs
1966  * (since final output is always sRGB not colormapped).
1967  *
1968  * These arrays may be modified if the --accumulate flag is set during the run;
1969  * then instead of logging errors they are simply added in.
1970  *
1971  * The three entries are currently for transparent, partially transparent and
1972  * opaque input pixel values.  Notice that alpha should be exact in each case.
1973  *
1974  * Errors in alpha should only occur when converting from a direct format
1975  * to a colormapped format, when alpha is effectively smashed (so large
1976  * errors can occur.)  There should be no error in the '0' and 'opaque'
1977  * values.  The fourth entry in the array is used for the alpha error (and it
1978  * should always be zero for the 'via linear' case since this is never color
1979  * mapped.)
1980  *
1981  * Mapping to a colormap smashes the colors, it is necessary to have separate
1982  * values for these cases because they are much larger; it is very much
1983  * impossible to obtain a reasonable result, these are held in
1984  * gpc_error_to_colormap.
1985  */
1986 #if PNG_FORMAT_FLAG_COLORMAP == 8 /* extra check also required */
1987 /* START MACHINE GENERATED */
1988 static png_uint_16 gpc_error[16/*in*/][16/*out*/][4/*a*/] =
1989 {
1990  { /* input: sRGB-gray */
1991   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
1992   { 0, 0, 372, 0 }, { 0, 0, 372, 0 }, { 0, 0, 372, 0 }, { 0, 0, 372, 0 },
1993   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
1994   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
1995  }, { /* input: sRGB-gray+alpha */
1996   { 0, 18, 0, 0 }, { 0, 0, 0, 0 }, { 0, 20, 0, 0 }, { 0, 0, 0, 0 },
1997   { 0, 897, 788, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 },
1998   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
1999   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2000  }, { /* input: sRGB-rgb */
2001   { 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2002   { 0, 0, 893, 0 }, { 0, 0, 893, 0 }, { 0, 0, 811, 0 }, { 0, 0, 811, 0 },
2003   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2004   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2005  }, { /* input: sRGB-rgb+alpha */
2006   { 0, 4, 13, 0 }, { 0, 14, 13, 0 }, { 0, 19, 0, 0 }, { 0, 0, 0, 0 },
2007   { 0, 832, 764, 0 }, { 0, 832, 764, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 },
2008   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2009   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2010  }, { /* input: linear-gray */
2011   { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
2012   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2013   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2014   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2015  }, { /* input: linear-gray+alpha */
2016   { 0, 74, 9, 0 }, { 0, 20, 9, 0 }, { 0, 74, 9, 0 }, { 0, 20, 9, 0 },
2017   { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 }, { 0, 1, 0, 0 },
2018   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2019   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2020  }, { /* input: linear-rgb */
2021   { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
2022   { 0, 0, 4, 0 }, { 0, 0, 4, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2023   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2024   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2025  }, { /* input: linear-rgb+alpha */
2026   { 0, 126, 143, 0 }, { 0, 9, 7, 0 }, { 0, 74, 9, 0 }, { 0, 16, 9, 0 },
2027   { 0, 4, 4, 0 }, { 0, 5, 4, 0 }, { 0, 0, 0, 0 }, { 0, 1, 0, 0 },
2028   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2029   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2030  }, { /* input: color-mapped-sRGB-gray */
2031   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2032   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2033   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2034   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2035  }, { /* input: color-mapped-sRGB-gray+alpha */
2036   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2037   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2038   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2039   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2040  }, { /* input: color-mapped-sRGB-rgb */
2041   { 0, 0, 13, 0 }, { 0, 0, 13, 0 }, { 0, 0, 8, 0 }, { 0, 0, 8, 0 },
2042   { 0, 0, 673, 0 }, { 0, 0, 673, 0 }, { 0, 0, 674, 0 }, { 0, 0, 674, 0 },
2043   { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2044   { 0, 0, 460, 0 }, { 0, 0, 460, 0 }, { 0, 0, 263, 0 }, { 0, 0, 263, 0 }
2045  }, { /* input: color-mapped-sRGB-rgb+alpha */
2046   { 0, 6, 8, 0 }, { 0, 7, 8, 0 }, { 0, 75, 8, 0 }, { 0, 9, 8, 0 },
2047   { 0, 585, 427, 0 }, { 0, 585, 427, 0 }, { 0, 717, 409, 0 }, { 0, 717, 409, 0 },
2048   { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 },
2049   { 0, 13323, 460, 0 }, { 0, 334, 460, 0 }, { 0, 16480, 263, 0 }, { 0, 243, 263, 0 }
2050  }, { /* input: color-mapped-linear-gray */
2051   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2052   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2053   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2054   { 0, 0, 282, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2055  }, { /* input: color-mapped-linear-gray+alpha */
2056   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2057   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2058   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2059   { 0, 0, 0, 0 }, { 0, 253, 282, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2060  }, { /* input: color-mapped-linear-rgb */
2061   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2062   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2063   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2064   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 265, 0 }, { 0, 0, 0, 0 }
2065  }, { /* input: color-mapped-linear-rgb+alpha */
2066   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2067   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2068   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
2069   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 243, 265, 0 }
2070  }
2071 };
2072 static png_uint_16 gpc_error_via_linear[16][4/*out*/][4] =
2073 {
2074  { /* input: sRGB-gray */
2075   { 0, 0, 7, 0 }, { 0, 0, 7, 0 }, { 0, 0, 7, 0 }, { 0, 0, 7, 0 }
2076  }, { /* input: sRGB-gray+alpha */
2077   { 0, 15, 15, 0 }, { 0, 186, 15, 0 }, { 0, 15, 15, 0 }, { 0, 186, 15, 0 }
2078  }, { /* input: sRGB-rgb */
2079   { 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 15, 0 }, { 0, 0, 15, 0 }
2080  }, { /* input: sRGB-rgb+alpha */
2081   { 0, 12, 14, 0 }, { 0, 180, 14, 0 }, { 0, 14, 15, 0 }, { 0, 186, 15, 0 }
2082  }, { /* input: linear-gray */
2083   { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }
2084  }, { /* input: linear-gray+alpha */
2085   { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }
2086  }, { /* input: linear-rgb */
2087   { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }
2088  }, { /* input: linear-rgb+alpha */
2089   { 0, 1, 1, 0 }, { 0, 8, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }
2090  }, { /* input: color-mapped-sRGB-gray */
2091   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2092  }, { /* input: color-mapped-sRGB-gray+alpha */
2093   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2094  }, { /* input: color-mapped-sRGB-rgb */
2095   { 0, 0, 13, 0 }, { 0, 0, 13, 0 }, { 0, 0, 14, 0 }, { 0, 0, 14, 0 }
2096  }, { /* input: color-mapped-sRGB-rgb+alpha */
2097   { 0, 4, 8, 0 }, { 0, 9, 8, 0 }, { 0, 8, 3, 0 }, { 0, 32, 3, 0 }
2098  }, { /* input: color-mapped-linear-gray */
2099   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2100  }, { /* input: color-mapped-linear-gray+alpha */
2101   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2102  }, { /* input: color-mapped-linear-rgb */
2103   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2104  }, { /* input: color-mapped-linear-rgb+alpha */
2105   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
2106  }
2107 };
2108 static png_uint_16 gpc_error_to_colormap[8/*i*/][8/*o*/][4] =
2109 {
2110  { /* input: sRGB-gray */
2111   { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
2112   { 0, 0, 560, 0 }, { 0, 0, 560, 0 }, { 0, 0, 560, 0 }, { 0, 0, 560, 0 }
2113  }, { /* input: sRGB-gray+alpha */
2114   { 0, 19, 2, 0 }, { 0, 255, 2, 25 }, { 0, 88, 2, 0 }, { 0, 255, 2, 25 },
2115   { 0, 1012, 745, 0 }, { 0, 16026, 745, 6425 }, { 0, 1012, 745, 0 }, { 0, 16026, 745, 6425 }
2116  }, { /* input: sRGB-rgb */
2117   { 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 25, 0 }, { 0, 0, 25, 0 },
2118   { 0, 0, 937, 0 }, { 0, 0, 937, 0 }, { 0, 0, 13677, 0 }, { 0, 0, 13677, 0 }
2119  }, { /* input: sRGB-rgb+alpha */
2120   { 0, 63, 77, 0 }, { 0, 255, 19, 25 }, { 0, 220, 25, 0 }, { 0, 255, 25, 67 },
2121   { 0, 17534, 18491, 0 }, { 0, 15614, 2824, 6425 }, { 0, 14019, 13677, 0 }, { 0, 48573, 13677, 17219 }
2122  }, { /* input: linear-gray */
2123   { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 73, 0 },
2124   { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }
2125  }, { /* input: linear-gray+alpha */
2126   { 0, 74, 74, 0 }, { 0, 255, 74, 25 }, { 0, 97, 74, 0 }, { 0, 255, 74, 25 },
2127   { 0, 18919, 18907, 0 }, { 0, 24549, 18907, 6552 }, { 0, 18919, 18907, 0 }, { 0, 24549, 18907, 6552 }
2128  }, { /* input: linear-rgb */
2129   { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 98, 0 }, { 0, 0, 98, 0 },
2130   { 0, 0, 18664, 0 }, { 0, 0, 18664, 0 }, { 0, 0, 24998, 0 }, { 0, 0, 24998, 0 }
2131  }, { /* input: linear-rgb+alpha */
2132   { 0, 181, 196, 0 }, { 0, 255, 61, 25 }, { 206, 187, 98, 0 }, { 0, 255, 98, 67 },
2133   { 0, 18141, 18137, 0 }, { 0, 17494, 17504, 6553 }, { 0, 24979, 24992, 0 }, { 0, 46509, 24992, 17347 }
2134  }
2135 };
2136 /* END MACHINE GENERATED */
2137 #endif /* COLORMAP flag check */
2138 #endif /* flag checks */
2139
2140 typedef struct
2141 {
2142    /* Basic pixel information: */
2143    Image*       in_image;   /* Input image */
2144    const Image* out_image;  /* Output image */
2145
2146    /* 'background' is the value passed to the gpc_ routines, it may be NULL if
2147     * it should not be used (*this* program has an error if it crashes as a
2148     * result!)
2149     */
2150    Background        background_color;
2151    const Background* background;
2152
2153    /* Precalculated values: */
2154    int          in_opaque;   /* Value of input alpha that is opaque */
2155    int          is_palette;  /* Sample values come from the palette */
2156    int          accumulate;  /* Accumlate component errors (don't log) */
2157    int          output_8bit; /* Output is 8 bit (else 16 bit) */
2158
2159    void (*in_gp)(Pixel*, png_const_voidp);
2160    void (*out_gp)(Pixel*, png_const_voidp);
2161
2162    void (*transform)(Pixel *out, const Pixel *in, const Background *back);
2163       /* A function to perform the required transform */
2164
2165    void (*from_linear)(Pixel *out, const Pixel *in, const Background *back);
2166       /* For 'via_linear' transforms the final, from linear, step, else NULL */
2167
2168    png_uint_16 error[4];
2169       /* Three error values for transparent, partially transparent and opaque
2170        * input pixels (in turn).
2171        */
2172
2173    png_uint_16 *error_ptr;
2174       /* Where these are stored in the static array (for 'accumulate') */
2175 }
2176 Transform;
2177
2178 /* Return a 'transform' as above for the given format conversion. */
2179 static void
2180 transform_from_formats(Transform *result, Image *in_image,
2181    const Image *out_image, png_const_colorp background, int via_linear)
2182 {
2183    png_uint_32 in_format, out_format;
2184    png_uint_32 in_base, out_base;
2185
2186    memset(result, 0, sizeof *result);
2187
2188    /* Store the original images for error messages */
2189    result->in_image = in_image;
2190    result->out_image = out_image;
2191
2192    in_format = in_image->image.format;
2193    out_format = out_image->image.format;
2194
2195    if (in_format & PNG_FORMAT_FLAG_LINEAR)
2196       result->in_opaque = 65535;
2197    else
2198       result->in_opaque = 255;
2199
2200    result->output_8bit = (out_format & PNG_FORMAT_FLAG_LINEAR) == 0;
2201
2202    result->is_palette = 0; /* set by caller if required */
2203    result->accumulate = (in_image->opts & ACCUMULATE) != 0;
2204
2205    /* The loaders (which need the ordering information) */
2206    result->in_gp = get_pixel(in_format);
2207    result->out_gp = get_pixel(out_format);
2208
2209    /* Remove the ordering information: */
2210    in_format &= BASE_FORMATS | PNG_FORMAT_FLAG_COLORMAP;
2211    in_base = in_format & BASE_FORMATS;
2212    out_format &= BASE_FORMATS | PNG_FORMAT_FLAG_COLORMAP;
2213    out_base = out_format & BASE_FORMATS;
2214
2215    if (via_linear)
2216    {
2217       /* Check for an error in this program: */
2218       if (out_format & (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLORMAP))
2219       {
2220          fprintf(stderr, "internal transform via linear error 0x%x->0x%x\n",
2221             in_format, out_format);
2222          exit(1);
2223       }
2224
2225       result->transform = gpc_fn[in_base][out_base | PNG_FORMAT_FLAG_LINEAR];
2226       result->from_linear = gpc_fn[out_base | PNG_FORMAT_FLAG_LINEAR][out_base];
2227       result->error_ptr = gpc_error_via_linear[in_format][out_format];
2228    }
2229
2230    else if (~in_format & out_format & PNG_FORMAT_FLAG_COLORMAP)
2231    {
2232       /* The input is not colormapped but the output is, the errors will
2233        * typically be large (only the grayscale-no-alpha case permits preserving
2234        * even 8-bit values.)
2235        */
2236       result->transform = gpc_fn[in_base][out_base];
2237       result->from_linear = NULL;
2238       result->error_ptr = gpc_error_to_colormap[in_base][out_base];
2239    }
2240
2241    else
2242    {
2243       /* The caller handles the colormap->pixel value conversion, so the
2244        * transform function just gets a pixel value, however because libpng
2245        * currently contains a different implementation for mapping a colormap if
2246        * both input and output are colormapped we need different conversion
2247        * functions to deal with errors in the libpng implementation.
2248        */
2249       if (in_format & out_format & PNG_FORMAT_FLAG_COLORMAP)
2250          result->transform = gpc_fn_colormapped[in_base][out_base];
2251       else
2252          result->transform = gpc_fn[in_base][out_base];
2253       result->from_linear = NULL;
2254       result->error_ptr = gpc_error[in_format][out_format];
2255    }
2256
2257    /* Follow the libpng simplified API rules to work out what to pass to the gpc
2258     * routines as a background value, if one is not required pass NULL so that
2259     * this program crashes in the even of a programming error.
2260     */
2261    result->background = NULL; /* default: not required */
2262
2263    /* Rule 1: background only need be supplied if alpha is to be removed */
2264    if (in_format & ~out_format & PNG_FORMAT_FLAG_ALPHA)
2265    {
2266       /* The input value is 'NULL' to use the background and (otherwise) an sRGB
2267        * background color (to use a solid color).  The code above uses a fixed
2268        * byte value, BUFFER_INIT8, for buffer even for 16-bit output.  For
2269        * linear (16-bit) output the sRGB background color is ignored; the
2270        * composition is always on the background (so BUFFER_INIT8 * 257), except
2271        * that for the colormap (i.e. linear colormapped output) black is used.
2272        */
2273       result->background = &result->background_color;
2274
2275       if (out_format & PNG_FORMAT_FLAG_LINEAR || via_linear)
2276       {
2277          if (out_format & PNG_FORMAT_FLAG_COLORMAP)
2278          {
2279             result->background_color.ir =
2280                result->background_color.ig =
2281                result->background_color.ib = 0;
2282             result->background_color.dr =
2283                result->background_color.dg =
2284                result->background_color.db = 0;
2285          }
2286
2287          else
2288          {
2289             result->background_color.ir =
2290                result->background_color.ig =
2291                result->background_color.ib = BUFFER_INIT8 * 257;
2292             result->background_color.dr =
2293                result->background_color.dg =
2294                result->background_color.db = 0;
2295          }
2296       }
2297
2298       else /* sRGB output */
2299       {
2300          if (background != NULL)
2301          {
2302             if (out_format & PNG_FORMAT_FLAG_COLOR)
2303             {
2304                result->background_color.ir = background->red;
2305                result->background_color.ig = background->green;
2306                result->background_color.ib = background->blue;
2307                /* TODO: sometimes libpng uses the power law conversion here, how
2308                 * to handle this?
2309                 */
2310                result->background_color.dr = sRGB_to_d[background->red];
2311                result->background_color.dg = sRGB_to_d[background->green];
2312                result->background_color.db = sRGB_to_d[background->blue];
2313             }
2314
2315             else /* grayscale: libpng only looks at 'g' */
2316             {
2317                result->background_color.ir =
2318                   result->background_color.ig =
2319                   result->background_color.ib = background->green;
2320                /* TODO: sometimes libpng uses the power law conversion here, how
2321                 * to handle this?
2322                 */
2323                result->background_color.dr =
2324                   result->background_color.dg =
2325                   result->background_color.db = sRGB_to_d[background->green];
2326             }
2327          }
2328
2329          else if ((out_format & PNG_FORMAT_FLAG_COLORMAP) == 0)
2330          {
2331             result->background_color.ir =
2332                result->background_color.ig =
2333                result->background_color.ib = BUFFER_INIT8;
2334             /* TODO: sometimes libpng uses the power law conversion here, how
2335              * to handle this?
2336              */
2337             result->background_color.dr =
2338                result->background_color.dg =
2339                result->background_color.db = sRGB_to_d[BUFFER_INIT8];
2340          }
2341
2342          /* Else the output is colormapped and a background color must be
2343           * provided; if pngstest crashes then that is a bug in this program
2344           * (though libpng should png_error as well.)
2345           */
2346          else
2347             result->background = NULL;
2348       }
2349    }
2350
2351    if (result->background == NULL)
2352    {
2353       result->background_color.ir =
2354          result->background_color.ig =
2355          result->background_color.ib = -1; /* not used */
2356       result->background_color.dr =
2357          result->background_color.dg =
2358          result->background_color.db = 1E30; /* not used */
2359    }
2360
2361
2362    /* Copy the error values into the Transform: */
2363    result->error[0] = result->error_ptr[0];
2364    result->error[1] = result->error_ptr[1];
2365    result->error[2] = result->error_ptr[2];
2366    result->error[3] = result->error_ptr[3];
2367 }
2368
2369
2370 /* Compare two pixels.
2371  *
2372  * OLD error values:
2373 static int error_to_linear = 811; * by experiment *
2374 static int error_to_linear_grayscale = 424; * by experiment *
2375 static int error_to_sRGB = 6; * by experiment *
2376 static int error_to_sRGB_grayscale = 17; * libpng error by calculation +
2377                                             2 by experiment *
2378 static int error_in_compose = 2; * by experiment *
2379 static int error_in_premultiply = 1;
2380  *
2381  * The following is *just* the result of a round trip from 8-bit sRGB to linear
2382  * then back to 8-bit sRGB when it is done by libpng.  There are two problems:
2383  *
2384  * 1) libpng currently uses a 2.2 power law with no linear segment, this results
2385  * in instability in the low values and even with 16-bit precision sRGB(1) ends
2386  * up mapping to sRGB(0) as a result of rounding in the 16-bit representation.
2387  * This gives an error of 1 in the handling of value 1 only.
2388  *
2389  * 2) libpng currently uses an intermediate 8-bit linear value in gamma
2390  * correction of 8-bit values.  This results in many more errors, the worse of
2391  * which is mapping sRGB(14) to sRGB(0).
2392  *
2393  * The general 'error_via_linear' is more complex because of pre-multiplication,
2394  * this compounds the 8-bit errors according to the alpha value of the pixel.
2395  * As a result 256 values are pre-calculated for error_via_linear.
2396  */
2397 #if 0
2398 static int error_in_libpng_gamma;
2399 static int error_via_linear[256]; /* Indexed by 8-bit alpha */
2400
2401 static void
2402 init_error_via_linear(void)
2403 {
2404    int alpha;
2405
2406    error_via_linear[0] = 255; /* transparent pixel */
2407
2408    for (alpha=1; alpha<=255; ++alpha)
2409    {
2410       /* 16-bit values less than 128.5 get rounded to 8-bit 0 and so the worst
2411        * case error arises with 16-bit 128.5, work out what sRGB
2412        * (non-associated) value generates 128.5; any value less than this is
2413        * going to map to 0, so the worst error is floor(value).
2414        *
2415        * Note that errors are considerably higher (more than a factor of 2)
2416        * because libpng uses a simple power law for sRGB data at present.
2417        *
2418        * Add .1 for arithmetic errors inside libpng.
2419        */
2420       double v = floor(255*pow(.5/*(128.5 * 255 / 65535)*/ / alpha, 1/2.2)+.1);
2421
2422       error_via_linear[alpha] = (int)v;
2423    }
2424
2425    /* This is actually 14.99, but, despite the closeness to 15, 14 seems to work
2426     * ok in this case.
2427     */
2428    error_in_libpng_gamma = 14;
2429 }
2430 #endif
2431
2432 static void
2433 print_pixel(char string[64], const Pixel *pixel, png_uint_32 format)
2434 {
2435    switch (format & (PNG_FORMAT_FLAG_ALPHA|PNG_FORMAT_FLAG_COLOR))
2436    {
2437       case 0:
2438          sprintf(string, "%s(%d)", format_names[format], pixel->g);
2439          break;
2440
2441       case PNG_FORMAT_FLAG_ALPHA:
2442          sprintf(string, "%s(%d,%d)", format_names[format], pixel->g,
2443             pixel->a);
2444          break;
2445
2446       case PNG_FORMAT_FLAG_COLOR:
2447          sprintf(string, "%s(%d,%d,%d)", format_names[format],
2448             pixel->r, pixel->g, pixel->b);
2449          break;
2450
2451       case PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA:
2452          sprintf(string, "%s(%d,%d,%d,%d)", format_names[format],
2453             pixel->r, pixel->g, pixel->b, pixel->a);
2454          break;
2455
2456       default:
2457          sprintf(string, "invalid-format");
2458          break;
2459    }
2460 }
2461
2462 static int
2463 logpixel(const Transform *transform, png_uint_32 x, png_uint_32 y,
2464    const Pixel *in, const Pixel *calc, const Pixel *out, const char *reason)
2465 {
2466    const png_uint_32 in_format = transform->in_image->image.format;
2467    const png_uint_32 out_format = transform->out_image->image.format;
2468
2469    png_uint_32 back_format = out_format & ~PNG_FORMAT_FLAG_ALPHA;
2470    const char *via_linear = "";
2471
2472    char pixel_in[64], pixel_calc[64], pixel_out[64], pixel_loc[64];
2473    char background_info[100];
2474
2475    print_pixel(pixel_in, in, in_format);
2476    print_pixel(pixel_calc, calc, out_format);
2477    print_pixel(pixel_out, out, out_format);
2478
2479    if (transform->is_palette)
2480       sprintf(pixel_loc, "palette: %lu", (unsigned long)y);
2481    else
2482       sprintf(pixel_loc, "%lu,%lu", (unsigned long)x, (unsigned long)y);
2483
2484    if (transform->from_linear != NULL)
2485    {
2486       via_linear = " (via linear)";
2487       /* And as a result the *read* format which did any background processing
2488        * was itself linear, so the background color information is also
2489        * linear.
2490        */
2491       back_format |= PNG_FORMAT_FLAG_LINEAR;
2492    }
2493
2494    if (transform->background != NULL)
2495    {
2496       Pixel back;
2497       char pixel_back[64];
2498
2499       back.r = transform->background->ir;
2500       back.g = transform->background->ig;
2501       back.b = transform->background->ib;
2502       back.a = -1; /* not used */
2503
2504       print_pixel(pixel_back, &back, back_format);
2505       sprintf(background_info, " on background %s", pixel_back);
2506    }
2507
2508    else
2509       background_info[0] = 0;
2510
2511    if (transform->in_image->file_name != transform->out_image->file_name)
2512    {
2513       char error_buffer[512];
2514       sprintf(error_buffer,
2515          "(%s) %s error%s:\n %s%s ->\n       %s\n  not: %s.\n"
2516          "Use --preserve and examine: ", pixel_loc, reason, via_linear,
2517          pixel_in, background_info, pixel_out, pixel_calc);
2518       return logerror(transform->in_image, transform->in_image->file_name,
2519          error_buffer, transform->out_image->file_name);
2520    }
2521
2522    else
2523    {
2524       char error_buffer[512];
2525       sprintf(error_buffer,
2526          "(%s) %s error%s:\n %s%s ->\n       %s\n  not: %s.\n"
2527          " The error happened when reading the original file with this format.",
2528          pixel_loc, reason, via_linear, pixel_in, background_info, pixel_out,
2529          pixel_calc);
2530       return logerror(transform->in_image, transform->in_image->file_name,
2531          error_buffer, "");
2532    }
2533 }
2534
2535 static int
2536 cmppixel(Transform *transform, png_const_voidp in, png_const_voidp out,
2537    png_uint_32 x, png_uint_32 y/*or palette index*/)
2538 {
2539    int maxerr;
2540    png_const_charp errmsg;
2541    Pixel pixel_in, pixel_calc, pixel_out;
2542
2543    transform->in_gp(&pixel_in, in);
2544
2545    if (transform->from_linear == NULL)
2546       transform->transform(&pixel_calc, &pixel_in, transform->background);
2547
2548    else
2549    {
2550       transform->transform(&pixel_out, &pixel_in, transform->background);
2551       transform->from_linear(&pixel_calc, &pixel_out, NULL);
2552    }
2553
2554    transform->out_gp(&pixel_out, out);
2555
2556    /* Eliminate the case where the input and output values match exactly. */
2557    if (pixel_calc.a == pixel_out.a && pixel_calc.r == pixel_out.r &&
2558       pixel_calc.g == pixel_out.g && pixel_calc.b == pixel_out.b)
2559       return 1;
2560
2561    /* Eliminate the case where the output pixel is transparent and the output
2562     * is 8-bit - any component values are valid.  Don't check the input alpha
2563     * here to also skip the 16-bit small alpha cases.
2564     */
2565    if (transform->output_8bit && pixel_calc.a == 0 && pixel_out.a == 0)
2566       return 1;
2567
2568    /* Check for alpha errors first; an alpha error can damage the components too
2569     * so avoid spurious checks on components if one is found.
2570     */
2571    errmsg = NULL;
2572    {
2573       int err_a = abs(pixel_calc.a-pixel_out.a);
2574
2575       if (err_a > transform->error[3])
2576       {
2577          /* If accumulating check the components too */
2578          if (transform->accumulate)
2579             transform->error[3] = (png_uint_16)err_a;
2580
2581          else
2582             errmsg = "alpha";
2583       }
2584    }
2585
2586    /* Now if *either* of the output alphas are 0 but alpha is within tolerance
2587     * eliminate the 8-bit component comparison.
2588     */
2589    if (errmsg == NULL && transform->output_8bit &&
2590       (pixel_calc.a == 0 || pixel_out.a == 0))
2591       return 1;
2592
2593    if (errmsg == NULL) /* else just signal an alpha error */
2594    {
2595       int err_r = abs(pixel_calc.r - pixel_out.r);
2596       int err_g = abs(pixel_calc.g - pixel_out.g);
2597       int err_b = abs(pixel_calc.b - pixel_out.b);
2598       int limit;
2599
2600       if ((err_r | err_g | err_b) == 0)
2601          return 1; /* exact match */
2602
2603       /* Mismatch on a component, check the input alpha */
2604       if (pixel_in.a >= transform->in_opaque)
2605       {
2606          errmsg = "opaque component";
2607          limit = 2; /* opaque */
2608       }
2609
2610       else if (pixel_in.a > 0)
2611       {
2612          errmsg = "alpha component";
2613          limit = 1; /* partially transparent */
2614       }
2615
2616       else
2617       {
2618          errmsg = "transparent component (background)";
2619          limit = 0; /* transparent */
2620       }
2621
2622       maxerr = err_r;
2623       if (maxerr < err_g) maxerr = err_g;
2624       if (maxerr < err_b) maxerr = err_b;
2625
2626       if (maxerr <= transform->error[limit])
2627          return 1; /* within the error limits */
2628
2629       /* Handle a component mis-match; log it, just return an error code, or
2630        * accumulate it.
2631        */
2632       if (transform->accumulate)
2633       {
2634          transform->error[limit] = (png_uint_16)maxerr;
2635          return 1; /* to cause the caller to keep going */
2636       }
2637    }
2638
2639    /* Failure to match and not accumulating, so the error must be logged. */
2640    return logpixel(transform, x, y, &pixel_in, &pixel_calc, &pixel_out, errmsg);
2641 }
2642
2643 static png_byte
2644 component_loc(png_byte loc[4], png_uint_32 format)
2645 {
2646    /* Given a format return the number of channels and the location of
2647     * each channel.
2648     *
2649     * The mask 'loc' contains the component offset of the channels in the
2650     * following order.  Note that if 'format' is grayscale the entries 1-3 must
2651     * all contain the location of the gray channel.
2652     *
2653     * 0: alpha
2654     * 1: red or gray
2655     * 2: green or gray
2656     * 3: blue or gray
2657     */
2658    png_byte channels;
2659
2660    if (format & PNG_FORMAT_FLAG_COLOR)
2661    {
2662       channels = 3;
2663
2664       loc[2] = 1;
2665
2666 #     ifdef PNG_FORMAT_BGR_SUPPORTED
2667          if (format & PNG_FORMAT_FLAG_BGR)
2668          {
2669             loc[1] = 2;
2670             loc[3] = 0;
2671          }
2672
2673          else
2674 #     endif
2675       {
2676          loc[1] = 0;
2677          loc[3] = 2;
2678       }
2679    }
2680
2681    else
2682    {
2683       channels = 1;
2684       loc[1] = loc[2] = loc[3] = 0;
2685    }
2686
2687    if (format & PNG_FORMAT_FLAG_ALPHA)
2688    {
2689 #     ifdef PNG_FORMAT_AFIRST_SUPPORTED
2690          if (format & PNG_FORMAT_FLAG_AFIRST)
2691          {
2692             loc[0] = 0;
2693             ++loc[1];
2694             ++loc[2];
2695             ++loc[3];
2696          }
2697
2698          else
2699 #     endif
2700          loc[0] = channels;
2701
2702       ++channels;
2703    }
2704
2705    else
2706       loc[0] = 4; /* not present */
2707
2708    return channels;
2709 }
2710
2711 /* Compare two images, the original 'a', which was written out then read back in
2712  * to * give image 'b'.  The formats may have been changed.
2713  */
2714 static int
2715 compare_two_images(Image *a, Image *b, int via_linear,
2716    png_const_colorp background)
2717 {
2718    ptrdiff_t stridea = a->stride;
2719    ptrdiff_t strideb = b->stride;
2720    png_const_bytep rowa = a->buffer+16;
2721    png_const_bytep rowb = b->buffer+16;
2722    const png_uint_32 width = a->image.width;
2723    const png_uint_32 height = a->image.height;
2724    const png_uint_32 formata = a->image.format;
2725    const png_uint_32 formatb = b->image.format;
2726    const unsigned int a_sample = PNG_IMAGE_SAMPLE_SIZE(formata);
2727    const unsigned int b_sample = PNG_IMAGE_SAMPLE_SIZE(formatb);
2728    int alpha_added, alpha_removed;
2729    int bchannels;
2730    int btoa[4];
2731    png_uint_32 y;
2732    Transform tr;
2733
2734    /* This should never happen: */
2735    if (width != b->image.width || height != b->image.height)
2736       return logerror(a, a->file_name, ": width x height changed: ",
2737          b->file_name);
2738
2739    /* Set up the background and the transform */
2740    transform_from_formats(&tr, a, b, background, via_linear);
2741
2742    /* Find the first row and inter-row space. */
2743    if (!(formata & PNG_FORMAT_FLAG_COLORMAP) &&
2744       (formata & PNG_FORMAT_FLAG_LINEAR))
2745       stridea *= 2;
2746
2747    if (!(formatb & PNG_FORMAT_FLAG_COLORMAP) &&
2748       (formatb & PNG_FORMAT_FLAG_LINEAR))
2749       strideb *= 2;
2750
2751    if (stridea < 0) rowa += (height-1) * (-stridea);
2752    if (strideb < 0) rowb += (height-1) * (-strideb);
2753
2754    /* First shortcut the two colormap case by comparing the image data; if it
2755     * matches then we expect the colormaps to match, although this is not
2756     * absolutely necessary for an image match.  If the colormaps fail to match
2757     * then there is a problem in libpng.
2758     */
2759    if (formata & formatb & PNG_FORMAT_FLAG_COLORMAP)
2760    {
2761       /* Only check colormap entries that actually exist; */
2762       png_const_bytep ppa, ppb;
2763       int match;
2764       png_byte in_use[256], amax = 0, bmax = 0;
2765
2766       memset(in_use, 0, sizeof in_use);
2767
2768       ppa = rowa;
2769       ppb = rowb;
2770
2771       /* Do this the slow way to accumulate the 'in_use' flags, don't break out
2772        * of the loop until the end; this validates the color-mapped data to
2773        * ensure all pixels are valid color-map indexes.
2774        */
2775       for (y=0, match=1; y<height && match; ++y, ppa += stridea, ppb += strideb)
2776       {
2777          png_uint_32 x;
2778
2779          for (x=0; x<width; ++x)
2780          {
2781             png_byte bval = ppb[x];
2782             png_byte aval = ppa[x];
2783
2784             if (bval > bmax)
2785                bmax = bval;
2786
2787             if (bval != aval)
2788                match = 0;
2789
2790             in_use[aval] = 1;
2791             if (aval > amax)
2792                amax = aval;
2793          }
2794       }
2795
2796       /* If the buffers match then the colormaps must too. */
2797       if (match)
2798       {
2799          /* Do the color-maps match, entry by entry?  Only check the 'in_use'
2800           * entries.  An error here should be logged as a color-map error.
2801           */
2802          png_const_bytep a_cmap = (png_const_bytep)a->colormap;
2803          png_const_bytep b_cmap = (png_const_bytep)b->colormap;
2804          int result = 1; /* match by default */
2805
2806          /* This is used in logpixel to get the error message correct. */
2807          tr.is_palette = 1;
2808
2809          for (y=0; y<256; ++y, a_cmap += a_sample, b_cmap += b_sample)
2810             if (in_use[y])
2811          {
2812             /* The colormap entries should be valid, but because libpng doesn't
2813              * do any checking at present the original image may contain invalid
2814              * pixel values.  These cause an error here (at present) unless
2815              * accumulating errors in which case the program just ignores them.
2816              */
2817             if (y >= a->image.colormap_entries)
2818             {
2819                if ((a->opts & ACCUMULATE) == 0)
2820                {
2821                   char pindex[9];
2822                   sprintf(pindex, "%lu[%lu]", (unsigned long)y,
2823                      (unsigned long)a->image.colormap_entries);
2824                   logerror(a, a->file_name, ": bad pixel index: ", pindex);
2825                }
2826                result = 0;
2827             }
2828
2829             else if (y >= b->image.colormap_entries)
2830             {
2831                if ((a->opts & ACCUMULATE) == 0)
2832                   {
2833                   char pindex[9];
2834                   sprintf(pindex, "%lu[%lu]", (unsigned long)y,
2835                      (unsigned long)b->image.colormap_entries);
2836                   logerror(b, b->file_name, ": bad pixel index: ", pindex);
2837                   }
2838                result = 0;
2839             }
2840
2841             /* All the mismatches are logged here; there can only be 256! */
2842             else if (!cmppixel(&tr, a_cmap, b_cmap, 0, y))
2843                result = 0;
2844          }
2845
2846          /* If reqested copy the error values back from the Transform. */
2847          if (a->opts & ACCUMULATE)
2848          {
2849             tr.error_ptr[0] = tr.error[0];
2850             tr.error_ptr[1] = tr.error[1];
2851             tr.error_ptr[2] = tr.error[2];
2852             tr.error_ptr[3] = tr.error[3];
2853             result = 1; /* force a continue */
2854          }
2855
2856          return result;
2857       }
2858
2859       /* else the image buffers don't match pixel-wise so compare sample values
2860        * instead, but first validate that the pixel indexes are in range (but
2861        * only if not accumulating, when the error is ignored.)
2862        */
2863       else if ((a->opts & ACCUMULATE) == 0)
2864       {
2865          /* Check the original image first,
2866           * TODO: deal with input images with bad pixel values?
2867           */
2868          if (amax >= a->image.colormap_entries)
2869          {
2870             char pindex[9];
2871             sprintf(pindex, "%d[%lu]", amax,
2872                (unsigned long)a->image.colormap_entries);
2873             return logerror(a, a->file_name, ": bad pixel index: ", pindex);
2874          }
2875
2876          else if (bmax >= b->image.colormap_entries)
2877          {
2878             char pindex[9];
2879             sprintf(pindex, "%d[%lu]", bmax,
2880                (unsigned long)b->image.colormap_entries);
2881             return logerror(b, b->file_name, ": bad pixel index: ", pindex);
2882          }
2883       }
2884    }
2885
2886    /* We can directly compare pixel values without the need to use the read
2887     * or transform support (i.e. a memory compare) if:
2888     *
2889     * 1) The bit depth has not changed.
2890     * 2) RGB to grayscale has not been done (the reverse is ok; we just compare
2891     *    the three RGB values to the original grayscale.)
2892     * 3) An alpha channel has not been removed from an 8-bit format, or the
2893     *    8-bit alpha value of the pixel was 255 (opaque).
2894     *
2895     * If an alpha channel has been *added* then it must have the relevant opaque
2896     * value (255 or 65535).
2897     *
2898     * The fist two the tests (in the order given above) (using the boolean
2899     * equivalence !a && !b == !(a || b))
2900     */
2901    if (!(((formata ^ formatb) & PNG_FORMAT_FLAG_LINEAR) |
2902       (formata & (formatb ^ PNG_FORMAT_FLAG_COLOR) & PNG_FORMAT_FLAG_COLOR)))
2903    {
2904       /* Was an alpha channel changed? */
2905       const png_uint_32 alpha_changed = (formata ^ formatb) &
2906          PNG_FORMAT_FLAG_ALPHA;
2907
2908       /* Was an alpha channel removed?  (The third test.)  If so the direct
2909        * comparison is only possible if the input alpha is opaque.
2910        */
2911       alpha_removed = (formata & alpha_changed) != 0;
2912
2913       /* Was an alpha channel added? */
2914       alpha_added = (formatb & alpha_changed) != 0;
2915
2916       /* The channels may have been moved between input and output, this finds
2917        * out how, recording the result in the btoa array, which says where in
2918        * 'a' to find each channel of 'b'.  If alpha was added then btoa[alpha]
2919        * ends up as 4 (and is not used.)
2920        */
2921       {
2922          int i;
2923          png_byte aloc[4];
2924          png_byte bloc[4];
2925
2926          /* The following are used only if the formats match, except that
2927           * 'bchannels' is a flag for matching formats.  btoa[x] says, for each
2928           * channel in b, where to find the corresponding value in a, for the
2929           * bchannels.  achannels may be different for a gray to rgb transform
2930           * (a will be 1 or 2, b will be 3 or 4 channels.)
2931           */
2932          (void)component_loc(aloc, formata);
2933          bchannels = component_loc(bloc, formatb);
2934
2935          /* Hence the btoa array. */
2936          for (i=0; i<4; ++i) if (bloc[i] < 4)
2937             btoa[bloc[i]] = aloc[i]; /* may be '4' for alpha */
2938
2939          if (alpha_added)
2940             alpha_added = bloc[0]; /* location of alpha channel in image b */
2941
2942          else
2943             alpha_added = 4; /* Won't match an image b channel */
2944
2945          if (alpha_removed)
2946             alpha_removed = aloc[0]; /* location of alpha channel in image a */
2947
2948          else
2949             alpha_removed = 4;
2950       }
2951    }
2952
2953    else
2954    {
2955       /* Direct compare is not possible, cancel out all the corresponding local
2956        * variables.
2957        */
2958       bchannels = 0;
2959       alpha_removed = alpha_added = 4;
2960       btoa[3] = btoa[2] = btoa[1] = btoa[0] = 4; /* 4 == not present */
2961    }
2962
2963    for (y=0; y<height; ++y, rowa += stridea, rowb += strideb)
2964    {
2965       png_const_bytep ppa, ppb;
2966       png_uint_32 x;
2967
2968       for (x=0, ppa=rowa, ppb=rowb; x<width; ++x)
2969       {
2970          png_const_bytep psa, psb;
2971
2972          if (formata & PNG_FORMAT_FLAG_COLORMAP)
2973             psa = (png_const_bytep)a->colormap + a_sample * *ppa++;
2974          else
2975             psa = ppa, ppa += a_sample;
2976
2977          if (formatb & PNG_FORMAT_FLAG_COLORMAP)
2978             psb = (png_const_bytep)b->colormap + b_sample * *ppb++;
2979          else
2980             psb = ppb, ppb += b_sample;
2981
2982          /* Do the fast test if possible. */
2983          if (bchannels)
2984          {
2985             /* Check each 'b' channel against either the corresponding 'a'
2986              * channel or the opaque alpha value, as appropriate.  If
2987              * alpha_removed value is set (not 4) then also do this only if the
2988              * 'a' alpha channel (alpha_removed) is opaque; only relevant for
2989              * the 8-bit case.
2990              */
2991             if (formatb & PNG_FORMAT_FLAG_LINEAR) /* 16-bit checks */
2992             {
2993                png_const_uint_16p pua = aligncastconst(png_const_uint_16p, psa);
2994                png_const_uint_16p pub = aligncastconst(png_const_uint_16p, psb);
2995
2996                switch (bchannels)
2997                {
2998                   case 4:
2999                      if (pua[btoa[3]] != pub[3]) break;
3000                   case 3:
3001                      if (pua[btoa[2]] != pub[2]) break;
3002                   case 2:
3003                      if (pua[btoa[1]] != pub[1]) break;
3004                   case 1:
3005                      if (pua[btoa[0]] != pub[0]) break;
3006                      if (alpha_added != 4 && pub[alpha_added] != 65535) break;
3007                      continue; /* x loop */
3008                   default:
3009                      break; /* impossible */
3010                }
3011             }
3012
3013             else if (alpha_removed == 4 || psa[alpha_removed] == 255)
3014             {
3015                switch (bchannels)
3016                {
3017                   case 4:
3018                      if (psa[btoa[3]] != psb[3]) break;
3019                   case 3:
3020                      if (psa[btoa[2]] != psb[2]) break;
3021                   case 2:
3022                      if (psa[btoa[1]] != psb[1]) break;
3023                   case 1:
3024                      if (psa[btoa[0]] != psb[0]) break;
3025                      if (alpha_added != 4 && psb[alpha_added] != 255) break;
3026                      continue; /* x loop */
3027                   default:
3028                      break; /* impossible */
3029                }
3030             }
3031          }
3032
3033          /* If we get to here the fast match failed; do the slow match for this
3034           * pixel.
3035           */
3036          if (!cmppixel(&tr, psa, psb, x, y) && (a->opts & KEEP_GOING) == 0)
3037             return 0; /* error case */
3038       }
3039    }
3040
3041    /* If reqested copy the error values back from the Transform. */
3042    if (a->opts & ACCUMULATE)
3043    {
3044       tr.error_ptr[0] = tr.error[0];
3045       tr.error_ptr[1] = tr.error[1];
3046       tr.error_ptr[2] = tr.error[2];
3047       tr.error_ptr[3] = tr.error[3];
3048    }
3049
3050    return 1;
3051 }
3052
3053 /* Read the file; how the read gets done depends on which of input_file and
3054  * input_memory have been set.
3055  */
3056 static int
3057 read_file(Image *image, png_uint_32 format, png_const_colorp background)
3058 {
3059    memset(&image->image, 0, sizeof image->image);
3060    image->image.version = PNG_IMAGE_VERSION;
3061
3062    if (image->input_memory != NULL)
3063    {
3064       if (!png_image_begin_read_from_memory(&image->image, image->input_memory,
3065          image->input_memory_size))
3066          return logerror(image, "memory init: ", image->file_name, "");
3067    }
3068
3069 #  ifdef PNG_STDIO_SUPPORTED
3070       else if (image->input_file != NULL)
3071       {
3072          if (!png_image_begin_read_from_stdio(&image->image, image->input_file))
3073             return logerror(image, "stdio init: ", image->file_name, "");
3074       }
3075
3076       else
3077       {
3078          if (!png_image_begin_read_from_file(&image->image, image->file_name))
3079             return logerror(image, "file init: ", image->file_name, "");
3080       }
3081 #  else
3082       else
3083       {
3084          return logerror(image, "unsupported file/stdio init: ",
3085             image->file_name, "");
3086       }
3087 #  endif
3088
3089    /* This must be set after the begin_read call: */
3090    if (image->opts & sRGB_16BIT)
3091       image->image.flags |= PNG_IMAGE_FLAG_16BIT_sRGB;
3092
3093    /* Have an initialized image with all the data we need plus, maybe, an
3094     * allocated file (myfile) or buffer (mybuffer) that need to be freed.
3095     */
3096    {
3097       int result;
3098       png_uint_32 image_format;
3099
3100       /* Print both original and output formats. */
3101       image_format = image->image.format;
3102
3103       if (image->opts & VERBOSE)
3104       {
3105          printf("%s %lu x %lu %s -> %s", image->file_name,
3106             (unsigned long)image->image.width,
3107             (unsigned long)image->image.height,
3108             format_names[image_format & FORMAT_MASK],
3109             (format & FORMAT_NO_CHANGE) != 0 || image->image.format == format
3110             ? "no change" : format_names[format & FORMAT_MASK]);
3111
3112          if (background != NULL)
3113             printf(" background(%d,%d,%d)\n", background->red,
3114                background->green, background->blue);
3115          else
3116             printf("\n");
3117
3118          fflush(stdout);
3119       }
3120
3121       /* 'NO_CHANGE' combined with the color-map flag forces the base format
3122        * flags to be set on read to ensure that the original representation is
3123        * not lost in the pass through a colormap format.
3124        */
3125       if ((format & FORMAT_NO_CHANGE) != 0)
3126       {
3127          if ((format & PNG_FORMAT_FLAG_COLORMAP) != 0 &&
3128             (image_format & PNG_FORMAT_FLAG_COLORMAP) != 0)
3129             format = (image_format & ~BASE_FORMATS) | (format & BASE_FORMATS);
3130
3131          else
3132             format = image_format;
3133       }
3134
3135       image->image.format = format;
3136
3137       image->stride = PNG_IMAGE_ROW_STRIDE(image->image) + image->stride_extra;
3138       allocbuffer(image);
3139
3140       result = png_image_finish_read(&image->image, background,
3141          image->buffer+16, (png_int_32)image->stride, image->colormap);
3142
3143       checkbuffer(image, image->file_name);
3144
3145       if (result)
3146          return checkopaque(image);
3147
3148       else
3149          return logerror(image, image->file_name, ": image read failed", "");
3150    }
3151 }
3152
3153 /* Reads from a filename, which must be in image->file_name, but uses
3154  * image->opts to choose the method.  The file is always read in its native
3155  * format (the one the simplified API suggests).
3156  */
3157 static int
3158 read_one_file(Image *image)
3159 {
3160    if (!(image->opts & READ_FILE) || (image->opts & USE_STDIO))
3161    {
3162       /* memory or stdio. */
3163       FILE *f = fopen(image->file_name, "rb");
3164
3165       if (f != NULL)
3166       {
3167          if (image->opts & READ_FILE)
3168             image->input_file = f;
3169
3170          else /* memory */
3171          {
3172             if (fseek(f, 0, SEEK_END) == 0)
3173             {
3174                long int cb = ftell(f);
3175
3176                if (cb > 0 && (unsigned long int)cb < (size_t)~(size_t)0)
3177                {
3178                   png_bytep b = voidcast(png_bytep, malloc((size_t)cb));
3179
3180                   if (b != NULL)
3181                   {
3182                      rewind(f);
3183
3184                      if (fread(b, (size_t)cb, 1, f) == 1)
3185                      {
3186                         fclose(f);
3187                         image->input_memory_size = cb;
3188                         image->input_memory = b;
3189                      }
3190
3191                      else
3192                      {
3193                         free(b);
3194                         return logclose(image, f, image->file_name,
3195                            ": read failed: ");
3196                      }
3197                   }
3198
3199                   else
3200                      return logclose(image, f, image->file_name,
3201                         ": out of memory: ");
3202                }
3203
3204                else if (cb == 0)
3205                   return logclose(image, f, image->file_name,
3206                      ": zero length: ");
3207
3208                else
3209                   return logclose(image, f, image->file_name,
3210                      ": tell failed: ");
3211             }
3212
3213             else
3214                return logclose(image, f, image->file_name, ": seek failed: ");
3215          }
3216       }
3217
3218       else
3219          return logerror(image, image->file_name, ": open failed: ",
3220             strerror(errno));
3221    }
3222
3223    return read_file(image, FORMAT_NO_CHANGE, NULL);
3224 }
3225
3226 #ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
3227 static int
3228 write_one_file(Image *output, Image *image, int convert_to_8bit)
3229 {
3230    if (image->opts & FAST_WRITE)
3231       image->image.flags |= PNG_IMAGE_FLAG_FAST;
3232
3233    if (image->opts & USE_STDIO)
3234    {
3235       FILE *f = tmpfile();
3236
3237       if (f != NULL)
3238       {
3239          if (png_image_write_to_stdio(&image->image, f, convert_to_8bit,
3240             image->buffer+16, (png_int_32)image->stride, image->colormap))
3241          {
3242             if (fflush(f) == 0)
3243             {
3244                rewind(f);
3245                initimage(output, image->opts, "tmpfile", image->stride_extra);
3246                output->input_file = f;
3247                if (!checkopaque(image))
3248                   return 0;
3249             }
3250
3251             else
3252                return logclose(image, f, "tmpfile", ": flush: ");
3253          }
3254
3255          else
3256          {
3257             fclose(f);
3258             return logerror(image, "tmpfile", ": write failed", "");
3259          }
3260       }
3261
3262       else
3263          return logerror(image, "tmpfile", ": open: ", strerror(errno));
3264    }
3265
3266    else
3267    {
3268       static int counter = 0;
3269       char name[32];
3270
3271       sprintf(name, "%s%d.png", tmpf, ++counter);
3272
3273       if (png_image_write_to_file(&image->image, name, convert_to_8bit,
3274          image->buffer+16, (png_int_32)image->stride, image->colormap))
3275       {
3276          initimage(output, image->opts, output->tmpfile_name,
3277             image->stride_extra);
3278          /* Afterwards, or freeimage will delete it! */
3279          strcpy(output->tmpfile_name, name);
3280
3281          if (!checkopaque(image))
3282             return 0;
3283       }
3284
3285       else
3286          return logerror(image, name, ": write failed", "");
3287    }
3288
3289    /* 'output' has an initialized temporary image, read this back in and compare
3290     * this against the original: there should be no change since the original
3291     * format was written unmodified unless 'convert_to_8bit' was specified.
3292     * However, if the original image was color-mapped, a simple read will zap
3293     * the linear, color and maybe alpha flags, this will cause spurious failures
3294     * under some circumstances.
3295     */
3296    if (read_file(output, image->image.format | FORMAT_NO_CHANGE, NULL))
3297    {
3298       png_uint_32 original_format = image->image.format;
3299
3300       if (convert_to_8bit)
3301          original_format &= ~PNG_FORMAT_FLAG_LINEAR;
3302
3303       if ((output->image.format & BASE_FORMATS) !=
3304          (original_format & BASE_FORMATS))
3305          return logerror(image, image->file_name, ": format changed on read: ",
3306             output->file_name);
3307
3308       return compare_two_images(image, output, 0/*via linear*/, NULL);
3309    }
3310
3311    else
3312       return logerror(output, output->tmpfile_name,
3313          ": read of new file failed", "");
3314 }
3315 #endif
3316
3317 static int
3318 testimage(Image *image, png_uint_32 opts, format_list *pf)
3319 {
3320    int result;
3321    Image copy;
3322
3323    /* Copy the original data, stealing it from 'image' */
3324    checkopaque(image);
3325    copy = *image;
3326
3327    copy.opts = opts;
3328    copy.buffer = NULL;
3329    copy.bufsize = 0;
3330    copy.allocsize = 0;
3331
3332    image->input_file = NULL;
3333    image->input_memory = NULL;
3334    image->input_memory_size = 0;
3335    image->tmpfile_name[0] = 0;
3336
3337    {
3338       png_uint_32 counter;
3339       Image output;
3340
3341       newimage(&output);
3342
3343       result = 1;
3344
3345       /* Use the low bit of 'counter' to indicate whether or not to do alpha
3346        * removal with a background color or by composting onto the image; this
3347        * step gets skipped if it isn't relevant
3348        */
3349       for (counter=0; counter<2*FORMAT_COUNT; ++counter)
3350          if (format_isset(pf, counter >> 1))
3351       {
3352          png_uint_32 format = counter >> 1;
3353
3354          png_color background_color;
3355          png_colorp background = NULL;
3356
3357          /* If there is a format change that removes the alpha channel then
3358           * the background is relevant.  If the output is 8-bit color-mapped
3359           * then a background color *must* be provided, otherwise there are
3360           * two tests to do - one with a color, the other with NULL.  The
3361           * NULL test happens second.
3362           */
3363          if ((counter & 1) == 0)
3364          {
3365             if ((format & PNG_FORMAT_FLAG_ALPHA) == 0 &&
3366                (image->image.format & PNG_FORMAT_FLAG_ALPHA) != 0)
3367             {
3368                /* Alpha/transparency will be removed, the background is
3369                 * relevant: make it a color the first time
3370                 */
3371                random_color(&background_color);
3372                background = &background_color;
3373
3374                /* BUT if the output is to a color-mapped 8-bit format then
3375                 * the background must always be a color, so increment 'counter'
3376                 * to skip the NULL test.
3377                 */
3378                if ((format & PNG_FORMAT_FLAG_COLORMAP) != 0 &&
3379                   (format & PNG_FORMAT_FLAG_LINEAR) == 0)
3380                   ++counter;
3381             }
3382
3383             /* Otherwise an alpha channel is not being eliminated, just leave
3384              * background NULL and skip the (counter & 1) NULL test.
3385              */
3386             else
3387                ++counter;
3388          }
3389          /* else just use NULL for background */
3390
3391          resetimage(&copy);
3392          copy.opts = opts; /* in case read_file needs to change it */
3393
3394          result = read_file(&copy, format, background);
3395          if (!result)
3396             break;
3397
3398          /* Make sure the file just read matches the original file. */
3399          result = compare_two_images(image, &copy, 0/*via linear*/, background);
3400          if (!result)
3401             break;
3402
3403 #        ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
3404             /* Write the *copy* just made to a new file to make sure the write
3405              * side works ok.  Check the conversion to sRGB if the copy is
3406              * linear.
3407              */
3408             output.opts = opts;
3409             result = write_one_file(&output, &copy, 0/*convert to 8bit*/);
3410             if (!result)
3411                break;
3412
3413             /* Validate against the original too; the background is needed here
3414              * as well so that compare_two_images knows what color was used.
3415              */
3416             result = compare_two_images(image, &output, 0, background);
3417             if (!result)
3418                break;
3419
3420             if ((format & PNG_FORMAT_FLAG_LINEAR) != 0 &&
3421                (format & PNG_FORMAT_FLAG_COLORMAP) == 0)
3422             {
3423                /* 'output' is linear, convert to the corresponding sRGB format.
3424                 */
3425                output.opts = opts;
3426                result = write_one_file(&output, &copy, 1/*convert to 8bit*/);
3427                if (!result)
3428                   break;
3429
3430                /* This may involve a conversion via linear; in the ideal world
3431                 * this would round-trip correctly, but libpng 1.5.7 is not the
3432                 * ideal world so allow a drift (error_via_linear).
3433                 *
3434                 * 'image' has an alpha channel but 'output' does not then there
3435                 * will a strip-alpha-channel operation (because 'output' is
3436                 * linear), handle this by composing on black when doing the
3437                 * comparison.
3438                 */
3439                result = compare_two_images(image, &output, 1/*via_linear*/,
3440                   background);
3441                if (!result)
3442                   break;
3443             }
3444 #        endif /* PNG_SIMPLIFIED_WRITE_SUPPORTED */
3445       }
3446
3447       freeimage(&output);
3448    }
3449
3450    freeimage(&copy);
3451
3452    return result;
3453 }
3454
3455 static int
3456 test_one_file(const char *file_name, format_list *formats, png_uint_32 opts,
3457    int stride_extra, int log_pass)
3458 {
3459    int result;
3460    Image image;
3461
3462    newimage(&image);
3463    initimage(&image, opts, file_name, stride_extra);
3464    result = read_one_file(&image);
3465    if (result)
3466       result = testimage(&image, opts, formats);
3467    freeimage(&image);
3468
3469    /* Ensure that stderr is flushed into any log file */
3470    fflush(stderr);
3471
3472    if (log_pass)
3473    {
3474       if (result)
3475          printf("PASS:");
3476
3477       else
3478          printf("FAIL:");
3479
3480 #     ifndef PNG_SIMPLIFIED_WRITE_SUPPORTED
3481          printf(" (no write)");
3482 #     endif
3483
3484       print_opts(opts);
3485       printf(" %s\n", file_name);
3486       /* stdout may not be line-buffered if it is piped to a file, so: */
3487       fflush(stdout);
3488    }
3489
3490    else if (!result)
3491       exit(1);
3492
3493    return result;
3494 }
3495
3496 int
3497 main(int argc, char **argv)
3498 {
3499    png_uint_32 opts = FAST_WRITE;
3500    format_list formats;
3501    const char *touch = NULL;
3502    int log_pass = 0;
3503    int redundant = 0;
3504    int stride_extra = 0;
3505    int retval = 0;
3506    int c;
3507
3508    init_sRGB_to_d();
3509 #if 0
3510    init_error_via_linear();
3511 #endif
3512    format_init(&formats);
3513
3514    for (c=1; c<argc; ++c)
3515    {
3516       const char *arg = argv[c];
3517
3518       if (strcmp(arg, "--log") == 0)
3519          log_pass = 1;
3520       else if (strcmp(arg, "--fresh") == 0)
3521       {
3522          memset(gpc_error, 0, sizeof gpc_error);
3523          memset(gpc_error_via_linear, 0, sizeof gpc_error_via_linear);
3524       }
3525       else if (strcmp(arg, "--file") == 0)
3526 #        ifdef PNG_STDIO_SUPPORTED
3527             opts |= READ_FILE;
3528 #        else
3529             return 77; /* skipped: no support */
3530 #        endif
3531       else if (strcmp(arg, "--memory") == 0)
3532          opts &= ~READ_FILE;
3533       else if (strcmp(arg, "--stdio") == 0)
3534 #        ifdef PNG_STDIO_SUPPORTED
3535             opts |= USE_STDIO;
3536 #        else
3537             return 77; /* skipped: no support */
3538 #        endif
3539       else if (strcmp(arg, "--name") == 0)
3540          opts &= ~USE_STDIO;
3541       else if (strcmp(arg, "--verbose") == 0)
3542          opts |= VERBOSE;
3543       else if (strcmp(arg, "--quiet") == 0)
3544          opts &= ~VERBOSE;
3545       else if (strcmp(arg, "--preserve") == 0)
3546          opts |= KEEP_TMPFILES;
3547       else if (strcmp(arg, "--nopreserve") == 0)
3548          opts &= ~KEEP_TMPFILES;
3549       else if (strcmp(arg, "--keep-going") == 0)
3550          opts |= KEEP_GOING;
3551       else if (strcmp(arg, "--fast") == 0)
3552          opts |= FAST_WRITE;
3553       else if (strcmp(arg, "--slow") == 0)
3554          opts &= ~FAST_WRITE;
3555       else if (strcmp(arg, "--accumulate") == 0)
3556          opts |= ACCUMULATE;
3557       else if (strcmp(arg, "--redundant") == 0)
3558          redundant = 1;
3559       else if (strcmp(arg, "--stop") == 0)
3560          opts &= ~KEEP_GOING;
3561       else if (strcmp(arg, "--strict") == 0)
3562          opts |= STRICT;
3563       else if (strcmp(arg, "--sRGB-16bit") == 0)
3564          opts |= sRGB_16BIT;
3565       else if (strcmp(arg, "--linear-16bit") == 0)
3566          opts &= ~sRGB_16BIT;
3567       else if (strcmp(arg, "--tmpfile") == 0)
3568       {
3569          if (c+1 < argc)
3570          {
3571             if (strlen(argv[++c]) >= sizeof tmpf)
3572             {
3573                fflush(stdout);
3574                fprintf(stderr, "%s: %s is too long for a temp file prefix\n",
3575                   argv[0], argv[c]);
3576                exit(99);
3577             }
3578
3579             /* Safe: checked above */
3580             strcpy(tmpf, argv[c]);
3581          }
3582
3583          else
3584          {
3585             fflush(stdout);
3586             fprintf(stderr, "%s: %s requires a temporary file prefix\n",
3587                argv[0], arg);
3588             exit(99);
3589          }
3590       }
3591       else if (strcmp(arg, "--touch") == 0)
3592       {
3593          if (c+1 < argc)
3594             touch = argv[++c];
3595
3596          else
3597          {
3598             fflush(stdout);
3599             fprintf(stderr, "%s: %s requires a file name argument\n",
3600                argv[0], arg);
3601             exit(99);
3602          }
3603       }
3604       else if (arg[0] == '+')
3605       {
3606          png_uint_32 format = formatof(arg+1);
3607
3608          if (format > FORMAT_COUNT)
3609             exit(99);
3610
3611          format_set(&formats, format);
3612       }
3613       else if (arg[0] == '-' && arg[1] != 0 && (arg[1] != '0' || arg[2] != 0))
3614       {
3615          fflush(stdout);
3616          fprintf(stderr, "%s: unknown option: %s\n", argv[0], arg);
3617          exit(99);
3618       }
3619       else
3620       {
3621          if (format_is_initial(&formats))
3622             format_default(&formats, redundant);
3623
3624          if (arg[0] == '-')
3625          {
3626             const int term = (arg[1] == '0' ? 0 : '\n');
3627             unsigned int ich = 0;
3628
3629             /* Loop reading files, use a static buffer to simplify this and just
3630              * stop if the name gets to long.
3631              */
3632             static char buffer[4096];
3633
3634             do
3635             {
3636                int ch = getchar();
3637
3638                /* Don't allow '\0' in file names, and terminate with '\n' or,
3639                 * for -0, just '\0' (use -print0 to find to make this work!)
3640                 */
3641                if (ch == EOF || ch == term || ch == 0)
3642                {
3643                   buffer[ich] = 0;
3644
3645                   if (ich > 0 && !test_one_file(buffer, &formats, opts,
3646                      stride_extra, log_pass))
3647                      retval = 1;
3648
3649                   if (ch == EOF)
3650                      break;
3651
3652                   ich = 0;
3653                   --ich; /* so that the increment below sets it to 0 again */
3654                }
3655
3656                else
3657                   buffer[ich] = (char)ch;
3658             } while (++ich < sizeof buffer);
3659
3660             if (ich)
3661             {
3662                buffer[32] = 0;
3663                buffer[4095] = 0;
3664                fprintf(stderr, "%s...%s: file name too long\n", buffer,
3665                   buffer+(4096-32));
3666                exit(99);
3667             }
3668          }
3669
3670          else if (!test_one_file(arg, &formats, opts, stride_extra, log_pass))
3671             retval = 1;
3672       }
3673    }
3674
3675    if (opts & ACCUMULATE)
3676    {
3677       unsigned int in;
3678
3679       printf("static png_uint_16 gpc_error[16/*in*/][16/*out*/][4/*a*/] =\n");
3680       printf("{\n");
3681       for (in=0; in<16; ++in)
3682       {
3683          unsigned int out;
3684          printf(" { /* input: %s */\n ", format_names[in]);
3685          for (out=0; out<16; ++out)
3686          {
3687             unsigned int alpha;
3688             printf(" {");
3689             for (alpha=0; alpha<4; ++alpha)
3690             {
3691                printf(" %d", gpc_error[in][out][alpha]);
3692                if (alpha < 3) putchar(',');
3693             }
3694             printf(" }");
3695             if (out < 15)
3696             {
3697                putchar(',');
3698                if (out % 4 == 3) printf("\n ");
3699             }
3700          }
3701          printf("\n }");
3702
3703          if (in < 15)
3704             putchar(',');
3705          else
3706             putchar('\n');
3707       }
3708       printf("};\n");
3709
3710       printf("static png_uint_16 gpc_error_via_linear[16][4/*out*/][4] =\n");
3711       printf("{\n");
3712       for (in=0; in<16; ++in)
3713       {
3714          unsigned int out;
3715          printf(" { /* input: %s */\n ", format_names[in]);
3716          for (out=0; out<4; ++out)
3717          {
3718             unsigned int alpha;
3719             printf(" {");
3720             for (alpha=0; alpha<4; ++alpha)
3721             {
3722                printf(" %d", gpc_error_via_linear[in][out][alpha]);
3723                if (alpha < 3) putchar(',');
3724             }
3725             printf(" }");
3726             if (out < 3)
3727                putchar(',');
3728          }
3729          printf("\n }");
3730
3731          if (in < 15)
3732             putchar(',');
3733          else
3734             putchar('\n');
3735       }
3736       printf("};\n");
3737
3738       printf("static png_uint_16 gpc_error_to_colormap[8/*i*/][8/*o*/][4] =\n");
3739       printf("{\n");
3740       for (in=0; in<8; ++in)
3741       {
3742          unsigned int out;
3743          printf(" { /* input: %s */\n ", format_names[in]);
3744          for (out=0; out<8; ++out)
3745          {
3746             unsigned int alpha;
3747             printf(" {");
3748             for (alpha=0; alpha<4; ++alpha)
3749             {
3750                printf(" %d", gpc_error_to_colormap[in][out][alpha]);
3751                if (alpha < 3) putchar(',');
3752             }
3753             printf(" }");
3754             if (out < 7)
3755             {
3756                putchar(',');
3757                if (out % 4 == 3) printf("\n ");
3758             }
3759          }
3760          printf("\n }");
3761
3762          if (in < 7)
3763             putchar(',');
3764          else
3765             putchar('\n');
3766       }
3767       printf("};\n");
3768    }
3769
3770    if (retval == 0 && touch != NULL)
3771    {
3772       FILE *fsuccess = fopen(touch, "wt");
3773
3774       if (fsuccess != NULL)
3775       {
3776          int error = 0;
3777          fprintf(fsuccess, "PNG simple API tests succeeded\n");
3778          fflush(fsuccess);
3779          error = ferror(fsuccess);
3780
3781          if (fclose(fsuccess) || error)
3782          {
3783             fflush(stdout);
3784             fprintf(stderr, "%s: write failed\n", touch);
3785             exit(99);
3786          }
3787       }
3788
3789       else
3790       {
3791          fflush(stdout);
3792          fprintf(stderr, "%s: open failed\n", touch);
3793          exit(99);
3794       }
3795    }
3796
3797    return retval;
3798 }
3799
3800 #else /* !PNG_SIMPLIFIED_READ_SUPPORTED */
3801 int main(void)
3802 {
3803    fprintf(stderr, "pngstest: no read support in libpng, test skipped\n");
3804    /* So the test is skipped: */
3805    return 77;
3806 }
3807 #endif /* PNG_SIMPLIFIED_READ_SUPPORTED */