diff options
Diffstat (limited to 'contrib/libtests/pngstest.c')
| -rw-r--r-- | contrib/libtests/pngstest.c | 3565 |
1 files changed, 765 insertions, 2800 deletions
diff --git a/contrib/libtests/pngstest.c b/contrib/libtests/pngstest.c index 32d5eea49..6e17b2022 100644 --- a/contrib/libtests/pngstest.c +++ b/contrib/libtests/pngstest.c @@ -1,9 +1,9 @@ /*- * pngstest.c * - * Copyright (c) 2013 John Cunningham Bowler + * Copyright (c) 2012 John Cunningham Bowler * - * Last changed in libpng 1.6.0 [February 14, 2013] + * Last changed in libpng 1.6.0 [(PENDING RELEASE)] * * This code is released under the libpng license. * For conditions of distribution and use, see the disclaimer @@ -22,7 +22,7 @@ #include <ctype.h> #include <math.h> -#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H) +#if (defined HAVE_CONFIG_H) && !(defined PNG_NO_CONFIG_H) # include <config.h> #endif @@ -35,77 +35,15 @@ # include "../../png.h" #endif -#ifdef PNG_SIMPLIFIED_READ_SUPPORTED /* Else nothing can be done */ #include "../tools/sRGB.h" -/* KNOWN ISSUES - * - * These defines switch on alternate algorithms for format conversions to match - * the current libpng implementation; they are set to allow pngstest to pass - * even though libpng is producing answers that are not as correct as they - * should be. - */ -#define ALLOW_UNUSED_GPC 0 - /* If true include unused static GPC functions and declare an external array - * of them to hide the fact that they are unused. This is for development - * use while testing the correct function to use to take into account libpng - * misbehavior, such as using a simple power law to correct sRGB to linear. - */ - /* The following is to support direct compilation of this file as C++ */ #ifdef __cplusplus # define voidcast(type, value) static_cast<type>(value) -# define aligncastconst(type, value) \ - static_cast<type>(static_cast<const void*>(value)) #else # define voidcast(type, value) (value) -# define aligncastconst(type, value) ((const void*)(value)) #endif /* __cplusplus */ -/* During parallel runs of pngstest each temporary file needs a unique name, - * this is used to permit uniqueness using a command line argument which can be - * up to 22 characters long. - */ -static char tmpf[23] = "TMP"; - -/* Generate random bytes. This uses a boring repeatable algorithm and it - * is implemented here so that it gives the same set of numbers on every - * architecture. It's a linear congruential generator (Knuth or Sedgewick - * "Algorithms") but it comes from the 'feedback taps' table in Horowitz and - * Hill, "The Art of Electronics". - */ -static void -make_random_bytes(png_uint_32* seed, void* pv, size_t size) -{ - png_uint_32 u0 = seed[0], u1 = seed[1]; - png_bytep bytes = voidcast(png_bytep, pv); - - /* There are thirty three bits, the next bit in the sequence is bit-33 XOR - * bit-20. The top 1 bit is in u1, the bottom 32 are in u0. - */ - size_t i; - for (i=0; i<size; ++i) - { - /* First generate 8 new bits then shift them in at the end. */ - png_uint_32 u = ((u0 >> (20-8)) ^ ((u1 << 7) | (u0 >> (32-7)))) & 0xff; - u1 <<= 8; - u1 |= u0 >> 24; - u0 <<= 8; - u0 |= u; - *bytes++ = (png_byte)u; - } - - seed[0] = u0; - seed[1] = u1; -} - -static void -random_color(png_colorp color) -{ - static png_uint_32 color_seed[2] = { 0x12345678, 0x9abcdef }; - make_random_bytes(color_seed, color, sizeof *color); -} - /* Math support - neither Cygwin nor Visual Studio have C99 support and we need * a predictable rounding function, so make one here: */ @@ -131,27 +69,8 @@ u16d(double d) } /* sRGB support: use exact calculations rounded to the nearest int, see the - * fesetround() call in main(). sRGB_to_d optimizes the 8 to 16-bit conversion. + * fesetround() call in main(). */ -static double sRGB_to_d[256]; -static double g22_to_d[256]; - -static void -init_sRGB_to_d(void) -{ - int i; - - sRGB_to_d[0] = 0; - for (i=1; i<255; ++i) - sRGB_to_d[i] = linear_from_sRGB(i/255.); - sRGB_to_d[255] = 1; - - g22_to_d[0] = 0; - for (i=1; i<255; ++i) - g22_to_d[i] = pow(i/255., 1/.45455); - g22_to_d[255] = 1; -} - static png_byte sRGB(double linear /*range 0.0 .. 1.0*/) { @@ -164,47 +83,12 @@ isRGB(int fixed_linear) return sRGB(fixed_linear / 65535.); } -#if 0 /* not used */ -static png_byte -unpremultiply(int component, int alpha) -{ - if (alpha <= component) - return 255; /* Arbitrary, but consistent with the libpng code */ - - else if (alpha >= 65535) - return isRGB(component); - - else - return sRGB((double)component / alpha); -} -#endif - -static png_uint_16 -ilinear(int fixed_srgb) -{ - return u16d(65535 * sRGB_to_d[fixed_srgb]); -} - static png_uint_16 ilineara(int fixed_srgb, int alpha) { - return u16d((257 * alpha) * sRGB_to_d[fixed_srgb]); -} - -static png_uint_16 -ilinear_g22(int fixed_srgb) -{ - return u16d(65535 * g22_to_d[fixed_srgb]); + return u16d((257 * alpha) * linear_from_sRGB(fixed_srgb / 255.)); } -#if ALLOW_UNUSED_GPC -static png_uint_16 -ilineara_g22(int fixed_srgb, int alpha) -{ - return u16d((257 * alpha) * g22_to_d[fixed_srgb]); -} -#endif - static double YfromRGBint(int ir, int ig, int ib) { @@ -214,107 +98,12 @@ YfromRGBint(int ir, int ig, int ib) return YfromRGB(r, g, b); } -#if 0 /* unused */ -/* The error that results from using a 2.2 power law in place of the correct - * sRGB transform, given an 8-bit value which might be either sRGB or power-law. - */ -static int -power_law_error8(int value) -{ - if (value > 0 && value < 255) - { - double vd = value / 255.; - double e = fabs( - pow(sRGB_to_d[value], 1/2.2) - sRGB_from_linear(pow(vd, 2.2))); - - /* Always allow an extra 1 here for rounding errors */ - e = 1+floor(255 * e); - return (int)e; - } - - return 0; -} - -static int error_in_sRGB_roundtrip = 56; /* by experiment */ -static int -power_law_error16(int value) -{ - if (value > 0 && value < 65535) - { - /* Round trip the value through an 8-bit representation but using - * non-matching to/from conversions. - */ - double vd = value / 65535.; - double e = fabs( - pow(sRGB_from_linear(vd), 2.2) - linear_from_sRGB(pow(vd, 1/2.2))); - - /* Always allow an extra 1 here for rounding errors */ - e = error_in_sRGB_roundtrip+floor(65535 * e); - return (int)e; - } - - return 0; -} - -static int -compare_8bit(int v1, int v2, int error_limit, int multiple_algorithms) -{ - int e = abs(v1-v2); - int ev1, ev2; - - if (e <= error_limit) - return 1; - - if (!multiple_algorithms) - return 0; - - ev1 = power_law_error8(v1); - if (e <= ev1) - return 1; - - ev2 = power_law_error8(v2); - if (e <= ev2) - return 1; - - return 0; -} - -static int -compare_16bit(int v1, int v2, int error_limit, int multiple_algorithms) -{ - int e = abs(v1-v2); - int ev1, ev2; - - if (e <= error_limit) - return 1; - - /* "multiple_algorithms" in this case means that a color-map has been - * involved somewhere, so we can deduce that the values were forced to 8-bit - * (like the via_linear case for 8-bit.) - */ - if (!multiple_algorithms) - return 0; - - ev1 = power_law_error16(v1); - if (e <= ev1) - return 1; - - ev2 = power_law_error16(v2); - if (e <= ev2) - return 1; - - return 0; -} -#endif /* unused */ - #define READ_FILE 1 /* else memory */ #define USE_STDIO 2 /* else use file name */ -#define STRICT 4 /* fail on warnings too */ +#define USE_BACKGROUND 4 /* else composite in place */ #define VERBOSE 8 #define KEEP_TMPFILES 16 /* else delete temporary files */ #define KEEP_GOING 32 -#define ACCUMULATE 64 -#define FAST_WRITE 128 static void print_opts(png_uint_32 opts) @@ -323,18 +112,14 @@ print_opts(png_uint_32 opts) printf(" --file"); if (opts & USE_STDIO) printf(" --stdio"); - if (opts & STRICT) - printf(" --strict"); + if (opts & USE_BACKGROUND) + printf(" --background"); if (opts & VERBOSE) printf(" --verbose"); if (opts & KEEP_TMPFILES) printf(" --preserve"); if (opts & KEEP_GOING) printf(" --keep-going"); - if (opts & ACCUMULATE) - printf(" --accumulate"); - if (!(opts & FAST_WRITE)) /* --fast is currently the default */ - printf(" --slow"); } #define FORMAT_NO_CHANGE 0x80000000 /* additional flag */ @@ -342,9 +127,7 @@ print_opts(png_uint_32 opts) /* A name table for all the formats - defines the format of the '+' arguments to * pngstest. */ -#define FORMAT_COUNT 64 -#define FORMAT_MASK 0x3f -static PNG_CONST char * PNG_CONST format_names[FORMAT_COUNT] = +static PNG_CONST char * PNG_CONST format_names[32] = { "sRGB-gray", "sRGB-gray+alpha", @@ -354,16 +137,6 @@ static PNG_CONST char * PNG_CONST format_names[FORMAT_COUNT] = "linear-gray+alpha", "linear-rgb", "linear-rgb+alpha", - - "color-mapped-sRGB-gray", - "color-mapped-sRGB-gray+alpha", - "color-mapped-sRGB-rgb", - "color-mapped-sRGB-rgb+alpha", - "color-mapped-linear-gray", - "color-mapped-linear-gray+alpha", - "color-mapped-linear-rgb", - "color-mapped-linear-rgb+alpha", - "sRGB-gray", "sRGB-gray+alpha", "sRGB-bgr", @@ -372,16 +145,6 @@ static PNG_CONST char * PNG_CONST format_names[FORMAT_COUNT] = "linear-gray+alpha", "linear-bgr", "linear-bgr+alpha", - - "color-mapped-sRGB-gray", - "color-mapped-sRGB-gray+alpha", - "color-mapped-sRGB-bgr", - "color-mapped-sRGB-bgr+alpha", - "color-mapped-linear-gray", - "color-mapped-linear-gray+alpha", - "color-mapped-linear-bgr", - "color-mapped-linear-bgr+alpha", - "sRGB-gray", "alpha+sRGB-gray", "sRGB-rgb", @@ -390,16 +153,6 @@ static PNG_CONST char * PNG_CONST format_names[FORMAT_COUNT] = "alpha+linear-gray", "linear-rgb", "alpha+linear-rgb", - - "color-mapped-sRGB-gray", - "color-mapped-alpha+sRGB-gray", - "color-mapped-sRGB-rgb", - "color-mapped-alpha+sRGB-rgb", - "color-mapped-linear-gray", - "color-mapped-alpha+linear-gray", - "color-mapped-linear-rgb", - "color-mapped-alpha+linear-rgb", - "sRGB-gray", "alpha+sRGB-gray", "sRGB-bgr", @@ -408,15 +161,6 @@ static PNG_CONST char * PNG_CONST format_names[FORMAT_COUNT] = "alpha+linear-gray", "linear-bgr", "alpha+linear-bgr", - - "color-mapped-sRGB-gray", - "color-mapped-alpha+sRGB-gray", - "color-mapped-sRGB-bgr", - "color-mapped-alpha+sRGB-bgr", - "color-mapped-linear-gray", - "color-mapped-alpha+linear-gray", - "color-mapped-linear-bgr", - "color-mapped-alpha+linear-bgr", }; /* Decode an argument to a format number. */ @@ -426,107 +170,17 @@ formatof(const char *arg) char *ep; unsigned long format = strtoul(arg, &ep, 0); - if (ep > arg && *ep == 0 && format < FORMAT_COUNT) + if (ep > arg && *ep == 0 && format < 32) return (png_uint_32)format; - else for (format=0; format < FORMAT_COUNT; ++format) + else for (format=0; format < 32; ++format) { if (strcmp(format_names[format], arg) == 0) return (png_uint_32)format; } fprintf(stderr, "pngstest: format name '%s' invalid\n", arg); - return FORMAT_COUNT; -} - -/* Bitset/test functions for formats */ -#define FORMAT_SET_COUNT (FORMAT_COUNT / 32) -typedef struct -{ - png_uint_32 bits[FORMAT_SET_COUNT]; -} -format_list; - -static void format_init(format_list *pf) -{ - int i; - for (i=0; i<FORMAT_SET_COUNT; ++i) - pf->bits[i] = 0; /* All off */ -} - -#if 0 /* currently unused */ -static void format_clear(format_list *pf) -{ - int i; - for (i=0; i<FORMAT_SET_COUNT; ++i) - pf->bits[i] = 0; -} -#endif - -static int format_is_initial(format_list *pf) -{ - int i; - for (i=0; i<FORMAT_SET_COUNT; ++i) - if (pf->bits[i] != 0) - return 0; - - return 1; -} - -static int format_set(format_list *pf, png_uint_32 format) -{ - if (format < FORMAT_COUNT) - return pf->bits[format >> 5] |= ((png_uint_32)1) << (format & 31); - - return 0; -} - -#if 0 /* currently unused */ -static int format_unset(format_list *pf, png_uint_32 format) -{ - if (format < FORMAT_COUNT) - return pf->bits[format >> 5] &= ~((png_uint_32)1) << (format & 31); - - return 0; -} -#endif - -static int format_isset(format_list *pf, png_uint_32 format) -{ - return format < FORMAT_COUNT && - (pf->bits[format >> 5] & (((png_uint_32)1) << (format & 31))) != 0; -} - -static void format_default(format_list *pf, int redundant) -{ - if (redundant) - { - int i; - - /* set everything, including flags that are pointless */ - for (i=0; i<FORMAT_SET_COUNT; ++i) - pf->bits[i] = ~(png_uint_32)0; - } - - else - { - png_uint_32 f; - - for (f=0; f<FORMAT_COUNT; ++f) - { - /* Eliminate redundant settings. */ - /* BGR is meaningless if no color: */ - if ((f & PNG_FORMAT_FLAG_COLOR) == 0 && (f & PNG_FORMAT_FLAG_BGR) != 0) - continue; - - /* AFIRST is meaningless if no alpha: */ - if ((f & PNG_FORMAT_FLAG_ALPHA) == 0 && - (f & PNG_FORMAT_FLAG_AFIRST) != 0) - continue; - - format_set(pf, f); - } - } + return 32; } /* THE Image STRUCTURE */ @@ -546,8 +200,8 @@ typedef struct ptrdiff_t stride; png_size_t bufsize; png_size_t allocsize; + png_color background; char tmpfile_name[32]; - png_uint_16 colormap[256*4]; } Image; @@ -636,7 +290,6 @@ allocbuffer(Image *image) image->buffer = voidcast(png_bytep, malloc(size+32)); if (image->buffer == NULL) { - fflush(stdout); fprintf(stderr, "simpletest: out of memory allocating %lu(+32) byte buffer\n", (unsigned long)size); @@ -669,14 +322,12 @@ checkbuffer(Image *image, const char *arg) { if (check16(image->buffer, 95)) { - fflush(stdout); fprintf(stderr, "%s: overwrite at start of image buffer\n", arg); exit(1); } if (check16(image->buffer+16+image->allocsize, 95)) { - fflush(stdout); fprintf(stderr, "%s: overwrite at end of image buffer\n", arg); exit(1); } @@ -688,7 +339,6 @@ checkbuffer(Image *image, const char *arg) static int logerror(Image *image, const char *a1, const char *a2, const char *a3) { - fflush(stdout); if (image->image.warning_or_error) fprintf(stderr, "%s%s%s: %s\n", a1, a2, a3, image->image.message); @@ -729,9 +379,6 @@ checkopaque(Image *image) return logerror(image, image->file_name, ": opaque not NULL", ""); } - else if (image->image.warning_or_error != 0 && (image->opts & STRICT) != 0) - return logerror(image, image->file_name, " --strict", ""); - else return 1; } @@ -742,2271 +389,896 @@ checkopaque(Image *image) */ typedef struct { - /* The components, for grayscale images the gray value is in 'g' and if alpha - * is not present 'a' is set to 255 or 65535 according to format. - */ - int r, g, b, a; + png_uint_32 format; + png_uint_16 r16, g16, b16, y16, a16; + png_byte r8, g8, b8, y8, a8; } Pixel; -typedef struct -{ - /* The background as the original sRGB 8-bit value converted to the final - * integer format and as a double precision linear value in the range 0..1 - * for with partially transparent pixels. - */ - int ir, ig, ib; - double dr, dg, db; /* linear r,g,b scaled to 0..1 */ -} Background; - -/* Basic image formats; control the data but not the layout thereof. */ -#define BASE_FORMATS\ - (PNG_FORMAT_FLAG_ALPHA|PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_LINEAR) - -/* Read a Pixel from a buffer. The code below stores the correct routine for - * the format in a function pointer, these are the routines: +/* This is not particularly fast, but it works. The input has pixels stored + * either as pre-multiplied linear 16-bit or as sRGB encoded non-pre-multiplied + * 8-bit values. The routine reads either and does exact conversion to the + * other format. + * + * Grayscale values are mapped r==g==b=y. Non-alpha images have alpha + * 65535/255. Color images have a correctly calculated Y value using the sRGB Y + * calculation. + * + * The API returns false if an error is detected; this can only be if the alpha + * value is less than the component in the linear case. */ -static void -gp_g8(Pixel *p, png_const_voidp pb) -{ - png_const_bytep pp = voidcast(png_const_bytep, pb); - - p->r = p->g = p->b = pp[0]; - p->a = 255; -} - -static void -gp_ga8(Pixel *p, png_const_voidp pb) -{ - png_const_bytep pp = voidcast(png_const_bytep, pb); - - p->r = p->g = p->b = pp[0]; - p->a = pp[1]; -} - -static void -gp_ag8(Pixel *p, png_const_voidp pb) -{ - png_const_bytep pp = voidcast(png_const_bytep, pb); - - p->r = p->g = p->b = pp[1]; - p->a = pp[0]; -} - -static void -gp_rgb8(Pixel *p, png_const_voidp pb) -{ - png_const_bytep pp = voidcast(png_const_bytep, pb); - - p->r = pp[0]; - p->g = pp[1]; - p->b = pp[2]; - p->a = 255; -} - -static void -gp_bgr8(Pixel *p, png_const_voidp pb) -{ - png_const_bytep pp = voidcast(png_const_bytep, pb); - - p->r = pp[2]; - p->g = pp[1]; - p->b = pp[0]; - p->a = 255; -} - -static void -gp_rgba8(Pixel *p, png_const_voidp pb) +static int +get_pixel(Image *image, Pixel *pixel, png_const_bytep pp) { - png_const_bytep pp = voidcast(png_const_bytep, pb); + png_uint_32 format = image->image.format; + int result = 1; - p->r = pp[0]; - p->g = pp[1]; - p->b = pp[2]; - p->a = pp[3]; -} - -static void -gp_bgra8(Pixel *p, png_const_voidp pb) -{ - png_const_bytep pp = voidcast(png_const_bytep, pb); - - p->r = pp[2]; - p->g = pp[1]; - p->b = pp[0]; - p->a = pp[3]; -} - -static void -gp_argb8(Pixel *p, png_const_voidp pb) -{ - png_const_bytep pp = voidcast(png_const_bytep, pb); - - p->r = pp[1]; - p->g = pp[2]; - p->b = pp[3]; - p->a = pp[0]; -} - -static void -gp_abgr8(Pixel *p, png_const_voidp pb) -{ - png_const_bytep pp = voidcast(png_const_bytep, pb); - - p->r = pp[3]; - p->g = pp[2]; - p->b = pp[1]; - p->a = pp[0]; -} - -static void -gp_g16(Pixel *p, png_const_voidp pb) -{ - png_const_uint_16p pp = voidcast(png_const_uint_16p, pb); - - p->r = p->g = p->b = pp[0]; - p->a = 65535; -} - -static void -gp_ga16(Pixel *p, png_const_voidp pb) -{ - png_const_uint_16p pp = voidcast(png_const_uint_16p, pb); - - p->r = p->g = p->b = pp[0]; - p->a = pp[1]; -} - -static void -gp_ag16(Pixel *p, png_const_voidp pb) -{ - png_const_uint_16p pp = voidcast(png_const_uint_16p, pb); - - p->r = p->g = p->b = pp[1]; - p->a = pp[0]; -} - -static void -gp_rgb16(Pixel *p, png_const_voidp pb) -{ - png_const_uint_16p pp = voidcast(png_const_uint_16p, pb); - - p->r = pp[0]; - p->g = pp[1]; - p->b = pp[2]; - p->a = 65535; -} + pixel->format = format; -static void -gp_bgr16(Pixel *p, png_const_voidp pb) -{ - png_const_uint_16p pp = voidcast(png_const_uint_16p, pb); + /* Initialize the alpha values for opaque: */ + pixel->a8 = 255; + pixel->a16 = 65535; - p->r = pp[2]; - p->g = pp[1]; - p->b = pp[0]; - p->a = 65535; -} + switch (PNG_IMAGE_COMPONENT_SIZE(format)) + { + default: + fprintf(stderr, "pngstest: impossible component size: %lu\n", + (unsigned long)PNG_IMAGE_COMPONENT_SIZE(format)); + exit(1); -static void -gp_rgba16(Pixel *p, png_const_voidp pb) -{ - png_const_uint_16p pp = voidcast(png_const_uint_16p, pb); + case sizeof (png_uint_16): + { + png_const_uint_16p up = (png_const_uint_16p)pp; - p->r = pp[0]; - p->g = pp[1]; - p->b = pp[2]; - p->a = pp[3]; -} + if ((format & PNG_FORMAT_FLAG_AFIRST) != 0 && + (format & PNG_FORMAT_FLAG_ALPHA) != 0) + pixel->a16 = *up++; -static void -gp_bgra16(Pixel *p, png_const_voidp pb) -{ - png_const_uint_16p pp = voidcast(png_const_uint_16p, pb); + if ((format & PNG_FORMAT_FLAG_COLOR) != 0) + { + if ((format & PNG_FORMAT_FLAG_BGR) != 0) + { + pixel->b16 = *up++; + pixel->g16 = *up++; + pixel->r16 = *up++; + } - p->r = pp[2]; - p->g = pp[1]; - p->b = pp[0]; - p->a = pp[3]; -} + else + { + pixel->r16 = *up++; + pixel->g16 = *up++; + pixel->b16 = *up++; + } -static void -gp_argb16(Pixel *p, png_const_voidp pb) -{ - png_const_uint_16p pp = voidcast(png_const_uint_16p, pb); + /* Because the 'Y' calculation is linear the pre-multiplication + * of the r16,g16,b16 values can be ignored. + */ + pixel->y16 = u16d(YfromRGBint(pixel->r16, pixel->g16, + pixel->b16)); + } - p->r = pp[1]; - p->g = pp[2]; - p->b = pp[3]; - p->a = pp[0]; -} + else + pixel->r16 = pixel->g16 = pixel->b16 = pixel->y16 = *up++; -static void -gp_abgr16(Pixel *p, png_const_voidp pb) -{ - png_const_uint_16p pp = voidcast(png_const_uint_16p, pb); + if ((format & PNG_FORMAT_FLAG_AFIRST) == 0 && + (format & PNG_FORMAT_FLAG_ALPHA) != 0) + pixel->a16 = *up++; - p->r = pp[3]; - p->g = pp[2]; - p->b = pp[1]; - p->a = pp[0]; -} + /* 'a1' is 1/65535 * 1/alpha, for alpha in the range 0..1 */ + if (pixel->a16 == 0) + { + pixel->r8 = pixel->g8 = pixel->b8 = pixel->y8 = 255; + pixel->a8 = 0; + } -/* Given a format, return the correct one of the above functions. */ -static void (* -get_pixel(png_uint_32 format))(Pixel *p, png_const_voidp pb) -{ - /* The color-map flag is irrelevant here - the caller of the function - * returned must either pass the buffer or, for a color-mapped image, the - * correct entry in the color-map. - */ - if (format & PNG_FORMAT_FLAG_LINEAR) - { - if (format & PNG_FORMAT_FLAG_COLOR) - { - if (format & PNG_FORMAT_FLAG_BGR) - { - if (format & PNG_FORMAT_FLAG_ALPHA) + else { - if (format & PNG_FORMAT_FLAG_AFIRST) - return gp_abgr16; + double a1 = 1. / pixel->a16; + if (pixel->a16 < pixel->r16) + result = 0, pixel->r8 = 255; else - return gp_bgra16; - } + pixel->r8 = sRGB(pixel->r16 * a1); - else - return gp_bgr16; - } + if (pixel->a16 < pixel->g16) + result = 0, pixel->g8 = 255; + else + pixel->g8 = sRGB(pixel->g16 * a1); - else - { - if (format & PNG_FORMAT_FLAG_ALPHA) - { - if (format & PNG_FORMAT_FLAG_AFIRST) - return gp_argb16; + if (pixel->a16 < pixel->b16) + result = 0, pixel->b8 = 255; + else + pixel->b8 = sRGB(pixel->b16 * a1); + if (pixel->a16 < pixel->y16) + result = 0, pixel->y8 = 255; else - return gp_rgba16; - } + pixel->y8 = sRGB(pixel->y16 * a1); - else - return gp_rgb16; + /* The 8-bit alpha value is just a16/257. */ + pixel->a8 = u8d(pixel->a16 / 257.); + } } - } + break; - else - { - if (format & PNG_FORMAT_FLAG_ALPHA) + case sizeof (png_byte): { - if (format & PNG_FORMAT_FLAG_AFIRST) - return gp_ag16; + double y; - else - return gp_ga16; - } - - else - return gp_g16; - } - } + if ((format & PNG_FORMAT_FLAG_AFIRST) != 0 && + (format & PNG_FORMAT_FLAG_ALPHA) != 0) + pixel->a8 = *pp++; - else - { - if (format & PNG_FORMAT_FLAG_COLOR) - { - if (format & PNG_FORMAT_FLAG_BGR) - { - if (format & PNG_FORMAT_FLAG_ALPHA) + if ((format & PNG_FORMAT_FLAG_COLOR) != 0) { - if (format & PNG_FORMAT_FLAG_AFIRST) - return gp_abgr8; + if ((format & PNG_FORMAT_FLAG_BGR) != 0) + { + pixel->b8 = *pp++; + pixel->g8 = *pp++; + pixel->r8 = *pp++; + } else - return gp_bgra8; - } - - else - return gp_bgr8; - } + { + pixel->r8 = *pp++; + pixel->g8 = *pp++; + pixel->b8 = *pp++; + } - else - { - if (format & PNG_FORMAT_FLAG_ALPHA) - { - if (format & PNG_FORMAT_FLAG_AFIRST) - return gp_argb8; + /* The y8 value requires convert to linear, convert to &, convert + * to sRGB: + */ + y = YfromRGB(linear_from_sRGB(pixel->r8/255.), + linear_from_sRGB(pixel->g8/255.), + linear_from_sRGB(pixel->b8/255.)); - else - return gp_rgba8; + pixel->y8 = sRGB(y); } else - return gp_rgb8; - } - } + { + pixel->r8 = pixel->g8 = pixel->b8 = pixel->y8 = *pp++; + y = linear_from_sRGB(pixel->y8/255.); + } - else - { - if (format & PNG_FORMAT_FLAG_ALPHA) - { - if (format & PNG_FORMAT_FLAG_AFIRST) - return gp_ag8; + if ((format & PNG_FORMAT_FLAG_AFIRST) == 0 && + (format & PNG_FORMAT_FLAG_ALPHA) != 0) + pixel->a8 = *pp++; - else - return gp_ga8; + pixel->r16 = ilineara(pixel->r8, pixel->a8); + pixel->g16 = ilineara(pixel->g8, pixel->a8); + pixel->b16 = ilineara(pixel->b8, pixel->a8); + pixel->y16 = u16d((257 * pixel->a8) * y); + pixel->a16 = (png_uint_16)(pixel->a8 * 257); } - - else - return gp_g8; - } + break; } + + return result; } -/* Convertion between pixel formats. The code above effectively eliminates the - * component ordering changes leaving three basic changes: - * - * 1) Remove an alpha channel by pre-multiplication or compositing on a - * background color. (Adding an alpha channel is a no-op.) - * - * 2) Remove color by mapping to grayscale. (Grayscale to color is a no-op.) - * - * 3) Convert between 8-bit and 16-bit components. (Both directtions are - * relevant.) - * - * This gives the following base format conversion matrix: +/* Two pixels are equal if the value of the left equals the value of the right + * as defined by the format of the right, or if it is close enough given the + * permitted error limits. If the formats match the values should (exactly!) * - * OUT: ----- 8-bit ----- ----- 16-bit ----- - * IN G GA RGB RGBA G GA RGB RGBA - * 8 G . . . . lin lin lin lin - * 8 GA bckg . bckc . pre' pre pre' pre - * 8 RGB g8 g8 . . glin glin lin lin - * 8 RGBA g8b g8 bckc . gpr' gpre pre' pre - * 16 G sRGB sRGB sRGB sRGB . . . . - * 16 GA b16g unpg b16c unpc A . A . - * 16 RGB sG sG sRGB sRGB g16 g16 . . - * 16 RGBA gb16 sGp cb16 sCp g16 g16' A . + * If the right pixel has no alpha channel but the left does, it was removed + * somehow. For an 8-bit *output* removal uses the background color if given + * else the default (the value filled in to the row buffer by allocbuffer() + * above.) * - * 8-bit to 8-bit: - * bckg: composite on gray background - * bckc: composite on color background - * g8: convert sRGB components to sRGB grayscale - * g8b: convert sRGB components to grayscale and composite on gray background + * The result of this function is NULL if the pixels match else a reason why + * they don't match. * - * 8-bit to 16-bit: - * lin: make sRGB components linear, alpha := 65535 - * pre: make sRGB components linear and premultiply by alpha (scale alpha) - * pre': as 'pre' but alpha := 65535 - * glin: make sRGB components linear, convert to grayscale, alpha := 65535 - * gpre: make sRGB components grayscale and linear and premultiply by alpha - * gpr': as 'gpre' but alpha := 65535 - * - * 16-bit to 8-bit: - * sRGB: convert linear components to sRGB, alpha := 255 - * unpg: unpremultiply gray component and convert to sRGB (scale alpha) - * unpc: unpremultiply color components and convert to sRGB (scale alpha) - * b16g: composite linear onto gray background and convert the result to sRGB - * b16c: composite linear onto color background and convert the result to sRGB - * sG: convert linear RGB to sRGB grayscale - * sGp: unpremultiply RGB then convert to sRGB grayscale - * sCp: unpremultiply RGB then convert to sRGB - * gb16: composite linear onto background and convert to sRGB grayscale - * (order doesn't matter, the composite and grayscale operations permute) - * cb16: composite linear onto background and convert to sRGB - * - * 16-bit to 16-bit: - * A: set alpha to 65535 - * g16: convert linear RGB to linear grayscale (alpha := 65535) - * g16': as 'g16' but alpha is unchanged + * Error values below are inflated because some of the conversions are done + * inside libpng using a simple power law transform of .45455 and others are + * done in the simplified API code using the correct sRGB tables. This needs + * to be made consistent. */ -/* Simple copy: */ -static void -gpc_noop(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - out->r = in->r; - out->g = in->g; - out->b = in->b; - out->a = in->a; -} - -#if ALLOW_UNUSED_GPC -static void -gpc_nop8(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - if (in->a == 0) - out->r = out->g = out->b = 255; - - else - { - out->r = in->r; - out->g = in->g; - out->b = in->b; - } - - out->a = in->a; -} -#endif - -#if ALLOW_UNUSED_GPC -static void -gpc_nop6(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - if (in->a == 0) - out->r = out->g = out->b = 65535; - - else - { - out->r = in->r; - out->g = in->g; - out->b = in->b; - } - - out->a = in->a; -} -#endif - -/* 8-bit to 8-bit conversions */ -/* bckg: composite on gray background */ -static void -gpc_bckg(Pixel *out, const Pixel *in, const Background *back) -{ - if (in->a <= 0) - out->r = out->g = out->b = back->ig; - - else if (in->a >= 255) - out->r = out->g = out->b = in->g; - - else - { - double a = in->a / 255.; - - out->r = out->g = out->b = sRGB(sRGB_to_d[in->g] * a + back->dg * (1-a)); - } - - out->a = 255; -} - -/* bckc: composite on color background */ -static void -gpc_bckc(Pixel *out, const Pixel *in, const Background *back) -{ - if (in->a <= 0) - { - out->r = back->ir; - out->g = back->ig; - out->b = back->ib; - } - - else if (in->a >= 255) - { - out->r = in->r; - out->g = in->g; - out->b = in->b; - } - - else - { - double a = in->a / 255.; - - out->r = sRGB(sRGB_to_d[in->r] * a + back->dr * (1-a)); - out->g = sRGB(sRGB_to_d[in->g] * a + back->dg * (1-a)); - out->b = sRGB(sRGB_to_d[in->b] * a + back->db * (1-a)); - } - - out->a = 255; -} - -/* g8: convert sRGB components to sRGB grayscale */ -static void -gpc_g8(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - - if (in->r == in->g && in->g == in->b) - out->r = out->g = out->b = in->g; - - else - out->r = out->g = out->b = - sRGB(YfromRGB(sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b])); - - out->a = in->a; -} - -/* g8b: convert sRGB components to grayscale and composite on gray background */ -static void -gpc_g8b(Pixel *out, const Pixel *in, const Background *back) -{ - if (in->a <= 0) - out->r = out->g = out->b = back->ig; - - else if (in->a >= 255) - { - if (in->r == in->g && in->g == in->b) - out->r = out->g = out->b = in->g; - - else - out->r = out->g = out->b = sRGB(YfromRGB( - sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b])); - } - - else - { - double a = in->a/255.; - - out->r = out->g = out->b = sRGB(a * YfromRGB(sRGB_to_d[in->r], - sRGB_to_d[in->g], sRGB_to_d[in->b]) + back->dg * (1-a)); - } - - out->a = 255; -} - -/* 8-bit to 16-bit conversions */ -/* lin: make sRGB components linear, alpha := 65535 */ -static void -gpc_lin(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - - out->r = ilinear(in->r); - - if (in->g == in->r) - { - out->g = out->r; - - if (in->b == in->r) - out->b = out->r; - - else - out->b = ilinear(in->b); - } - - else - { - out->g = ilinear(in->g); - - if (in->b == in->r) - out->b = out->r; - - else if (in->b == in->g) - out->b = out->g; - - else - out->b = ilinear(in->b); - } - - out->a = 65535; -} - -/* pre: make sRGB components linear and premultiply by alpha (scale alpha) */ -static void -gpc_pre(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - - out->r = ilineara(in->r, in->a); - - if (in->g == in->r) - { - out->g = out->r; - - if (in->b == in->r) - out->b = out->r; - - else - out->b = ilineara(in->b, in->a); - } - - else - { - out->g = ilineara(in->g, in->a); - - if (in->b == in->r) - out->b = out->r; - - else if (in->b == in->g) - out->b = out->g; - - else - out->b = ilineara(in->b, in->a); - } - - out->a = in->a * 257; -} - -/* pre': as 'pre' but alpha := 65535 */ -static void -gpc_preq(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - - out->r = ilineara(in->r, in->a); - - if (in->g == in->r) - { - out->g = out->r; - - if (in->b == in->r) - out->b = out->r; - - else - out->b = ilineara(in->b, in->a); - } - - else - { - out->g = ilineara(in->g, in->a); - - if (in->b == in->r) - out->b = out->r; - - else if (in->b == in->g) - out->b = out->g; - - else - out->b = ilineara(in->b, in->a); - } - - out->a = 65535; -} - -/* glin: make sRGB components linear, convert to grayscale, alpha := 65535 */ -static void -gpc_glin(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - - if (in->r == in->g && in->g == in->b) - out->r = out->g = out->b = ilinear(in->g); - - else - out->r = out->g = out->b = u16d(65535 * - YfromRGB(sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b])); - - out->a = 65535; -} - -/* gpre: make sRGB components grayscale and linear and premultiply by alpha */ -static void -gpc_gpre(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - - if (in->r == in->g && in->g == in->b) - out->r = out->g = out->b = ilineara(in->g, in->a); - - else - out->r = out->g = out->b = u16d(in->a * 257 * - YfromRGB(sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b])); - - out->a = 257 * in->a; -} - -/* gpr': as 'gpre' but alpha := 65535 */ -static void -gpc_gprq(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - - if (in->r == in->g && in->g == in->b) - out->r = out->g = out->b = ilineara(in->g, in->a); - - else - out->r = out->g = out->b = u16d(in->a * 257 * - YfromRGB(sRGB_to_d[in->r], sRGB_to_d[in->g], sRGB_to_d[in->b])); - - out->a = 65535; -} - -/* 8-bit to 16-bit conversions for gAMA 45455 encoded values */ -/* Lin: make gAMA 45455 components linear, alpha := 65535 */ -static void -gpc_Lin(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - - out->r = ilinear_g22(in->r); - - if (in->g == in->r) - { - out->g = out->r; - - if (in->b == in->r) - out->b = out->r; - - else - out->b = ilinear_g22(in->b); - } - - else - { - out->g = ilinear_g22(in->g); - - if (in->b == in->r) - out->b = out->r; - - else if (in->b == in->g) - out->b = out->g; - - else - out->b = ilinear_g22(in->b); - } - - out->a = 65535; -} - -#if ALLOW_UNUSED_GPC -/* Pre: make gAMA 45455 components linear and premultiply by alpha (scale alpha) - */ -static void -gpc_Pre(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - - out->r = ilineara_g22(in->r, in->a); - - if (in->g == in->r) - { - out->g = out->r; - - if (in->b == in->r) - out->b = out->r; - - else - out->b = ilineara_g22(in->b, in->a); - } - - else - { - out->g = ilineara_g22(in->g, in->a); - - if (in->b == in->r) - out->b = out->r; - - else if (in->b == in->g) - out->b = out->g; - - else - out->b = ilineara_g22(in->b, in->a); - } - - out->a = in->a * 257; -} -#endif +static int error_to_linear = 811; /* by experiment */ +static int error_to_linear_grayscale = 424; /* by experiment */ +static int error_to_sRGB = 6; /* by experiment */ +static int error_to_sRGB_grayscale = 11; /* by experiment */ +static int error_in_compose = 0; +static int error_via_linear = 14; /* by experiment */ +static int error_in_premultiply = 1; -#if ALLOW_UNUSED_GPC -/* Pre': as 'Pre' but alpha := 65535 */ -static void -gpc_Preq(Pixel *out, const Pixel *in, const Background *back) +static const char * +cmppixel(Pixel *a, Pixel *b, const png_color *background, int via_linear) { - (void)back; - - out->r = ilineara_g22(in->r, in->a); - - if (in->g == in->r) - { - out->g = out->r; - - if (in->b == in->r) - out->b = out->r; + int error_limit = 0; - else - out->b = ilineara_g22(in->b, in->a); - } - - else + if (b->format & PNG_FORMAT_FLAG_LINEAR) { - out->g = ilineara_g22(in->g, in->a); - - if (in->b == in->r) - out->b = out->r; - - else if (in->b == in->g) - out->b = out->g; - - else - out->b = ilineara_g22(in->b, in->a); - } - - out->a = 65535; -} -#endif - -#if ALLOW_UNUSED_GPC -/* Glin: make gAMA 45455 components linear, convert to grayscale, alpha := 65535 - */ -static void -gpc_Glin(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - - if (in->r == in->g && in->g == in->b) - out->r = out->g = out->b = ilinear_g22(in->g); + /* If the input was non-opaque then use the pre-multiplication error + * limit. + */ + if ((a->format & PNG_FORMAT_FLAG_ALPHA) && a->a16 < 65535) + error_limit = error_in_premultiply; - else - out->r = out->g = out->b = u16d(65535 * - YfromRGB(g22_to_d[in->r], g22_to_d[in->g], g22_to_d[in->b])); + if (b->format & PNG_FORMAT_FLAG_ALPHA) + { + /* Expect an exact match. */ + if (b->a16 != a->a16) + return "linear alpha mismatch"; + } - out->a = 65535; -} -#endif + else if (a->format & PNG_FORMAT_FLAG_ALPHA) + { + /* An alpha channel has been removed, the destination is linear so the + * removal algorithm is just the premultiplication - compose on black - + * and the 16-bit colors are correct already. + */ + } -#if ALLOW_UNUSED_GPC -/* Gpre: make gAMA 45455 components grayscale and linear and premultiply by - * alpha. - */ -static void -gpc_Gpre(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; + if (b->format & PNG_FORMAT_FLAG_COLOR) + { + const char *err = "linear color mismatch"; - if (in->r == in->g && in->g == in->b) - out->r = out->g = out->b = ilineara_g22(in->g, in->a); + /* Check for an exact match. */ + if (a->r16 == b->r16 && a->g16 == b->g16 && a->b16 == b->b16) + return NULL; - else - out->r = out->g = out->b = u16d(in->a * 257 * - YfromRGB(g22_to_d[in->r], g22_to_d[in->g], g22_to_d[in->b])); + /* Not an exact match; allow drift only if the input is 8-bit */ + if (!(a->format & PNG_FORMAT_FLAG_LINEAR)) + { + if (error_limit < error_to_linear) + { + error_limit = error_to_linear; + err = "sRGB to linear conversion error"; + } + } - out->a = 257 * in->a; -} -#endif + if (abs(a->r16-b->r16) <= error_limit && + abs(a->g16-b->g16) <= error_limit && + abs(a->b16-b->b16) <= error_limit) + return NULL; -#if ALLOW_UNUSED_GPC -/* Gpr': as 'Gpre' but alpha := 65535 */ -static void -gpc_Gprq(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; + return err; + } - if (in->r == in->g && in->g == in->b) - out->r = out->g = out->b = ilineara_g22(in->g, in->a); + else /* b is grayscale */ + { + const char *err = "linear gray mismatch"; - else - out->r = out->g = out->b = u16d(in->a * 257 * - YfromRGB(g22_to_d[in->r], g22_to_d[in->g], g22_to_d[in->b])); + /* Check for an exact match. */ + if (a->y16 == b->y16) + return NULL; - out->a = 65535; -} -#endif + /* Not an exact match; allow drift only if the input is 8-bit or if it + * has been converted from color. + */ + if (!(a->format & PNG_FORMAT_FLAG_LINEAR)) + { + /* Converted to linear, check for that drift. */ + if (error_limit < error_to_linear) + { + error_limit = error_to_linear; + err = "8-bit gray to linear conversion error"; + } -/* 16-bit to 8-bit conversions */ -/* sRGB: convert linear components to sRGB, alpha := 255 */ -static void -gpc_sRGB(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; + if (abs(a->y16-b->y16) <= error_to_linear) + return NULL; - out->r = isRGB(in->r); + } - if (in->g == in->r) - { - out->g = out->r; + if (a->format & PNG_FORMAT_FLAG_COLOR) + { + /* Converted to grayscale, allow drift */ + if (error_limit < error_to_linear_grayscale) + { + error_limit = error_to_linear_grayscale; + err = "color to linear gray conversion error"; + } + } - if (in->b == in->r) - out->b = out->r; + if (abs(a->y16-b->y16) <= error_limit) + return NULL; - else - out->b = isRGB(in->b); + return err; + } } - else + else /* RHS is 8-bit */ { - out->g = isRGB(in->g); + const char *err; - if (in->b == in->r) - out->b = out->r; - - else if (in->b == in->g) - out->b = out->g; + /* For 8-bit to 8-bit use 'error_via_linear'; this handles the cases where + * the original image is compared with the output of another conversion: + * see where the parameter is set to non-zero below. + */ + if (!(a->format & PNG_FORMAT_FLAG_LINEAR) && via_linear) + error_limit = error_via_linear; + if (b->format & PNG_FORMAT_FLAG_COLOR) + err = "8-bit color mismatch"; + else - out->b = isRGB(in->b); - } - - out->a = 255; -} + err = "8-bit gray mismatch"; -/* unpg: unpremultiply gray component and convert to sRGB (scale alpha) */ -static void -gpc_unpg(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - - if (in->a <= 128) - { - out->r = out->g = out->b = 255; - out->a = 0; - } - - else - { - out->r = out->g = out->b = sRGB((double)in->g / in->a); - out->a = u8d(in->a / 257.); - } -} - -/* unpc: unpremultiply color components and convert to sRGB (scale alpha) */ -static void -gpc_unpc(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - - if (in->a <= 128) - { - out->r = out->g = out->b = 255; - out->a = 0; - } - - else - { - out->r = sRGB((double)in->r / in->a); - out->g = sRGB((double)in->g / in->a); - out->b = sRGB((double)in->b / in->a); - out->a = u8d(in->a / 257.); - } -} - -/* b16g: composite linear onto gray background and convert the result to sRGB */ -static void -gpc_b16g(Pixel *out, const Pixel *in, const Background *back) -{ - if (in->a <= 0) - out->r = out->g = out->b = back->ig; - - else - { - double a = in->a/65535.; - double a1 = 1-a; - - a /= 65535; - out->r = out->g = out->b = sRGB(in->g * a + back->dg * a1); - } - - out->a = 255; -} - -/* b16c: composite linear onto color background and convert the result to sRGB*/ -static void -gpc_b16c(Pixel *out, const Pixel *in, const Background *back) -{ - if (in->a <= 0) - { - out->r = back->ir; - out->g = back->ig; - out->b = back->ib; - } - - else - { - double a = in->a/65535.; - double a1 = 1-a; - - a /= 65535; - out->r = sRGB(in->r * a + back->dr * a1); - out->g = sRGB(in->g * a + back->dg * a1); - out->b = sRGB(in->b * a + back->db * a1); - } - - out->a = 255; -} - -/* sG: convert linear RGB to sRGB grayscale */ -static void -gpc_sG(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - - out->r = out->g = out->b = sRGB(YfromRGBint(in->r, in->g, in->b)/65535); - out->a = 255; -} - -/* sGp: unpremultiply RGB then convert to sRGB grayscale */ -static void -gpc_sGp(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - - if (in->a <= 128) - { - out->r = out->g = out->b = 255; - out->a = 0; - } - - else - { - out->r = out->g = out->b = sRGB(YfromRGBint(in->r, in->g, in->b)/in->a); - out->a = u8d(in->a / 257.); - } -} - -/* sCp: unpremultiply RGB then convert to sRGB */ -static void -gpc_sCp(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - - if (in->a <= 128) - { - out->r = out->g = out->b = 255; - out->a = 0; - } - - else - { - out->r = sRGB((double)in->r / in->a); - out->g = sRGB((double)in->g / in->a); - out->b = sRGB((double)in->b / in->a); - out->a = u8d(in->a / 257.); - } -} - -/* gb16: composite linear onto background and convert to sRGB grayscale */ -/* (order doesn't matter, the composite and grayscale operations permute) */ -static void -gpc_gb16(Pixel *out, const Pixel *in, const Background *back) -{ - if (in->a <= 0) - out->r = out->g = out->b = back->ig; - - else if (in->a >= 65535) - out->r = out->g = out->b = isRGB(in->g); - - else - { - double a = in->a / 65535.; - double a1 = 1-a; - - a /= 65535; - out->r = out->g = out->b = sRGB(in->g * a + back->dg * a1); - } + /* If the original data had an alpha channel and was not pre-multiplied + * pre-multiplication may lose precision in non-opaque pixel values. If + * the output is linear the premultiplied 16-bit values will be used, but + * if 'via_linear' is set an intermediate 16-bit pre-multiplied form has + * been used and this must be taken into account here. + */ + if (via_linear && (a->format & PNG_FORMAT_FLAG_ALPHA) && + !(a->format & PNG_FORMAT_FLAG_LINEAR) && + a->a16 < 65535) + { + if (a->a16 > 0) + { + /* First calculate the rounded 16-bit component values, (r,g,b) or y + * as appropriate, then back-calculate the 8-bit values for + * comparison below. + */ + if (a->format & PNG_FORMAT_FLAG_COLOR) + { + double r = closestinteger((65535. * a->r16) / a->a16)/65535; + double g = closestinteger((65535. * a->g16) / a->a16)/65535; + double blue = closestinteger((65535. * a->b16) / a->a16)/65535; + + a->r16 = u16d(r * a->a16); + a->g16 = u16d(g * a->a16); + a->b16 = u16d(blue * a->a16); + a->y16 = u16d(YfromRGBint(a->r16, a->g16, a->b16)); + + a->r8 = u8d(r * 255); + a->g8 = u8d(g * 255); + a->b8 = u8d(blue * 255); + a->y8 = u8d(255 * YfromRGB(r, g, blue)); + } - out->a = 255; -} + else + { + double y = closestinteger((65535. * a->y16) / a->a16)/65535.; -/* cb16: composite linear onto background and convert to sRGB */ -static void -gpc_cb16(Pixel *out, const Pixel *in, const Background *back) -{ - if (in->a <= 0) - { - out->r = back->ir; - out->g = back->ig; - out->b = back->ib; - } + a->b16 = a->g16 = a->r16 = a->y16 = u16d(y * a->a16); + a->b8 = a->g8 = a->r8 = a->y8 = u8d(255 * y); + } + } - else if (in->a >= 65535) - { - out->r = isRGB(in->r); - out->g = isRGB(in->g); - out->b = isRGB(in->b); - } + else + { + a->r16 = a->g16 = a->b16 = a->y16 = 0; + a->r8 = a->g8 = a->b8 = a->y8 = 255; + } + } - else - { - double a = in->a / 65535.; - double a1 = 1-a; - a /= 65535; - out->r = sRGB(in->r * a + back->dr * a1); - out->g = sRGB(in->g * a + back->dg * a1); - out->b = sRGB(in->b * a + back->db * a1); - } + if (b->format & PNG_FORMAT_FLAG_ALPHA) + { + /* Expect an exact match on the 8 bit value. */ + if (b->a8 != a->a8) + return "8-bit alpha mismatch"; + + /* If the *input* was linear+alpha as well libpng will have converted + * the non-premultiplied format directly to the sRGB non-premultiplied + * format and the precision loss on an intermediate pre-multiplied + * format will have been avoided. In this case we will get spurious + * values in the non-opaque pixels. + */ + if (!via_linear && (a->format & PNG_FORMAT_FLAG_LINEAR) != 0 && + (a->format & PNG_FORMAT_FLAG_ALPHA) != 0 && + a->a16 < 65535) + { + /* We don't know the original values (libpng has already removed + * them) but we can make sure they are in range here by doing a + * comparison on the pre-multiplied values instead. + */ + if (a->a16 > 0) + { + if (b->format & PNG_FORMAT_FLAG_COLOR) + { + double r, g, blue; - out->a = 255; -} + r = (255. * b->r16)/b->a16; + b->r8 = u8d(r); -/* 16-bit to 16-bit conversions */ -/* A: set alpha to 65535 */ -static void -gpc_A(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - out->r = in->r; - out->g = in->g; - out->b = in->b; - out->a = 65535; -} + g = (255. * b->g16)/b->a16; + b->g8 = u8d(g); -/* g16: convert linear RGB to linear grayscale (alpha := 65535) */ -static void -gpc_g16(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - out->r = out->g = out->b = u16d(YfromRGBint(in->r, in->g, in->b)); - out->a = 65535; -} + blue = (255. * b->b16)/b->a16; + b->b8 = u8d(blue); -/* g16': as 'g16' but alpha is unchanged */ -static void -gpc_g16q(Pixel *out, const Pixel *in, const Background *back) -{ - (void)back; - out->r = out->g = out->b = u16d(YfromRGBint(in->r, in->g, in->b)); - out->a = in->a; -} + b->y8 = u8d(YfromRGB(r, g, blue)); + } -#if ALLOW_UNUSED_GPC -/* Unused functions (to hide them from GCC unused function warnings) */ -void (* const gpc_unused[]) - (Pixel *out, const Pixel *in, const Background *back) = -{ - gpc_Pre, gpc_Preq, gpc_Glin, gpc_Gpre, gpc_Gprq, gpc_nop8, gpc_nop6 -}; -#endif + else + { + b->r8 = b->g8 = b->b8 = b->y8 = + u8d((255. * b->y16)/b->a16); + } + } -/* OUT: ----- 8-bit ----- ----- 16-bit ----- - * IN G GA RGB RGBA G GA RGB RGBA - * 8 G . . . . lin lin lin lin - * 8 GA bckg . bckc . pre' pre pre' pre - * 8 RGB g8 g8 . . glin glin lin lin - * 8 RGBA g8b g8 bckc . gpr' gpre pre' pre - * 16 G sRGB sRGB sRGB sRGB . . . . - * 16 GA b16g unpg b16c unpc A . A . - * 16 RGB sG sG sRGB sRGB g16 g16 . . - * 16 RGBA gb16 sGp cb16 sCp g16 g16' A . - * - * The matrix is held in an array indexed thus: - * - * gpc_fn[out_format & BASE_FORMATS][in_format & BASE_FORMATS]; - */ -/* This will produce a compile time error if the FORMAT_FLAG values don't - * match the above matrix! - */ -#if PNG_FORMAT_FLAG_ALPHA == 1 && PNG_FORMAT_FLAG_COLOR == 2 &&\ - PNG_FORMAT_FLAG_LINEAR == 4 -static void (* const gpc_fn[8/*in*/][8/*out*/]) - (Pixel *out, const Pixel *in, const Background *back) = -{ -/*out: G-8 GA-8 RGB-8 RGBA-8 G-16 GA-16 RGB-16 RGBA-16 */ - {gpc_noop,gpc_noop,gpc_noop,gpc_noop, gpc_Lin, gpc_Lin, gpc_Lin, gpc_Lin }, - {gpc_bckg,gpc_noop,gpc_bckc,gpc_noop, gpc_preq,gpc_pre, gpc_preq,gpc_pre }, - {gpc_g8, gpc_g8, gpc_noop,gpc_noop, gpc_glin,gpc_glin,gpc_lin, gpc_lin }, - {gpc_g8b, gpc_g8, gpc_bckc,gpc_noop, gpc_gprq,gpc_gpre,gpc_preq,gpc_pre }, - {gpc_sRGB,gpc_sRGB,gpc_sRGB,gpc_sRGB, gpc_noop,gpc_noop,gpc_noop,gpc_noop}, - {gpc_b16g,gpc_unpg,gpc_b16c,gpc_unpc, gpc_A, gpc_noop,gpc_A, gpc_noop}, - {gpc_sG, gpc_sG, gpc_sRGB,gpc_sRGB, gpc_g16, gpc_g16, gpc_noop,gpc_noop}, - {gpc_gb16,gpc_sGp, gpc_cb16,gpc_sCp, gpc_g16, gpc_g16q,gpc_A, gpc_noop} -}; + else + b->r8 = b->g8 = b->b8 = b->y8 = 255; + } + } -/* The array is repeated for the cases where both the input and output are color - * mapped because then different algorithms are used. - */ -static void (* const gpc_fn_colormapped[8/*in*/][8/*out*/]) - (Pixel *out, const Pixel *in, const Background *back) = -{ -/*out: G-8 GA-8 RGB-8 RGBA-8 G-16 GA-16 RGB-16 RGBA-16 */ - {gpc_noop,gpc_noop,gpc_noop,gpc_noop, gpc_lin, gpc_lin, gpc_lin, gpc_lin }, - {gpc_bckg,gpc_noop,gpc_bckc,gpc_noop, gpc_preq,gpc_pre, gpc_preq,gpc_pre }, - {gpc_g8, gpc_g8, gpc_noop,gpc_noop, gpc_glin,gpc_glin,gpc_lin, gpc_lin }, - {gpc_g8b, gpc_g8, gpc_bckc,gpc_noop, gpc_gprq,gpc_gpre,gpc_preq,gpc_pre }, - {gpc_sRGB,gpc_sRGB,gpc_sRGB,gpc_sRGB, gpc_noop,gpc_noop,gpc_noop,gpc_noop}, - {gpc_b16g,gpc_unpg,gpc_b16c,gpc_unpc, gpc_A, gpc_noop,gpc_A, gpc_noop}, - {gpc_sG, gpc_sG, gpc_sRGB,gpc_sRGB, gpc_g16, gpc_g16, gpc_noop,gpc_noop}, - {gpc_gb16,gpc_sGp, gpc_cb16,gpc_sCp, gpc_g16, gpc_g16q,gpc_A, gpc_noop} -}; + else if (a->format & PNG_FORMAT_FLAG_ALPHA) + { + png_uint_32 alpha; -/* The error arrays record the error in the same matrix; 64 entries, however - * the different algorithms used in libpng for colormap and direct conversions - * mean that four separate matrices are used (for each combination of - * colormapped and direct.) - * - * In some cases the conversion between sRGB formats goes via a linear - * intermediate; an sRGB to linear conversion (as above) is followed by a simple - * linear to sRGB step with no other conversions. This is done by a separate - * error array from an arbitrary 'in' format to one of the four basic outputs - * (since final output is always sRGB not colormapped). - * - * These arrays may be modified if the --accumulate flag is set during the run; - * then instead of logging errors they are simply added in. - * - * The three entries are currently for transparent, partially transparent and - * opaque input pixel values. Notice that alpha should be exact in each case. - * - * Errors in alpha should only occur when converting from a direct format - * to a colormapped format, when alpha is effectively smashed (so large - * errors can occur.) There should be no error in the '0' and 'opaque' - * values. The fourth entry in the array is used for the alpha error (and it - * should always be zero for the 'via linear' case since this is never color - * mapped.) - * - * Mapping to a colormap smashes the colors, it is necessary to have separate - * values for these cases because they are much larger; it is very much - * impossible to obtain a reasonable result, these are held in - * gpc_error_to_colormap. - */ -#if PNG_FORMAT_FLAG_COLORMAP == 8 /* extra check also required */ -/* START MACHINE GENERATED */ -static png_uint_16 gpc_error[16/*in*/][16/*out*/][4/*a*/] = -{ - { /* input: sRGB-gray */ - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 372, 0 }, { 0, 0, 372, 0 }, { 0, 0, 372, 0 }, { 0, 0, 372, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } - }, { /* input: sRGB-gray+alpha */ - { 0, 18, 0, 0 }, { 0, 0, 0, 0 }, { 0, 20, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 897, 788, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } - }, { /* input: sRGB-rgb */ - { 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 893, 0 }, { 0, 0, 893, 0 }, { 0, 0, 811, 0 }, { 0, 0, 811, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } - }, { /* input: sRGB-rgb+alpha */ - { 0, 4, 13, 0 }, { 0, 14, 13, 0 }, { 0, 19, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 832, 764, 0 }, { 0, 832, 764, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } - }, { /* input: linear-gray */ - { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } - }, { /* input: linear-gray+alpha */ - { 0, 74, 9, 0 }, { 0, 20, 9, 0 }, { 0, 74, 9, 0 }, { 0, 20, 9, 0 }, - { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } - }, { /* input: linear-rgb */ - { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, - { 0, 0, 4, 0 }, { 0, 0, 4, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } - }, { /* input: linear-rgb+alpha */ - { 0, 126, 143, 0 }, { 0, 9, 7, 0 }, { 0, 74, 9, 0 }, { 0, 16, 9, 0 }, - { 0, 4, 4, 0 }, { 0, 5, 4, 0 }, { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } - }, { /* input: color-mapped-sRGB-gray */ - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } - }, { /* input: color-mapped-sRGB-gray+alpha */ - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } - }, { /* input: color-mapped-sRGB-rgb */ - { 0, 0, 13, 0 }, { 0, 0, 13, 0 }, { 0, 0, 8, 0 }, { 0, 0, 8, 0 }, - { 0, 0, 673, 0 }, { 0, 0, 673, 0 }, { 0, 0, 674, 0 }, { 0, 0, 674, 0 }, - { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 460, 0 }, { 0, 0, 460, 0 }, { 0, 0, 263, 0 }, { 0, 0, 263, 0 } - }, { /* input: color-mapped-sRGB-rgb+alpha */ - { 0, 6, 8, 0 }, { 0, 7, 8, 0 }, { 0, 75, 8, 0 }, { 0, 9, 8, 0 }, - { 0, 585, 427, 0 }, { 0, 585, 427, 0 }, { 0, 717, 409, 0 }, { 0, 717, 409, 0 }, - { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 13323, 460, 0 }, { 0, 334, 460, 0 }, { 0, 16480, 263, 0 }, { 0, 243, 263, 0 } - }, { /* input: color-mapped-linear-gray */ - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 282, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } - }, { /* input: color-mapped-linear-gray+alpha */ - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 253, 282, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } - }, { /* input: color-mapped-linear-rgb */ - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 265, 0 }, { 0, 0, 0, 0 } - }, { /* input: color-mapped-linear-rgb+alpha */ - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 243, 265, 0 } - } -}; -static png_uint_16 gpc_error_via_linear[16][4/*out*/][4] = -{ - { /* input: sRGB-gray */ - { 0, 0, 7, 0 }, { 0, 0, 7, 0 }, { 0, 0, 7, 0 }, { 0, 0, 7, 0 } - }, { /* input: sRGB-gray+alpha */ - { 0, 15, 15, 0 }, { 0, 186, 15, 0 }, { 0, 15, 15, 0 }, { 0, 186, 15, 0 } - }, { /* input: sRGB-rgb */ - { 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 15, 0 }, { 0, 0, 15, 0 } - }, { /* input: sRGB-rgb+alpha */ - { 0, 12, 14, 0 }, { 0, 180, 14, 0 }, { 0, 14, 15, 0 }, { 0, 186, 15, 0 } - }, { /* input: linear-gray */ - { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 } - }, { /* input: linear-gray+alpha */ - { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 } - }, { /* input: linear-rgb */ - { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 } - }, { /* input: linear-rgb+alpha */ - { 0, 1, 1, 0 }, { 0, 8, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 } - }, { /* input: color-mapped-sRGB-gray */ - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } - }, { /* input: color-mapped-sRGB-gray+alpha */ - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } - }, { /* input: color-mapped-sRGB-rgb */ - { 0, 0, 13, 0 }, { 0, 0, 13, 0 }, { 0, 0, 14, 0 }, { 0, 0, 14, 0 } - }, { /* input: color-mapped-sRGB-rgb+alpha */ - { 0, 4, 8, 0 }, { 0, 9, 8, 0 }, { 0, 8, 3, 0 }, { 0, 32, 3, 0 } - }, { /* input: color-mapped-linear-gray */ - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } - }, { /* input: color-mapped-linear-gray+alpha */ - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } - }, { /* input: color-mapped-linear-rgb */ - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } - }, { /* input: color-mapped-linear-rgb+alpha */ - { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } - } -}; -static png_uint_16 gpc_error_to_colormap[8/*i*/][8/*o*/][4] = -{ - { /* input: sRGB-gray */ - { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, - { 0, 0, 560, 0 }, { 0, 0, 560, 0 }, { 0, 0, 560, 0 }, { 0, 0, 560, 0 } - }, { /* input: sRGB-gray+alpha */ - { 0, 19, 2, 0 }, { 0, 255, 2, 25 }, { 0, 88, 2, 0 }, { 0, 255, 2, 25 }, - { 0, 1012, 745, 0 }, { 0, 16026, 745, 6425 }, { 0, 1012, 745, 0 }, { 0, 16026, 745, 6425 } - }, { /* input: sRGB-rgb */ - { 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 25, 0 }, { 0, 0, 25, 0 }, - { 0, 0, 937, 0 }, { 0, 0, 937, 0 }, { 0, 0, 13677, 0 }, { 0, 0, 13677, 0 } - }, { /* input: sRGB-rgb+alpha */ - { 0, 63, 77, 0 }, { 0, 255, 19, 25 }, { 0, 220, 25, 0 }, { 0, 255, 25, 67 }, - { 0, 17534, 18491, 0 }, { 0, 15614, 2824, 6425 }, { 0, 14019, 13677, 0 }, { 0, 48573, 13677, 17219 } - }, { /* input: linear-gray */ - { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, - { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 } - }, { /* input: linear-gray+alpha */ - { 0, 74, 74, 0 }, { 0, 255, 74, 25 }, { 0, 97, 74, 0 }, { 0, 255, 74, 25 }, - { 0, 18919, 18907, 0 }, { 0, 24549, 18907, 6552 }, { 0, 18919, 18907, 0 }, { 0, 24549, 18907, 6552 } - }, { /* input: linear-rgb */ - { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 98, 0 }, { 0, 0, 98, 0 }, - { 0, 0, 18664, 0 }, { 0, 0, 18664, 0 }, { 0, 0, 24998, 0 }, { 0, 0, 24998, 0 } - }, { /* input: linear-rgb+alpha */ - { 0, 181, 196, 0 }, { 0, 255, 61, 25 }, { 206, 187, 98, 0 }, { 0, 255, 98, 67 }, - { 0, 18141, 18137, 0 }, { 0, 17494, 17504, 6553 }, { 0, 24979, 24992, 0 }, { 0, 46509, 24992, 17347 } - } -}; -/* END MACHINE GENERATED */ -#endif /* COLORMAP flag check */ -#endif /* flag checks */ + /* An alpha channel has been removed; the background will have been + * composed in. Adjust the 'a' pixel to represent this by doing the + * correct compose. Set the error limit, above, to an appropriate + * value for the compose operation. + */ + if (error_limit < error_in_compose) + error_limit = error_in_compose; -typedef struct -{ - /* Basic pixel information: */ - Image* in_image; /* Input image */ - const Image* out_image; /* Output image */ + alpha = 65535 - a->a16; /* for the background */ - /* 'background' is the value passed to the gpc_ routines, it may be NULL if - * it should not be used (*this* program has an error if it crashes as a - * result!) - */ - Background background_color; - const Background* background; + if (b->format & PNG_FORMAT_FLAG_COLOR) /* background is rgb */ + { + err = "8-bit color compose error"; - /* Precalculated values: */ - int in_opaque; /* Value of input alpha that is opaque */ - int is_palette; /* Sample values come from the palette */ - int accumulate; /* Accumlate component errors (don't log) */ - int output_8bit; /* Output is 8 bit (else 16 bit) */ + if (via_linear) + { + /* The 16-bit values are already correct (being pre-multiplied), + * just recalculate the 8-bit values. + */ + a->r8 = isRGB(a->r16); + a->g8 = isRGB(a->g16); + a->b8 = isRGB(a->b16); + a->y8 = isRGB(a->y16); - void (*in_gp)(Pixel*, png_const_voidp); - void (*out_gp)(Pixel*, png_const_voidp); + /* There should be no libpng error in this (ideally) */ + error_limit = 0; + } - void (*transform)(Pixel *out, const Pixel *in, const Background *back); - /* A function to perform the required transform */ + else if (background == NULL) + { + double add = alpha * linear_from_sRGB(BUFFER_INIT8/255.); + double r, g, blue, y; - void (*from_linear)(Pixel *out, const Pixel *in, const Background *back); - /* For 'via_linear' transforms the final, from linear, step, else NULL */ + r = a->r16 + add; + a->r16 = u16d(r); + a->r8 = sRGB(r/65535); - png_uint_16 error[4]; - /* Three error values for transparent, partially transparent and opaque - * input pixels (in turn). - */ + g = a->g16 + add; + a->g16 = u16d(g); + a->g8 = sRGB(g/65535); - png_uint_16 *error_ptr; - /* Where these are stored in the static array (for 'accumulate') */ -} -Transform; + blue = a->b16 + add; + a->b16 = u16d(blue); + a->b8 = sRGB(blue/65535); -/* Return a 'transform' as above for the given format conversion. */ -static void -transform_from_formats(Transform *result, Image *in_image, - const Image *out_image, png_const_colorp background, int via_linear) -{ - png_uint_32 in_format, out_format; - png_uint_32 in_base, out_base; + y = YfromRGB(r, g, blue); + a->y16 = u16d(y); + a->y8 = sRGB(y/65535); + } - memset(result, 0, sizeof *result); + else + { + double r, g, blue, y; - /* Store the original images for error messages */ - result->in_image = in_image; - result->out_image = out_image; + r = a->r16 + alpha * linear_from_sRGB(background->red/255.); + a->r16 = u16d(r); + a->r8 = sRGB(r/65535); - in_format = in_image->image.format; - out_format = out_image->image.format; + g = a->g16 + alpha * linear_from_sRGB(background->green/255.); + a->g16 = u16d(g); + a->g8 = sRGB(g/65535); - if (in_format & PNG_FORMAT_FLAG_LINEAR) - result->in_opaque = 65535; - else - result->in_opaque = 255; + blue = a->b16 + alpha * linear_from_sRGB(background->blue/255.); + a->b16 = u16d(blue); + a->b8 = sRGB(blue/65535); - result->output_8bit = (out_format & PNG_FORMAT_FLAG_LINEAR) == 0; + y = YfromRGB(r, g, blue); + a->y16 = u16d(y * 65535); + a->y8 = sRGB(y); + } + } - result->is_palette = 0; /* set by caller if required */ - result->accumulate = (in_image->opts & ACCUMULATE) != 0; + else /* background is gray */ + { + err = "8-bit gray compose error"; - /* The loaders (which need the ordering information) */ - result->in_gp = get_pixel(in_format); - result->out_gp = get_pixel(out_format); + if (via_linear) + { + a->r8 = a->g8 = a->b8 = a->y8 = isRGB(a->y16); + error_limit = 0; + } - /* Remove the ordering information: */ - in_format &= BASE_FORMATS | PNG_FORMAT_FLAG_COLORMAP; - in_base = in_format & BASE_FORMATS; - out_format &= BASE_FORMATS | PNG_FORMAT_FLAG_COLORMAP; - out_base = out_format & BASE_FORMATS; + else + { + /* When the output is gray the background comes from just the + * green channel. + */ + double y = a->y16 + alpha * linear_from_sRGB( + (background == NULL ? BUFFER_INIT8 : background->green)/255.); - if (via_linear) - { - /* Check for an error in this program: */ - if (out_format & (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLORMAP)) - { - fprintf(stderr, "internal transform via linear error 0x%x->0x%x\n", - in_format, out_format); - exit(1); + a->r16 = a->g16 = a->b16 = a->y16 = u16d(y); + a->r8 = a->g8 = a->b8 = a->y8 = sRGB(y/65535); + } + } } - result->transform = gpc_fn[in_base][out_base | PNG_FORMAT_FLAG_LINEAR]; - result->from_linear = gpc_fn[out_base | PNG_FORMAT_FLAG_LINEAR][out_base]; - result->error_ptr = gpc_error_via_linear[in_format][out_format]; - } - - else if (~in_format & out_format & PNG_FORMAT_FLAG_COLORMAP) - { - /* The input is not colormapped but the output is, the errors will - * typically be large (only the grayscale-no-alpha case permits preserving - * even 8-bit values.) - */ - result->transform = gpc_fn[in_base][out_base]; - result->from_linear = NULL; - result->error_ptr = gpc_error_to_colormap[in_base][out_base]; - } - - else - { - /* The caller handles the colormap->pixel value conversion, so the - * transform function just gets a pixel value, however because libpng - * currently contains a different implementation for mapping a colormap if - * both input and output are colormapped we need different conversion - * functions to deal with errors in the libpng implementation. - */ - if (in_format & out_format & PNG_FORMAT_FLAG_COLORMAP) - result->transform = gpc_fn_colormapped[in_base][out_base]; - else - result->transform = gpc_fn[in_base][out_base]; - result->from_linear = NULL; - result->error_ptr = gpc_error[in_format][out_format]; - } - - /* Follow the libpng simplified API rules to work out what to pass to the gpc - * routines as a background value, if one is not required pass NULL so that - * this program crashes in the even of a programming error. - */ - result->background = NULL; /* default: not required */ + if (b->format & PNG_FORMAT_FLAG_COLOR) + { - /* Rule 1: background only need be supplied if alpha is to be removed */ - if (in_format & ~out_format & PNG_FORMAT_FLAG_ALPHA) - { - /* The input value is 'NULL' to use the background and (otherwise) an sRGB - * background color (to use a solid color). The code above uses a fixed - * byte value, BUFFER_INIT8, for buffer even for 16-bit output. For - * linear (16-bit) output the sRGB background color is ignored; the - * composition is always on the background (so BUFFER_INIT8 * 257), except - * that for the colormap (i.e. linear colormapped output) black is used. - */ - result->background = &result->background_color; + /* Check for an exact match. */ + if (a->r8 == b->r8 && a->g8 == b->g8 && a->b8 == b->b8) + return NULL; - if (out_format & PNG_FORMAT_FLAG_LINEAR || via_linear) - { - if (out_format & PNG_FORMAT_FLAG_COLORMAP) + /* Check for linear to 8-bit conversion. */ + if (a->format & PNG_FORMAT_FLAG_LINEAR) { - result->background_color.ir = - result->background_color.ig = - result->background_color.ib = 0; - result->background_color.dr = - result->background_color.dg = - result->background_color.db = 0; + if (error_limit < error_to_sRGB) + { + err = "linear to sRGB conversion error"; + error_limit = error_to_sRGB; + } } - else - { - result->background_color.ir = - result->background_color.ig = - result->background_color.ib = BUFFER_INIT8 * 257; - result->background_color.dr = - result->background_color.dg = - result->background_color.db = 0; - } + if (abs(a->r8-b->r8) <= error_limit && + abs(a->g8-b->g8) <= error_limit && + abs(a->b8-b->b8) <= error_limit) + return NULL; + + return err; } - else /* sRGB output */ + else /* b is grayscale */ { - if (background != NULL) + /* Check for an exact match. */ + if (a->y8 == b->y8) + return NULL; + + /* Not an exact match; allow drift only if the input is linear or if it + * has been converted from color. + */ + if (a->format & PNG_FORMAT_FLAG_LINEAR) { - if (out_format & PNG_FORMAT_FLAG_COLOR) + /* Converted to linear, check for that drift. */ + if (error_limit < error_to_sRGB) { - result->background_color.ir = background->red; - result->background_color.ig = background->green; - result->background_color.ib = background->blue; - /* TODO: sometimes libpng uses the power law conversion here, how - * to handle this? - */ - result->background_color.dr = sRGB_to_d[background->red]; - result->background_color.dg = sRGB_to_d[background->green]; - result->background_color.db = sRGB_to_d[background->blue]; + error_limit = error_to_sRGB; + err = "linear to 8-bit gray conversion error"; } + } - else /* grayscale: libpng only looks at 'g' */ + if (a->format & PNG_FORMAT_FLAG_COLOR) + { + /* Converted to grayscale, allow drift */ + if (error_limit < error_to_sRGB_grayscale) { - result->background_color.ir = - result->background_color.ig = - result->background_color.ib = background->green; - /* TODO: sometimes libpng uses the power law conversion here, how - * to handle this? - */ - result->background_color.dr = - result->background_color.dg = - result->background_color.db = sRGB_to_d[background->green]; + error_limit = error_to_sRGB_grayscale; + err = "color to 8-bit gray conversion error"; } } - else if ((out_format & PNG_FORMAT_FLAG_COLORMAP) == 0) - { - result->background_color.ir = - result->background_color.ig = - result->background_color.ib = BUFFER_INIT8; - /* TODO: sometimes libpng uses the power law conversion here, how - * to handle this? - */ - result->background_color.dr = - result->background_color.dg = - result->background_color.db = sRGB_to_d[BUFFER_INIT8]; - } + if (abs(a->y8-b->y8) <= error_limit) + return NULL; - /* Else the output is colormapped and a background color must be - * provided; if pngstest crashes then that is a bug in this program - * (though libpng should png_error as well.) - */ - else - result->background = NULL; + return err; } } - - if (result->background == NULL) - { - result->background_color.ir = - result->background_color.ig = - result->background_color.ib = -1; /* not used */ - result->background_color.dr = - result->background_color.dg = - result->background_color.db = 1E30; /* not used */ - } - - - /* Copy the error values into the Transform: */ - result->error[0] = result->error_ptr[0]; - result->error[1] = result->error_ptr[1]; - result->error[2] = result->error_ptr[2]; - result->error[3] = result->error_ptr[3]; } - -/* Compare two pixels. - * - * OLD error values: -static int error_to_linear = 811; * by experiment * -static int error_to_linear_grayscale = 424; * by experiment * -static int error_to_sRGB = 6; * by experiment * -static int error_to_sRGB_grayscale = 17; * libpng error by calculation + - 2 by experiment * -static int error_in_compose = 2; * by experiment * -static int error_in_premultiply = 1; - * - * The following is *just* the result of a round trip from 8-bit sRGB to linear - * then back to 8-bit sRGB when it is done by libpng. There are two problems: - * - * 1) libpng currently uses a 2.2 power law with no linear segment, this results - * in instability in the low values and even with 16-bit precision sRGB(1) ends - * up mapping to sRGB(0) as a result of rounding in the 16-bit representation. - * This gives an error of 1 in the handling of value 1 only. - * - * 2) libpng currently uses an intermediate 8-bit linear value in gamma - * correction of 8-bit values. This results in many more errors, the worse of - * which is mapping sRGB(14) to sRGB(0). - * - * The general 'error_via_linear' is more complex because of pre-multiplication, - * this compounds the 8-bit errors according to the alpha value of the pixel. - * As a result 256 values are pre-calculated for error_via_linear. - */ -#if 0 -static int error_in_libpng_gamma; -static int error_via_linear[256]; /* Indexed by 8-bit alpha */ - -static void -init_error_via_linear(void) -{ - int alpha; - - error_via_linear[0] = 255; /* transparent pixel */ - - for (alpha=1; alpha<=255; ++alpha) - { - /* 16-bit values less than 128.5 get rounded to 8-bit 0 and so the worst - * case error arises with 16-bit 128.5, work out what sRGB - * (non-associated) value generates 128.5; any value less than this is - * going to map to 0, so the worst error is floor(value). - * - * Note that errors are considerably higher (more than a factor of 2) - * because libpng uses a simple power law for sRGB data at present. - * - * Add .1 for arithmetic errors inside libpng. - */ - double v = floor(255*pow(.5/*(128.5 * 255 / 65535)*/ / alpha, 1/2.2)+.1); - - error_via_linear[alpha] = (int)v; - } - - /* This is actually 14.99, but, despite the closeness to 15, 14 seems to work - * ok in this case. - */ - error_in_libpng_gamma = 14; -} -#endif +/* Basic image formats; control the data but not the layout thereof. */ +#define BASE_FORMATS\ + (PNG_FORMAT_FLAG_ALPHA|PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_LINEAR) static void -print_pixel(char string[64], const Pixel *pixel, png_uint_32 format) +print_pixel(char string[64], Pixel *pixel) { - switch (format & (PNG_FORMAT_FLAG_ALPHA|PNG_FORMAT_FLAG_COLOR)) + switch (pixel->format & BASE_FORMATS) { - case 0: - sprintf(string, "%s(%d)", format_names[format], pixel->g); + case 0: /* 8-bit, one channel */ + sprintf(string, "%s(%d)", format_names[pixel->format], pixel->y8); break; case PNG_FORMAT_FLAG_ALPHA: - sprintf(string, "%s(%d,%d)", format_names[format], pixel->g, - pixel->a); + sprintf(string, "%s(%d,%d)", format_names[pixel->format], pixel->y8, + pixel->a8); break; case PNG_FORMAT_FLAG_COLOR: - sprintf(string, "%s(%d,%d,%d)", format_names[format], - pixel->r, pixel->g, pixel->b); + sprintf(string, "%s(%d,%d,%d)", format_names[pixel->format], + pixel->r8, pixel->g8, pixel->b8); break; case PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA: - sprintf(string, "%s(%d,%d,%d,%d)", format_names[format], - pixel->r, pixel->g, pixel->b, pixel->a); + sprintf(string, "%s(%d,%d,%d,%d)", format_names[pixel->format], + pixel->r8, pixel->g8, pixel->b8, pixel->a8); break; - default: - sprintf(string, "invalid-format"); + case PNG_FORMAT_FLAG_LINEAR: + sprintf(string, "%s(%d)", format_names[pixel->format], pixel->y16); break; - } -} - -static int -logpixel(const Transform *transform, png_uint_32 x, png_uint_32 y, - const Pixel *in, const Pixel *calc, const Pixel *out, const char *reason) -{ - const png_uint_32 in_format = transform->in_image->image.format; - const png_uint_32 out_format = transform->out_image->image.format; - - png_uint_32 back_format = out_format & ~PNG_FORMAT_FLAG_ALPHA; - const char *via_linear = ""; - - char pixel_in[64], pixel_calc[64], pixel_out[64], pixel_loc[64]; - char background_info[100]; - - print_pixel(pixel_in, in, in_format); - print_pixel(pixel_calc, calc, out_format); - print_pixel(pixel_out, out, out_format); - - if (transform->is_palette) - sprintf(pixel_loc, "palette: %lu", (unsigned long)y); - else - sprintf(pixel_loc, "%lu,%lu", (unsigned long)x, (unsigned long)y); - - if (transform->from_linear != NULL) - { - via_linear = " (via linear)"; - /* And as a result the *read* format which did any background processing - * was itself linear, so the background color information is also - * linear. - */ - back_format |= PNG_FORMAT_FLAG_LINEAR; - } - if (transform->background != NULL) - { - Pixel back; - char pixel_back[64]; - - back.r = transform->background->ir; - back.g = transform->background->ig; - back.b = transform->background->ib; - back.a = -1; /* not used */ - - print_pixel(pixel_back, &back, back_format); - sprintf(background_info, " on background %s", pixel_back); - } + case PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_ALPHA: + sprintf(string, "%s(%d,%d)", format_names[pixel->format], pixel->y16, + pixel->a16); + break; - else - background_info[0] = 0; + case PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR: + sprintf(string, "%s(%d,%d,%d)", format_names[pixel->format], + pixel->r16, pixel->g16, pixel->b16); + break; - if (transform->in_image->file_name != transform->out_image->file_name) - { - char error_buffer[512]; - sprintf(error_buffer, - "(%s) %s error%s:\n %s%s ->\n %s\n not: %s.\n" - "Use --preserve and examine: ", pixel_loc, reason, via_linear, - pixel_in, background_info, pixel_out, pixel_calc); - return logerror(transform->in_image, transform->in_image->file_name, - error_buffer, transform->out_image->file_name); - } + case PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA: + sprintf(string, "%s(%d,%d,%d,%d)", format_names[pixel->format], + pixel->r16, pixel->g16, pixel->b16, pixel->a16); + break; - else - { - char error_buffer[512]; - sprintf(error_buffer, - "(%s) %s error%s:\n %s%s ->\n %s\n not: %s.\n" - " The error happened when reading the original file with this format.", - pixel_loc, reason, via_linear, pixel_in, background_info, pixel_out, - pixel_calc); - return logerror(transform->in_image, transform->in_image->file_name, - error_buffer, ""); + default: + sprintf(string, "invalid-format"); + break; } } static int -cmppixel(Transform *transform, png_const_voidp in, png_const_voidp out, - png_uint_32 x, png_uint_32 y/*or palette index*/) +logpixel(Image *image, png_uint_32 x, png_uint_32 y, Pixel *a, Pixel *b, + const char *reason) { - int maxerr; - png_const_charp errmsg; - Pixel pixel_in, pixel_calc, pixel_out; - - transform->in_gp(&pixel_in, in); - - if (transform->from_linear == NULL) - transform->transform(&pixel_calc, &pixel_in, transform->background); - - else - { - transform->transform(&pixel_out, &pixel_in, transform->background); - transform->from_linear(&pixel_calc, &pixel_out, NULL); - } - - transform->out_gp(&pixel_out, out); - - /* Eliminate the case where the input and output values match exactly. */ - if (pixel_calc.a == pixel_out.a && pixel_calc.r == pixel_out.r && - pixel_calc.g == pixel_out.g && pixel_calc.b == pixel_out.b) - return 1; - - /* Eliminate the case where the output pixel is transparent and the output - * is 8-bit - any component values are valid. Don't check the input alpha - * here to also skip the 16-bit small alpha cases. - */ - if (transform->output_8bit && pixel_calc.a == 0 && pixel_out.a == 0) - return 1; - - /* Check for alpha errors first; an alpha error can damage the components too - * so avoid spurious checks on components if one is found. - */ - errmsg = NULL; - { - int err_a = abs(pixel_calc.a-pixel_out.a); - - if (err_a > transform->error[3]) - { - /* If accumulating check the components too */ - if (transform->accumulate) - transform->error[3] = (png_uint_16)err_a; - - else - errmsg = "alpha"; - } - } + char pixel_a[64], pixel_b[64]; + char error_buffer[256]; - /* Now if *either* of the output alphas are 0 but alpha is within tolerance - * eliminate the 8-bit component comparison. - */ - if (errmsg == NULL && transform->output_8bit && - (pixel_calc.a == 0 || pixel_out.a == 0)) - return 1; - - if (errmsg == NULL) /* else just signal an alpha error */ - { - int err_r = abs(pixel_calc.r - pixel_out.r); - int err_g = abs(pixel_calc.g - pixel_out.g); - int err_b = abs(pixel_calc.b - pixel_out.b); - int limit; - - if ((err_r | err_g | err_b) == 0) - return 1; /* exact match */ - - /* Mismatch on a component, check the input alpha */ - if (pixel_in.a >= transform->in_opaque) - { - errmsg = "opaque component"; - limit = 2; /* opaque */ - } - - else if (pixel_in.a > 0) - { - errmsg = "alpha component"; - limit = 1; /* partially transparent */ - } - - else - { - errmsg = "transparent component (background)"; - limit = 0; /* transparent */ - } - - maxerr = err_r; - if (maxerr < err_g) maxerr = err_g; - if (maxerr < err_b) maxerr = err_b; - - if (maxerr <= transform->error[limit]) - return 1; /* within the error limits */ - - /* Handle a component mis-match; log it, just return an error code, or - * accumulate it. - */ - if (transform->accumulate) - { - transform->error[limit] = (png_uint_16)maxerr; - return 1; /* to cause the caller to keep going */ - } - } - - /* Failure to match and not accumulating, so the error must be logged. */ - return logpixel(transform, x, y, &pixel_in, &pixel_calc, &pixel_out, errmsg); -} - -static png_byte -component_loc(png_byte loc[4], png_uint_32 format) -{ - /* Given a format return the number of channels and the location of - * each channel. - * - * The mask 'loc' contains the component offset of the channels in the - * following order. Note that if 'format' is grayscale the entries 1-3 must - * all contain the location of the gray channel. - * - * 0: alpha - * 1: red or gray - * 2: green or gray - * 3: blue or gray - */ - png_byte channels; - - if (format & PNG_FORMAT_FLAG_COLOR) - { - channels = 3; - - loc[2] = 1; - - if (format & PNG_FORMAT_FLAG_BGR) - { - loc[1] = 2; - loc[3] = 0; - } - - else - { - loc[1] = 0; - loc[3] = 2; - } - } - - else - { - channels = 1; - loc[1] = loc[2] = loc[3] = 0; - } - - if (format & PNG_FORMAT_FLAG_ALPHA) - { - if (format & PNG_FORMAT_FLAG_AFIRST) - { - loc[0] = 0; - ++loc[1]; - ++loc[2]; - ++loc[3]; - } - - else - loc[0] = channels; - - ++channels; - } - - else - loc[0] = 4; /* not present */ - - return channels; + print_pixel(pixel_a, a); + print_pixel(pixel_b, b); + sprintf(error_buffer, "(%lu,%lu) %s: %s -> %s", (unsigned long)x, + (unsigned long)y, reason, pixel_a, pixel_b); + return logerror(image, image->file_name, error_buffer, ""); } /* Compare two images, the original 'a', which was written out then read back in * to * give image 'b'. The formats may have been changed. */ static int -compare_two_images(Image *a, Image *b, int via_linear, - png_const_colorp background) +compare_two_images(Image *a, Image *b, int via_linear) { + png_uint_32 width = a->image.width; + png_uint_32 height = a->image.height; + png_uint_32 formata = a->image.format; + png_uint_32 formatb = b->image.format; ptrdiff_t stridea = a->stride; ptrdiff_t strideb = b->stride; png_const_bytep rowa = a->buffer+16; png_const_bytep rowb = b->buffer+16; - const png_uint_32 width = a->image.width; - const png_uint_32 height = a->image.height; - const png_uint_32 formata = a->image.format; - const png_uint_32 formatb = b->image.format; - const unsigned int a_sample = PNG_IMAGE_SAMPLE_SIZE(formata); - const unsigned int b_sample = PNG_IMAGE_SAMPLE_SIZE(formatb); - int alpha_added, alpha_removed; - int bchannels; - int btoa[4]; - png_uint_32 y; - Transform tr; + png_byte channels; + int linear = 0; + int result = 1; + unsigned int check_alpha = 0; /* must be zero or one */ + png_byte swap_mask[4]; + png_uint_32 x, y; + png_const_bytep ppa, ppb; + const png_color *background = + ((a->opts & USE_BACKGROUND) ? &a->background : NULL); /* This should never happen: */ if (width != b->image.width || height != b->image.height) return logerror(a, a->file_name, ": width x height changed: ", b->file_name); - /* Set up the background and the transform */ - transform_from_formats(&tr, a, b, background, via_linear); - /* Find the first row and inter-row space. */ - if (!(formata & PNG_FORMAT_FLAG_COLORMAP) && - (formata & PNG_FORMAT_FLAG_LINEAR)) - stridea *= 2; + if (formata & PNG_FORMAT_FLAG_LINEAR) + { + stridea *= sizeof (png_uint_16); + ++linear; + } - if (!(formatb & PNG_FORMAT_FLAG_COLORMAP) && - (formatb & PNG_FORMAT_FLAG_LINEAR)) - strideb *= 2; + if (formatb & PNG_FORMAT_FLAG_LINEAR) + { + strideb *= sizeof (png_uint_16); + ++linear; + } if (stridea < 0) rowa += (height-1) * (-stridea); if (strideb < 0) rowb += (height-1) * (-strideb); - /* First shortcut the two colormap case by comparing the image data; if it - * matches then we expect the colormaps to match, although this is not - * absolutely necessary for an image match. If the colormaps fail to match - * then there is a problem in libpng. + /* The following are used only if the formats match, except that 'channels' + * is a flag for matching formats. */ - if (formata & formatb & PNG_FORMAT_FLAG_COLORMAP) - { - /* Only check colormap entries that actually exist; */ - png_const_bytep ppa, ppb; - int match; - png_byte in_use[256], amax = 0, bmax = 0; - - memset(in_use, 0, sizeof in_use); - - ppa = rowa; - ppb = rowb; + channels = 0; + swap_mask[3] = swap_mask[2] = swap_mask[1] = swap_mask[0] = 0; - /* Do this the slow way to accumulate the 'in_use' flags, don't break out - * of the loop until the end; this validates the color-mapped data to - * ensure all pixels are valid color-map indexes. - */ - for (y=0, match=1; y<height && match; ++y, ppa += stridea, ppb += strideb) - { - png_uint_32 x; - - for (x=0; x<width; ++x) - { - png_byte bval = ppb[x]; - png_byte aval = ppa[x]; - - if (bval > bmax) - bmax = bval; - - if (bval != aval) - match = 0; + /* Set up the masks if no base format change, or if the format change was + * just to add an alpha channel. + */ + if (((formata | PNG_FORMAT_FLAG_ALPHA) & BASE_FORMATS) == + (formatb & BASE_FORMATS)) + { + png_byte astart = 0; /* index of first component */ + png_byte bstart = 0; - in_use[aval] = 1; - if (aval > amax) - amax = aval; - } - } + /* Set to the actual number of channels in 'a' */ + channels = (formata & PNG_FORMAT_FLAG_COLOR) ? 3 : 1; - /* If the buffers match then the colormaps must too. */ - if (match) + if (formata & PNG_FORMAT_FLAG_ALPHA) { - /* Do the color-maps match, entry by entry? Only check the 'in_use' - * entries. An error here should be logged as a color-map error. - */ - png_const_bytep a_cmap = (png_const_bytep)a->colormap; - png_const_bytep b_cmap = (png_const_bytep)b->colormap; - int result = 1; /* match by default */ - - /* This is used in logpixel to get the error message correct. */ - tr.is_palette = 1; - - for (y=0; y<256; ++y, a_cmap += a_sample, b_cmap += b_sample) - if (in_use[y]) + /* Both formats have an alpha channel */ + if (formata & PNG_FORMAT_FLAG_AFIRST) { - /* The colormap entries should be valid, but because libpng doesn't - * do any checking at present the original image may contain invalid - * pixel values. These cause an error here (at present) unless - * accumulating errors in which case the program just ignores them. - */ - if (y >= a->image.colormap_entries) - { - if ((a->opts & ACCUMULATE) == 0) - { - char pindex[9]; - sprintf(pindex, "%lu[%lu]", (unsigned long)y, - (unsigned long)a->image.colormap_entries); - logerror(a, a->file_name, ": bad pixel index: ", pindex); - } - result = 0; - } + astart = 1; - else if (y >= b->image.colormap_entries) + if (formatb & PNG_FORMAT_FLAG_AFIRST) { - if ((a->opts & ACCUMULATE) == 0) - { - char pindex[9]; - sprintf(pindex, "%lu[%lu]", (unsigned long)y, - (unsigned long)b->image.colormap_entries); - logerror(b, b->file_name, ": bad pixel index: ", pindex); - } - result = 0; + bstart = 1; + swap_mask[0] = 0; } - /* All the mismatches are logged here; there can only be 256! */ - else if (!cmppixel(&tr, a_cmap, b_cmap, 0, y)) - result = 0; + else + swap_mask[0] = channels; /* 'b' alpha is at end */ } - /* If reqested copy the error values back from the Transform. */ - if (a->opts & ACCUMULATE) + else if (formatb & PNG_FORMAT_FLAG_AFIRST) { - tr.error_ptr[0] = tr.error[0]; - tr.error_ptr[1] = tr.error[1]; - tr.error_ptr[2] = tr.error[2]; - tr.error_ptr[3] = tr.error[3]; - result = 1; /* force a continue */ + /* 'a' alpha is at end, 'b' is at start (0) */ + bstart = 1; + swap_mask[channels] = 0; } - return result; + else + swap_mask[channels] = channels; + + ++channels; } - /* else the image buffers don't match pixel-wise so compare sample values - * instead, but first validate that the pixel indexes are in range (but - * only if not accumulating, when the error is ignored.) - */ - else if ((a->opts & ACCUMULATE) == 0) + else if (formatb & PNG_FORMAT_FLAG_ALPHA) { - /* Check the original image first, - * TODO: deal with input images with bad pixel values? - */ - if (amax >= a->image.colormap_entries) + /* Only 'b' has an alpha channel */ + check_alpha = 1; + if (formatb & PNG_FORMAT_FLAG_AFIRST) { - char pindex[9]; - sprintf(pindex, "%d[%lu]", amax, - (unsigned long)a->image.colormap_entries); - return logerror(a, a->file_name, ": bad pixel index: ", pindex); + bstart = 1; + /* Put the location of the alpha channel in swap_mask[3], since it + * cannot be used if 'a' does not have an alpha channel. + */ + swap_mask[3] = 0; } - else if (bmax >= b->image.colormap_entries) - { - char pindex[9]; - sprintf(pindex, "%d[%lu]", bmax, - (unsigned long)b->image.colormap_entries); - return logerror(b, b->file_name, ": bad pixel index: ", pindex); - } + else + swap_mask[3] = channels; } - } - - /* We can directly compare pixel values without the need to use the read - * or transform support (i.e. a memory compare) if: - * - * 1) The bit depth has not changed. - * 2) RGB to grayscale has not been done (the reverse is ok; we just compare - * the three RGB values to the original grayscale.) - * 3) An alpha channel has not been removed from an 8-bit format, or the - * 8-bit alpha value of the pixel was 255 (opaque). - * - * If an alpha channel has been *added* then it must have the relevant opaque - * value (255 or 65535). - * - * The fist two the tests (in the order given above) (using the boolean - * equivalence !a && !b == !(a || b)) - */ - if (!(((formata ^ formatb) & PNG_FORMAT_FLAG_LINEAR) | - (formata & (formatb ^ PNG_FORMAT_FLAG_COLOR) & PNG_FORMAT_FLAG_COLOR))) - { - /* Was an alpha channel changed? */ - const png_uint_32 alpha_changed = (formata ^ formatb) & - PNG_FORMAT_FLAG_ALPHA; - /* Was an alpha channel removed? (The third test.) If so the direct - * comparison is only possible if the input alpha is opaque. - */ - alpha_removed = (formata & alpha_changed) != 0; - - /* Was an alpha channel added? */ - alpha_added = (formatb & alpha_changed) != 0; - - /* The channels may have been moved between input and output, this finds - * out how, recording the result in the btoa array, which says where in - * 'a' to find each channel of 'b'. If alpha was added then btoa[alpha] - * ends up as 4 (and is not used.) - */ + if (formata & PNG_FORMAT_FLAG_COLOR) { - int i; - png_byte aloc[4]; - png_byte bloc[4]; - - /* The following are used only if the formats match, except that - * 'bchannels' is a flag for matching formats. btoa[x] says, for each - * channel in b, where to find the corresponding value in a, for the - * bchannels. achannels may be different for a gray to rgb transform - * (a will be 1 or 2, b will be 3 or 4 channels.) - */ - (void)component_loc(aloc, formata); - bchannels = component_loc(bloc, formatb); - - /* Hence the btoa array. */ - for (i=0; i<4; ++i) if (bloc[i] < 4) - btoa[bloc[i]] = aloc[i]; /* may be '4' for alpha */ - - if (alpha_added) - alpha_added = bloc[0]; /* location of alpha channel in image b */ - - else - alpha_added = 4; /* Won't match an image b channel */ + unsigned int swap = 0; - if (alpha_removed) - alpha_removed = aloc[0]; /* location of alpha channel in image a */ + /* Colors match, but are they swapped? */ + if ((formata ^ formatb) & PNG_FORMAT_FLAG_BGR) /* Swapped. */ + swap = 2; - else - alpha_removed = 4; + swap_mask[astart+0] = (png_byte)(bstart+(0^swap)); + swap_mask[astart+1] = (png_byte)(bstart+1); + swap_mask[astart+2] = (png_byte)(bstart+(2^swap)); } - } - else - { - /* Direct compare is not possible, cancel out all the corresponding local - * variables. - */ - bchannels = 0; - alpha_removed = alpha_added = 4; - btoa[3] = btoa[2] = btoa[1] = btoa[0] = 4; /* 4 == not present */ + else /* grayscale: 1 channel */ + swap_mask[astart] = bstart; } - for (y=0; y<height; ++y, rowa += stridea, rowb += strideb) + ppa = rowa; + ppb = rowb; + for (x=y=0; y<height;) { - png_const_bytep ppa, ppb; - png_uint_32 x; - - for (x=0, ppa=rowa, ppb=rowb; x<width; ++x) + /* Do the fast test if possible. */ + if (channels != 0) switch (linear) { - png_const_bytep psa, psb; - - if (formata & PNG_FORMAT_FLAG_COLORMAP) - psa = (png_const_bytep)a->colormap + a_sample * *ppa++; - else - psa = ppa, ppa += a_sample; - - if (formatb & PNG_FORMAT_FLAG_COLORMAP) - psb = (png_const_bytep)b->colormap + b_sample * *ppb++; - else - psb = ppb, ppb += b_sample; - - /* Do the fast test if possible. */ - if (bchannels) - { - /* Check each 'b' channel against either the corresponding 'a' - * channel or the opaque alpha value, as appropriate. If - * alpha_removed value is set (not 4) then also do this only if the - * 'a' alpha channel (alpha_removed) is opaque; only relevant for - * the 8-bit case. - */ - if (formatb & PNG_FORMAT_FLAG_LINEAR) /* 16-bit checks */ + case 2: /* both sides linear */ { - png_const_uint_16p pua = aligncastconst(png_const_uint_16p, psa); - png_const_uint_16p pub = aligncastconst(png_const_uint_16p, psb); + png_const_uint_16p lppa = (png_const_uint_16p)ppa; + png_const_uint_16p lppb = (png_const_uint_16p)ppb; - switch (bchannels) + while (x < width) switch (channels) { case 4: - if (pua[btoa[3]] != pub[3]) break; + if (lppa[3] != lppb[swap_mask[3]]) + goto linear_mismatch; case 3: - if (pua[btoa[2]] != pub[2]) break; + if (lppa[2] != lppb[swap_mask[2]]) + goto linear_mismatch; case 2: - if (pua[btoa[1]] != pub[1]) break; + if (lppa[1] != lppb[swap_mask[1]]) + goto linear_mismatch; case 1: - if (pua[btoa[0]] != pub[0]) break; - if (alpha_added != 4 && pub[alpha_added] != 65535) break; - continue; /* x loop */ + if (lppa[0] != lppb[swap_mask[0]]) + goto linear_mismatch; + + /* The pixels apparently match, but if an alpha channel has + * been added (in b) it must be 65535 too. + */ + if (check_alpha && 65535 != lppb[swap_mask[3]]) + goto linear_mismatch; + + /* This pixel matches, advance to the next. */ + lppa += channels; + lppb += channels + check_alpha; + ++x; default: - break; /* impossible */ + break; } + + linear_mismatch: + ppa = (png_const_bytep)lppa; + ppb = (png_const_bytep)lppb; } + break; - else if (alpha_removed == 4 || psa[alpha_removed] == 255) + case 0: /* both sides sRGB */ + while (x < width) switch (channels) { - switch (bchannels) - { - case 4: - if (psa[btoa[3]] != psb[3]) break; - case 3: - if (psa[btoa[2]] != psb[2]) break; - case 2: - if (psa[btoa[1]] != psb[1]) break; - case 1: - if (psa[btoa[0]] != psb[0]) break; - if (alpha_added != 4 && psb[alpha_added] != 255) break; - continue; /* x loop */ - default: - break; /* impossible */ - } + case 4: + if (ppa[3] != ppb[swap_mask[3]]) + goto sRGB_mismatch; + case 3: + if (ppa[2] != ppb[swap_mask[2]]) + goto sRGB_mismatch; + case 2: + if (ppa[1] != ppb[swap_mask[1]]) + goto sRGB_mismatch; + case 1: + if (ppa[0] != ppb[swap_mask[0]]) + goto sRGB_mismatch; + + /* The pixels apparently match, but if an alpha channel has + * been added (in b) it must be 1.0 too. + */ + if (check_alpha && 255 != ppb[swap_mask[3]]) + goto sRGB_mismatch; + + /* This pixel matches, advance to the next. */ + ppa += channels; + ppb += channels + check_alpha; + ++x; + default: + break; } + + sRGB_mismatch: + break; + + default: /* formats do not match */ + break; + } + + /* If at the end of the row advance to the next row, if not at the end + * compare the pixels the slow way. + */ + if (x < width) + { + Pixel pixel_a, pixel_b; + const char *mismatch; + + get_pixel(a, &pixel_a, ppa); + get_pixel(b, &pixel_b, ppb); + mismatch = cmppixel(&pixel_a, &pixel_b, background, via_linear); + + if (mismatch != NULL) + { + (void)logpixel(a, x, y, &pixel_a, &pixel_b, mismatch); + + if ((a->opts & KEEP_GOING) == 0) + return 0; + + result = 0; } - /* If we get to here the fast match failed; do the slow match for this - * pixel. - */ - if (!cmppixel(&tr, psa, psb, x, y) && (a->opts & KEEP_GOING) == 0) - return 0; /* error case */ + ++x; } - } - /* If reqested copy the error values back from the Transform. */ - if (a->opts & ACCUMULATE) - { - tr.error_ptr[0] = tr.error[0]; - tr.error_ptr[1] = tr.error[1]; - tr.error_ptr[2] = tr.error[2]; - tr.error_ptr[3] = tr.error[3]; + if (x >= width) + { + x = 0; + ++y; + rowa += stridea; + rowb += strideb; + ppa = rowa; + ppb = rowb; + } } - return 1; + return result; } /* Read the file; how the read gets done depends on which of input_file and * input_memory have been set. */ static int -read_file(Image *image, png_uint_32 format, png_const_colorp background) +read_file(Image *image, png_uint_32 format) { - memset(&image->image, 0, sizeof image->image); - image->image.version = PNG_IMAGE_VERSION; - if (image->input_memory != NULL) { if (!png_image_begin_read_from_memory(&image->image, image->input_memory, @@ -3031,50 +1303,30 @@ read_file(Image *image, png_uint_32 format, png_const_colorp background) */ { int result; - png_uint_32 image_format; - /* Print both original and output formats. */ - image_format = image->image.format; + /* Various random settings for detecting overwrites */ + image->background.red = 89; + image->background.green = 78; + image->background.blue = 178; + /* Print both original and output formats. */ if (image->opts & VERBOSE) - { - printf("%s %lu x %lu %s -> %s", image->file_name, + printf("%s %lu x %lu %s -> %s\n", image->file_name, (unsigned long)image->image.width, (unsigned long)image->image.height, - format_names[image_format & FORMAT_MASK], + format_names[image->image.format & 0x1f], (format & FORMAT_NO_CHANGE) != 0 || image->image.format == format - ? "no change" : format_names[format & FORMAT_MASK]); + ? "no change" : format_names[format & 0x1f]); - if (background != NULL) - printf(" background(%d,%d,%d)\n", background->red, - background->green, background->blue); - else - printf("\n"); - - fflush(stdout); - } - - /* 'NO_CHANGE' combined with the color-map flag forces the base format - * flags to be set on read to ensure that the original representation is - * not lost in the pass through a colormap format. - */ - if ((format & FORMAT_NO_CHANGE) != 0) - { - if ((format & PNG_FORMAT_FLAG_COLORMAP) != 0 && - (image_format & PNG_FORMAT_FLAG_COLORMAP) != 0) - format = (image_format & ~BASE_FORMATS) | (format & BASE_FORMATS); - - else - format = image_format; - } - - image->image.format = format; + if ((format & FORMAT_NO_CHANGE) == 0) + image->image.format = format; image->stride = PNG_IMAGE_ROW_STRIDE(image->image) + image->stride_extra; allocbuffer(image); - result = png_image_finish_read(&image->image, background, - image->buffer+16, (png_int_32)image->stride, image->colormap); + result = png_image_finish_read(&image->image, + (image->opts & USE_BACKGROUND) ? &image->background : NULL, + image->buffer+16, (png_int_32)image->stride); checkbuffer(image, image->file_name); @@ -3087,11 +1339,10 @@ read_file(Image *image, png_uint_32 format, png_const_colorp background) } /* Reads from a filename, which must be in image->file_name, but uses - * image->opts to choose the method. The file is always read in its native - * format (the one the simplified API suggests). + * image->opts to choose the method. */ static int -read_one_file(Image *image) +read_one_file(Image *image, png_uint_32 format) { if (!(image->opts & READ_FILE) || (image->opts & USE_STDIO)) { @@ -3109,7 +1360,7 @@ read_one_file(Image *image) { long int cb = ftell(f); - if (cb > 0 && (unsigned long int)cb < (size_t)~(size_t)0) + if (cb >= 0 && (unsigned long int)cb < (size_t)~(size_t)0) { png_bytep b = voidcast(png_bytep, malloc((size_t)cb)); @@ -3128,22 +1379,17 @@ read_one_file(Image *image) { free(b); return logclose(image, f, image->file_name, - ": read failed: "); + ": read failed"); } } else return logclose(image, f, image->file_name, - ": out of memory: "); + ": out of memory"); } - else if (cb == 0) - return logclose(image, f, image->file_name, - ": zero length: "); - else - return logclose(image, f, image->file_name, - ": tell failed: "); + return logclose(image, f, image->file_name, ": tell failed"); } else @@ -3156,16 +1402,12 @@ read_one_file(Image *image) strerror(errno)); } - return read_file(image, FORMAT_NO_CHANGE, NULL); + return read_file(image, format); } -#ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED static int write_one_file(Image *output, Image *image, int convert_to_8bit) { - if (image->opts & FAST_WRITE) - image->image.flags |= PNG_IMAGE_FLAG_FAST; - if (image->opts & USE_STDIO) { FILE *f = tmpfile(); @@ -3173,7 +1415,7 @@ write_one_file(Image *output, Image *image, int convert_to_8bit) if (f != NULL) { if (png_image_write_to_stdio(&image->image, f, convert_to_8bit, - image->buffer+16, (png_int_32)image->stride, image->colormap)) + image->buffer+16, (png_int_32)image->stride)) { if (fflush(f) == 0) { @@ -3185,7 +1427,7 @@ write_one_file(Image *output, Image *image, int convert_to_8bit) } else - return logclose(image, f, "tmpfile", ": flush: "); + return logclose(image, f, "tmpfile", ": flush"); } else @@ -3204,10 +1446,10 @@ write_one_file(Image *output, Image *image, int convert_to_8bit) static int counter = 0; char name[32]; - sprintf(name, "%s%d.png", tmpf, ++counter); + sprintf(name, "TMP%d.png", ++counter); if (png_image_write_to_file(&image->image, name, convert_to_8bit, - image->buffer+16, (png_int_32)image->stride, image->colormap)) + image->buffer+16, (png_int_32)image->stride)) { initimage(output, image->opts, output->tmpfile_name, image->stride_extra); @@ -3225,33 +1467,25 @@ write_one_file(Image *output, Image *image, int convert_to_8bit) /* 'output' has an initialized temporary image, read this back in and compare * this against the original: there should be no change since the original * format was written unmodified unless 'convert_to_8bit' was specified. - * However, if the original image was color-mapped, a simple read will zap - * the linear, color and maybe alpha flags, this will cause spurious failures - * under some circumstances. */ - if (read_file(output, image->image.format | FORMAT_NO_CHANGE, NULL)) + if (read_file(output, FORMAT_NO_CHANGE)) { - png_uint_32 original_format = image->image.format; - - if (convert_to_8bit) - original_format &= ~PNG_FORMAT_FLAG_LINEAR; - if ((output->image.format & BASE_FORMATS) != - (original_format & BASE_FORMATS)) - return logerror(image, image->file_name, ": format changed on read: ", + ((image->image.format & BASE_FORMATS) & + ~(convert_to_8bit ? PNG_FORMAT_FLAG_LINEAR : 0))) + return logerror(image, image->file_name, ": format changed on read:", output->file_name); - return compare_two_images(image, output, 0/*via linear*/, NULL); + return compare_two_images(image, output, 0); } else return logerror(output, output->tmpfile_name, ": read of new file failed", ""); } -#endif static int -testimage(Image *image, png_uint_32 opts, format_list *pf) +testimage(Image *image, png_uint_32 opts, png_uint_32 formats) { int result; Image copy; @@ -3271,113 +1505,56 @@ testimage(Image *image, png_uint_32 opts, format_list *pf) image->tmpfile_name[0] = 0; { - png_uint_32 counter; + png_uint_32 format; Image output; newimage(&output); - + result = 1; - - /* Use the low bit of 'counter' to indicate whether or not to do alpha - * removal with a background color or by composting onto the image; this - * step gets skipped if it isn't relevant - */ - for (counter=0; counter<2*FORMAT_COUNT; ++counter) - if (format_isset(pf, counter >> 1)) + for (format=0; format<32; ++format) if (formats & (1<<format)) { - png_uint_32 format = counter >> 1; + resetimage(©); + result = read_file(©, format); + if (!result) + break; - png_color background_color; - png_colorp background = NULL; + /* Make sure the file just read matches the original file. */ + result = compare_two_images(image, ©, 0); + if (!result) + break; - /* If there is a format change that removes the alpha channel then - * the background is relevant. If the output is 8-bit color-mapped - * then a background color *must* be provided, otherwise there are - * two tests to do - one with a color, the other with NULL. The - * NULL test happens second. + /* Write the *copy* just made to a new file to make sure the write side + * works ok. Check the conversion to sRGB if the copy is linear. */ - if ((counter & 1) == 0) - { - if ((format & PNG_FORMAT_FLAG_ALPHA) == 0 && - (image->image.format & PNG_FORMAT_FLAG_ALPHA) != 0) - { - /* Alpha/transparency will be removed, the background is - * relevant: make it a color the first time - */ - random_color(&background_color); - background = &background_color; - - /* BUT if the output is to a color-mapped 8-bit format then - * the background must always be a color, so increment 'counter' - * to skip the NULL test. - */ - if ((format & PNG_FORMAT_FLAG_COLORMAP) != 0 && - (format & PNG_FORMAT_FLAG_LINEAR) == 0) - ++counter; - } - - /* Otherwise an alpha channel is not being eliminated, just leave - * background NULL and skip the (counter & 1) NULL test. - */ - else - ++counter; - } - /* else just use NULL for background */ - - resetimage(©); - copy.opts = opts; /* in case read_file needs to change it */ - - result = read_file(©, format, background); + result = write_one_file(&output, ©, 0/*convert to 8bit*/); if (!result) break; - /* Make sure the file just read matches the original file. */ - result = compare_two_images(image, ©, 0/*via linear*/, background); + /* Validate against the original too: */ + result = compare_two_images(image, &output, 0); if (!result) break; -# ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED - /* Write the *copy* just made to a new file to make sure the write - * side works ok. Check the conversion to sRGB if the copy is - * linear. - */ - output.opts = opts; - result = write_one_file(&output, ©, 0/*convert to 8bit*/); + if ((output.image.format & PNG_FORMAT_FLAG_LINEAR) != 0) + { + /* 'output' is linear, convert to the corresponding sRGB format. */ + result = write_one_file(&output, ©, 1/*convert to 8bit*/); if (!result) break; - /* Validate against the original too; the background is needed here - * as well so that compare_two_images knows what color was used. + /* This may involve a conversion via linear; in the ideal world this + * would round-trip correctly, but libpng 1.5.7 is not the ideal + * world so allow a drift (error_via_linear). + * + * 'image' has an alpha channel but 'output' does not then there + * will a strip-alpha-channel operation (because 'output' is + * linear), handle this by composing on black when doing the + * comparison. */ - result = compare_two_images(image, &output, 0, background); + result = compare_two_images(image, &output, 1/*via_linear*/); if (!result) break; - - if ((format & PNG_FORMAT_FLAG_LINEAR) != 0 && - (format & PNG_FORMAT_FLAG_COLORMAP) == 0) - { - /* 'output' is linear, convert to the corresponding sRGB format. - */ - output.opts = opts; - result = write_one_file(&output, ©, 1/*convert to 8bit*/); - if (!result) - break; - - /* This may involve a conversion via linear; in the ideal world - * this would round-trip correctly, but libpng 1.5.7 is not the - * ideal world so allow a drift (error_via_linear). - * - * 'image' has an alpha channel but 'output' does not then there - * will a strip-alpha-channel operation (because 'output' is - * linear), handle this by composing on black when doing the - * comparison. - */ - result = compare_two_images(image, &output, 1/*via_linear*/, - background); - if (!result) - break; - } -# endif /* PNG_SIMPLIFIED_WRITE_SUPPORTED */ + } } freeimage(&output); @@ -3388,76 +1565,23 @@ testimage(Image *image, png_uint_32 opts, format_list *pf) return result; } -static int -test_one_file(const char *file_name, format_list *formats, png_uint_32 opts, - int stride_extra, int log_pass) -{ - int result; - Image image; - - newimage(&image); - initimage(&image, opts, file_name, stride_extra); - result = read_one_file(&image); - if (result) - result = testimage(&image, opts, formats); - freeimage(&image); - - /* Ensure that stderr is flushed into any log file */ - fflush(stderr); - - if (log_pass) - { - if (result) - printf("PASS:"); - - else - printf("FAIL:"); - -# ifndef PNG_SIMPLIFIED_WRITE_SUPPORTED - printf(" (no write)"); -# endif - - print_opts(opts); - printf(" %s\n", file_name); - /* stdout may not be line-buffered if it is piped to a file, so: */ - fflush(stdout); - } - - else if (!result) - exit(1); - - return result; -} - int -main(int argc, char **argv) +main(int argc, const char **argv) { - png_uint_32 opts = FAST_WRITE; - format_list formats; + png_uint_32 opts = 0; + png_uint_32 formats = (png_uint_32)~0; /* a mask of formats to test */ const char *touch = NULL; int log_pass = 0; - int redundant = 0; int stride_extra = 0; int retval = 0; int c; - init_sRGB_to_d(); -#if 0 - init_error_via_linear(); -#endif - format_init(&formats); - for (c=1; c<argc; ++c) { const char *arg = argv[c]; if (strcmp(arg, "--log") == 0) log_pass = 1; - else if (strcmp(arg, "--fresh") == 0) - { - memset(gpc_error, 0, sizeof gpc_error); - memset(gpc_error_via_linear, 0, sizeof gpc_error_via_linear); - } else if (strcmp(arg, "--file") == 0) opts |= READ_FILE; else if (strcmp(arg, "--memory") == 0) @@ -3466,6 +1590,10 @@ main(int argc, char **argv) opts |= USE_STDIO; else if (strcmp(arg, "--name") == 0) opts &= ~USE_STDIO; + else if (strcmp(arg, "--background") == 0) + opts |= USE_BACKGROUND; + else if (strcmp(arg, "--composite") == 0) + opts &= ~USE_BACKGROUND; else if (strcmp(arg, "--verbose") == 0) opts |= VERBOSE; else if (strcmp(arg, "--quiet") == 0) @@ -3476,42 +1604,8 @@ main(int argc, char **argv) opts &= ~KEEP_TMPFILES; else if (strcmp(arg, "--keep-going") == 0) opts |= KEEP_GOING; - else if (strcmp(arg, "--fast") == 0) - opts |= FAST_WRITE; - else if (strcmp(arg, "--slow") == 0) - opts &= ~FAST_WRITE; - else if (strcmp(arg, "--accumulate") == 0) - opts |= ACCUMULATE; - else if (strcmp(arg, "--redundant") == 0) - redundant = 1; else if (strcmp(arg, "--stop") == 0) opts &= ~KEEP_GOING; - else if (strcmp(arg, "--strict") == 0) - opts |= STRICT; - else if (strcmp(arg, "--tmpfile") == 0) - { - if (c+1 < argc) - { - if (strlen(argv[++c]) >= sizeof tmpf) - { - fflush(stdout); - fprintf(stderr, "%s: %s is too long for a temp file prefix\n", - argv[0], argv[c]); - exit(99); - } - - /* Safe: checked above */ - strcpy(tmpf, argv[c]); - } - - else - { - fflush(stdout); - fprintf(stderr, "%s: %s requires a temporary file prefix\n", - argv[0], arg); - exit(99); - } - } else if (strcmp(arg, "--touch") == 0) { if (c+1 < argc) @@ -3519,176 +1613,58 @@ main(int argc, char **argv) else { - fflush(stdout); fprintf(stderr, "%s: %s requires a file name argument\n", argv[0], arg); - exit(99); + exit(1); } } else if (arg[0] == '+') { png_uint_32 format = formatof(arg+1); - if (format > FORMAT_COUNT) - exit(99); + if (format > 31) + exit(1); + + if (formats == (png_uint_32)~0) + formats = 0; - format_set(&formats, format); + formats |= 1<<format; } - else if (arg[0] == '-' && arg[1] != 0 && (arg[1] != '0' || arg[2] != 0)) + else if (arg[0] == '-') { - fflush(stdout); fprintf(stderr, "%s: unknown option: %s\n", argv[0], arg); - exit(99); + exit(1); } else { - if (format_is_initial(&formats)) - format_default(&formats, redundant); - - if (arg[0] == '-') - { - const int term = (arg[1] == '0' ? 0 : '\n'); - unsigned int ich = 0; - - /* Loop reading files, use a static buffer to simplify this and just - * stop if the name gets to long. - */ - static char buffer[4096]; - - do - { - int ch = getchar(); + int result; + Image image; - /* Don't allow '\0' in file names, and terminate with '\n' or, - * for -0, just '\0' (use -print0 to find to make this work!) - */ - if (ch == EOF || ch == term || ch == 0) - { - buffer[ich] = 0; - - if (ich > 0 && !test_one_file(buffer, &formats, opts, - stride_extra, log_pass)) - retval = 1; - - if (ch == EOF) - break; - - ich = 0; - --ich; /* so that the increment below sets it to 0 again */ - } - - else - buffer[ich] = (char)ch; - } while (++ich < sizeof buffer); + newimage(&image); + initimage(&image, opts, arg, stride_extra); + result = read_one_file(&image, FORMAT_NO_CHANGE); + if (result) + result = testimage(&image, opts, formats); + freeimage(&image); - if (ich) - { - buffer[32] = 0; - buffer[4095] = 0; - fprintf(stderr, "%s...%s: file name too long\n", buffer, - buffer+(4096-32)); - exit(99); - } - } - - else if (!test_one_file(arg, &formats, opts, stride_extra, log_pass)) - retval = 1; - } - } - - if (opts & ACCUMULATE) - { - unsigned int in; - - printf("static png_uint_16 gpc_error[16/*in*/][16/*out*/][4/*a*/] =\n"); - printf("{\n"); - for (in=0; in<16; ++in) - { - unsigned int out; - printf(" { /* input: %s */\n ", format_names[in]); - for (out=0; out<16; ++out) + if (log_pass) { - unsigned int alpha; - printf(" {"); - for (alpha=0; alpha<4; ++alpha) - { - printf(" %d", gpc_error[in][out][alpha]); - if (alpha < 3) putchar(','); - } - printf(" }"); - if (out < 15) - { - putchar(','); - if (out % 4 == 3) printf("\n "); - } - } - printf("\n }"); - - if (in < 15) - putchar(','); - else - putchar('\n'); - } - printf("};\n"); + if (result) + printf("PASS:"); - printf("static png_uint_16 gpc_error_via_linear[16][4/*out*/][4] =\n"); - printf("{\n"); - for (in=0; in<16; ++in) - { - unsigned int out; - printf(" { /* input: %s */\n ", format_names[in]); - for (out=0; out<4; ++out) - { - unsigned int alpha; - printf(" {"); - for (alpha=0; alpha<4; ++alpha) + else { - printf(" %d", gpc_error_via_linear[in][out][alpha]); - if (alpha < 3) putchar(','); + printf("FAIL:"); + retval = 1; } - printf(" }"); - if (out < 3) - putchar(','); - } - printf("\n }"); - if (in < 15) - putchar(','); - else - putchar('\n'); - } - printf("};\n"); - - printf("static png_uint_16 gpc_error_to_colormap[8/*i*/][8/*o*/][4] =\n"); - printf("{\n"); - for (in=0; in<8; ++in) - { - unsigned int out; - printf(" { /* input: %s */\n ", format_names[in]); - for (out=0; out<8; ++out) - { - unsigned int alpha; - printf(" {"); - for (alpha=0; alpha<4; ++alpha) - { - printf(" %d", gpc_error_to_colormap[in][out][alpha]); - if (alpha < 3) putchar(','); - } - printf(" }"); - if (out < 7) - { - putchar(','); - if (out % 4 == 3) printf("\n "); - } + print_opts(opts); + printf(" %s\n", arg); } - printf("\n }"); - if (in < 7) - putchar(','); - else - putchar('\n'); + else if (!result) + exit(1); } - printf("};\n"); } if (retval == 0 && touch != NULL) @@ -3704,28 +1680,17 @@ main(int argc, char **argv) if (fclose(fsuccess) || error) { - fflush(stdout); fprintf(stderr, "%s: write failed\n", touch); - exit(99); + exit(1); } } else { - fflush(stdout); fprintf(stderr, "%s: open failed\n", touch); - exit(99); + exit(1); } } return retval; } - -#else /* !PNG_SIMPLIFIED_READ_SUPPORTED */ -int main(void) -{ - fprintf(stderr, "pngstest: no read support in libpng, test skipped\n"); - /* So the test is skipped: */ - return 77; -} -#endif /* PNG_SIMPLIFIED_READ_SUPPORTED */ |