mirror of
https://git.code.sf.net/p/libpng/code.git
synced 2025-07-10 18:04:09 +02:00
[master] Imported from libpng-1.6.0.tar
This commit is contained in:
Glenn Randers-Pehrson
24
contrib/examples/README.txt
Normal file
24
contrib/examples/README.txt
Normal file
@@ -0,0 +1,24 @@
|
||||
|
||||
This directory (contrib/examples) contains examples of libpng usage.
|
||||
|
||||
NO COPYRIGHT RIGHTS ARE CLAIMED TO ANY OF THE FILES IN THIS DIRECTORY.
|
||||
|
||||
To the extent possible under law, the authors have waived all copyright and
|
||||
related or neighboring rights to this work. This work is published from:
|
||||
United States.
|
||||
|
||||
The files may be used freely in any way. The intention is that appropriate
|
||||
parts of the files be used in other libpng-using programs without any need for
|
||||
the authors of the using code to seek copyright or license from the original
|
||||
authors.
|
||||
|
||||
The source code and comments in this directory are the original work of the
|
||||
people named below. No other person or organization has made contributions to
|
||||
the work in this directory.
|
||||
|
||||
ORIGINAL AUTHORS
|
||||
The following people have contributed to the code in this directory. None
|
||||
of the people below claim any rights with regard to the contents of this
|
||||
directory.
|
||||
|
||||
John Bowler <jbowler@acm.org>
|
||||
180
contrib/examples/iccfrompng.c
Normal file
180
contrib/examples/iccfrompng.c
Normal file
@@ -0,0 +1,180 @@
|
||||
/*- iccfrompng
|
||||
*
|
||||
* COPYRIGHT: Written by John Cunningham Bowler, 2011.
|
||||
* To the extent possible under law, the author has waived all copyright and
|
||||
* related or neighboring rights to this work. This work is published from:
|
||||
* United States.
|
||||
*
|
||||
* Extract any icc profiles found in the given PNG files. This is a simple
|
||||
* example of a program which extracts information from the header of a PNG file
|
||||
* without processing the image. Notice that some header information may occur
|
||||
* after the image data, textual data and comments are an example; the approach
|
||||
* in this file won't work reliably for such data because it only looks for the
|
||||
* information in the section of the file that preceeds the image data.
|
||||
*
|
||||
* Compile and link against libpng and zlib, plus anything else required on the
|
||||
* system you use.
|
||||
*
|
||||
* To use supply a list of PNG files containing iCCP chunks, the chunks will be
|
||||
* extracted to a similarly named file with the extension replaced by 'icc',
|
||||
* which will be overwritten without warning.
|
||||
*/
|
||||
#include <stdlib.h>
|
||||
#include <setjmp.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include <png.h>
|
||||
|
||||
static int verbose = 1;
|
||||
static png_byte no_profile[] = "no profile";
|
||||
|
||||
static png_bytep
|
||||
extract(FILE *fp, png_uint_32 *proflen)
|
||||
{
|
||||
png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,0);
|
||||
png_infop info_ptr = NULL;
|
||||
png_bytep result = NULL;
|
||||
|
||||
/* Initialize for error or no profile: */
|
||||
*proflen = 0;
|
||||
|
||||
if (png_ptr == NULL)
|
||||
{
|
||||
fprintf(stderr, "iccfrompng: version library mismatch?\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (setjmp(png_jmpbuf(png_ptr)))
|
||||
{
|
||||
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
|
||||
return 0;
|
||||
}
|
||||
|
||||
png_init_io(png_ptr, fp);
|
||||
|
||||
info_ptr = png_create_info_struct(png_ptr);
|
||||
if (info_ptr == NULL)
|
||||
png_error(png_ptr, "OOM allocating info structure");
|
||||
|
||||
png_read_info(png_ptr, info_ptr);
|
||||
|
||||
{
|
||||
png_charp name;
|
||||
int compression_type;
|
||||
png_bytep profile;
|
||||
|
||||
if (png_get_iCCP(png_ptr, info_ptr, &name, &compression_type, &profile,
|
||||
proflen) & PNG_INFO_iCCP)
|
||||
{
|
||||
result = malloc(*proflen);
|
||||
if (result != NULL)
|
||||
memcpy(result, profile, *proflen);
|
||||
|
||||
else
|
||||
png_error(png_ptr, "OOM allocating profile buffer");
|
||||
}
|
||||
|
||||
else
|
||||
result = no_profile;
|
||||
}
|
||||
|
||||
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
|
||||
return result;
|
||||
}
|
||||
|
||||
static int
|
||||
extract_one_file(const char *filename)
|
||||
{
|
||||
int result = 0;
|
||||
FILE *fp = fopen(filename, "rb");
|
||||
|
||||
if (fp != NULL)
|
||||
{
|
||||
png_uint_32 proflen = 0;
|
||||
png_bytep profile = extract(fp, &proflen);
|
||||
|
||||
if (profile != NULL && profile != no_profile)
|
||||
{
|
||||
size_t len;
|
||||
char *output;
|
||||
|
||||
{
|
||||
const char *ep = strrchr(filename, '.');
|
||||
|
||||
if (ep != NULL)
|
||||
len = ep-filename;
|
||||
|
||||
else
|
||||
len = strlen(filename);
|
||||
}
|
||||
|
||||
output = malloc(len + 5);
|
||||
if (output != NULL)
|
||||
{
|
||||
FILE *of;
|
||||
|
||||
memcpy(output, filename, len);
|
||||
strcpy(output+len, ".icc");
|
||||
|
||||
of = fopen(output, "wb");
|
||||
if (of != NULL)
|
||||
{
|
||||
if (fwrite(profile, proflen, 1, of) == 1 &&
|
||||
fflush(of) == 0 &&
|
||||
fclose(of) == 0)
|
||||
{
|
||||
if (verbose)
|
||||
printf("%s -> %s\n", filename, output);
|
||||
/* Success return */
|
||||
result = 1;
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "%s: error writing profile\n", output);
|
||||
if (remove(output))
|
||||
fprintf(stderr, "%s: could not remove file\n", output);
|
||||
}
|
||||
}
|
||||
|
||||
else
|
||||
fprintf(stderr, "%s: failed to open output file\n", output);
|
||||
|
||||
free(output);
|
||||
}
|
||||
|
||||
else
|
||||
fprintf(stderr, "%s: OOM allocating string!\n", filename);
|
||||
|
||||
free(profile);
|
||||
}
|
||||
|
||||
else if (verbose && profile == no_profile)
|
||||
printf("%s has no profile\n", filename);
|
||||
}
|
||||
|
||||
else
|
||||
fprintf(stderr, "%s: could not open file\n", filename);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, char **argv)
|
||||
{
|
||||
int i;
|
||||
int extracted = 0;
|
||||
|
||||
for (i=1; i<argc; ++i)
|
||||
{
|
||||
if (strcmp(argv[i], "-q") == 0)
|
||||
verbose = 0;
|
||||
|
||||
else if (extract_one_file(argv[i]))
|
||||
extracted = 1;
|
||||
}
|
||||
|
||||
/* Exit code is true if any extract succeeds */
|
||||
return extracted == 0;
|
||||
}
|
||||
368
contrib/examples/pngpixel.c
Normal file
368
contrib/examples/pngpixel.c
Normal file
@@ -0,0 +1,368 @@
|
||||
/*- pngpixel
|
||||
*
|
||||
* COPYRIGHT: Written by John Cunningham Bowler, 2011.
|
||||
* To the extent possible under law, the author has waived all copyright and
|
||||
* related or neighboring rights to this work. This work is published from:
|
||||
* United States.
|
||||
*
|
||||
* Read a single pixel value from a PNG file.
|
||||
*
|
||||
* This code illustrates basic 'by-row' reading of a PNG file using libpng.
|
||||
* Rows are read until a particular pixel is found, the value of this pixel is
|
||||
* then printed on stdout.
|
||||
*
|
||||
* The code illustrates how to do this on interlaced as well as non-interlaced
|
||||
* images. Normally you would call png_set_interlace_handling() to have libpng
|
||||
* deal with the interlace for you, but that obliges you to buffer half of the
|
||||
* image to assemble the interlaced rows. In this code
|
||||
* png_set_interlace_handling() is not called and, instead, the code handles the
|
||||
* interlace passes directly looking for the required pixel.
|
||||
*/
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <setjmp.h> /* required for error handling */
|
||||
|
||||
/* Normally use <png.h> here to get the installed libpng, but this is done to
|
||||
* ensure the code picks up the local libpng implementation:
|
||||
*/
|
||||
#include "../../png.h"
|
||||
|
||||
/* Return component 'c' of pixel 'x' from the given row. */
|
||||
static unsigned int
|
||||
component(png_const_bytep row, png_uint_32 x, unsigned int c,
|
||||
unsigned int bit_depth, unsigned int channels)
|
||||
{
|
||||
/* PNG images can be up to 2^31 pixels wide, but this means they can be up to
|
||||
* 2^37 bits wide (for a 64-bit pixel - the largest possible) and hence 2^34
|
||||
* bytes wide. Since the row fitted into memory, however, the following must
|
||||
* work:
|
||||
*/
|
||||
png_uint_32 bit_offset_hi = bit_depth * ((x >> 6) * channels + c);
|
||||
png_uint_32 bit_offset_lo = bit_depth * ((x & 0x3f) * channels + c);
|
||||
|
||||
row = (png_const_bytep)(((PNG_CONST png_byte (*)[8])row) + bit_offset_hi);
|
||||
row += bit_offset_lo >> 3;
|
||||
bit_offset_lo &= 0x07;
|
||||
|
||||
/* PNG pixels are packed into bytes to put the first pixel in the highest
|
||||
* bits of the byte and into two bytes for 16-bit values with the high 8 bits
|
||||
* first, so:
|
||||
*/
|
||||
switch (bit_depth)
|
||||
{
|
||||
case 1: return (row[0] >> (7-bit_offset_lo)) & 0x01;
|
||||
case 2: return (row[0] >> (6-bit_offset_lo)) & 0x03;
|
||||
case 4: return (row[0] >> (4-bit_offset_lo)) & 0x0f;
|
||||
case 8: return row[0];
|
||||
case 16: return (row[0] << 8) + row[1];
|
||||
default:
|
||||
/* This should never happen, it indicates a bug in this program or in
|
||||
* libpng itself:
|
||||
*/
|
||||
fprintf(stderr, "pngpixel: invalid bit depth %u\n", bit_depth);
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
/* Print a pixel from a row returned by libpng; determine the row format, find
|
||||
* the pixel, and print the relevant information to stdout.
|
||||
*/
|
||||
static void
|
||||
print_pixel(png_structp png_ptr, png_infop info_ptr, png_const_bytep row,
|
||||
png_uint_32 x)
|
||||
{
|
||||
PNG_CONST unsigned int bit_depth = png_get_bit_depth(png_ptr, info_ptr);
|
||||
|
||||
switch (png_get_color_type(png_ptr, info_ptr))
|
||||
{
|
||||
case PNG_COLOR_TYPE_GRAY:
|
||||
printf("GRAY %u\n", component(row, x, 0, bit_depth, 1));
|
||||
return;
|
||||
|
||||
/* The palette case is slightly more difficult - the palette and, if
|
||||
* present, the tRNS ('transparency', though the values are really
|
||||
* opacity) data must be read to give the full picture:
|
||||
*/
|
||||
case PNG_COLOR_TYPE_PALETTE:
|
||||
{
|
||||
PNG_CONST unsigned int index = component(row, x, 0, bit_depth, 1);
|
||||
png_colorp palette = NULL;
|
||||
int num_palette = 0;
|
||||
|
||||
if ((png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette) &
|
||||
PNG_INFO_PLTE) && num_palette > 0 && palette != NULL)
|
||||
{
|
||||
png_bytep trans_alpha = NULL;
|
||||
int num_trans = 0;
|
||||
if ((png_get_tRNS(png_ptr, info_ptr, &trans_alpha, &num_trans,
|
||||
NULL) & PNG_INFO_tRNS) && num_trans > 0 &&
|
||||
trans_alpha != NULL)
|
||||
printf("INDEXED %u = %d %d %d %d\n", index,
|
||||
palette[index].red, palette[index].green,
|
||||
palette[index].blue,
|
||||
index < num_trans ? trans_alpha[index] : 255);
|
||||
|
||||
else /* no transparency */
|
||||
printf("INDEXED %u = %d %d %d\n", index,
|
||||
palette[index].red, palette[index].green,
|
||||
palette[index].blue);
|
||||
}
|
||||
|
||||
else
|
||||
printf("INDEXED %u = invalid index\n", index);
|
||||
}
|
||||
return;
|
||||
|
||||
case PNG_COLOR_TYPE_RGB:
|
||||
printf("RGB %u %u %u\n", component(row, x, 0, bit_depth, 3),
|
||||
component(row, x, 1, bit_depth, 3),
|
||||
component(row, x, 2, bit_depth, 3));
|
||||
return;
|
||||
|
||||
case PNG_COLOR_TYPE_GRAY_ALPHA:
|
||||
printf("GRAY+ALPHA %u %u\n", component(row, x, 0, bit_depth, 2),
|
||||
component(row, x, 1, bit_depth, 2));
|
||||
return;
|
||||
|
||||
case PNG_COLOR_TYPE_RGB_ALPHA:
|
||||
printf("RGBA %u %u %u %u\n", component(row, x, 0, bit_depth, 4),
|
||||
component(row, x, 1, bit_depth, 4),
|
||||
component(row, x, 2, bit_depth, 4),
|
||||
component(row, x, 3, bit_depth, 4));
|
||||
return;
|
||||
|
||||
default:
|
||||
png_error(png_ptr, "invalid color type");
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, const char **argv)
|
||||
{
|
||||
/* This program uses the default, <setjmp.h> based, libpng error handling
|
||||
* mechanism, therefore any local variable that exists before the call to
|
||||
* setjmp and is changed after the call to setjmp returns successfully must
|
||||
* be declared with 'volatile' to ensure that their values don't get
|
||||
* destroyed by longjmp:
|
||||
*/
|
||||
volatile int result = 1/*fail*/;
|
||||
|
||||
if (argc == 4)
|
||||
{
|
||||
long x = atol(argv[1]);
|
||||
long y = atol(argv[2]);
|
||||
FILE *f = fopen(argv[3], "rb");
|
||||
volatile png_bytep row = NULL;
|
||||
|
||||
if (f != NULL)
|
||||
{
|
||||
/* libpng requires a callback function for handling errors; this
|
||||
* callback must not return. The default callback function uses a
|
||||
* stored <setjmp.h> style jmp_buf which is held in a png_struct and
|
||||
* writes error messages to stderr. Creating the png_struct is a
|
||||
* little tricky; just copy the following code.
|
||||
*/
|
||||
png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
|
||||
NULL, NULL, NULL);
|
||||
|
||||
if (png_ptr != NULL)
|
||||
{
|
||||
png_infop info_ptr = png_create_info_struct(png_ptr);
|
||||
|
||||
if (info_ptr != NULL)
|
||||
{
|
||||
/* Declare stack variables to hold pointers to locally allocated
|
||||
* data.
|
||||
*/
|
||||
|
||||
/* Initialize the error control buffer: */
|
||||
if (setjmp(png_jmpbuf(png_ptr)) == 0)
|
||||
{
|
||||
png_uint_32 width, height;
|
||||
int bit_depth, color_type, interlace_method,
|
||||
compression_method, filter_method;
|
||||
png_bytep row_tmp;
|
||||
|
||||
/* Now associate the recently opened (FILE*) with the default
|
||||
* libpng initialization functions. Sometimes libpng is
|
||||
* compiled without stdio support (it can be difficult to do
|
||||
* in some environments); in that case you will have to write
|
||||
* your own read callback to read data from the (FILE*).
|
||||
*/
|
||||
png_init_io(png_ptr, f);
|
||||
|
||||
/* And read the first part of the PNG file - the header and
|
||||
* all the information up to the first pixel.
|
||||
*/
|
||||
png_read_info(png_ptr, info_ptr);
|
||||
|
||||
/* This fills in enough information to tell us the width of
|
||||
* each row in bytes, allocate the appropriate amount of
|
||||
* space. In this case png_malloc is used - it will not
|
||||
* return if memory isn't available.
|
||||
*/
|
||||
row = png_malloc(png_ptr, png_get_rowbytes(png_ptr,
|
||||
info_ptr));
|
||||
|
||||
/* To avoid the overhead of using a volatile auto copy row_tmp
|
||||
* to a local here - just use row for the png_free below.
|
||||
*/
|
||||
row_tmp = row;
|
||||
|
||||
/* All the information we need is in the header is returned by
|
||||
* png_get_IHDR, if this fails we can now use 'png_error' to
|
||||
* signal the error and return control to the setjmp above.
|
||||
*/
|
||||
if (png_get_IHDR(png_ptr, info_ptr, &width, &height,
|
||||
&bit_depth, &color_type, &interlace_method,
|
||||
&compression_method, &filter_method))
|
||||
{
|
||||
int passes, pass;
|
||||
|
||||
/* png_set_interlace_handling returns the number of
|
||||
* passes required as well as turning on libpng's
|
||||
* handling, but since we do it ourselves this is
|
||||
* necessary:
|
||||
*/
|
||||
switch (interlace_method)
|
||||
{
|
||||
case PNG_INTERLACE_NONE:
|
||||
passes = 1;
|
||||
break;
|
||||
|
||||
case PNG_INTERLACE_ADAM7:
|
||||
passes = PNG_INTERLACE_ADAM7_PASSES;
|
||||
break;
|
||||
|
||||
default:
|
||||
png_error(png_ptr, "pngpixel: unknown interlace");
|
||||
}
|
||||
|
||||
/* Now read the pixels, pass-by-pass, row-by-row: */
|
||||
png_start_read_image(png_ptr);
|
||||
|
||||
for (pass=0; pass<passes; ++pass)
|
||||
{
|
||||
png_uint_32 ystart, xstart, ystep, xstep;
|
||||
png_uint_32 py;
|
||||
|
||||
if (interlace_method == PNG_INTERLACE_ADAM7)
|
||||
{
|
||||
/* Sometimes the whole pass is empty because the
|
||||
* image is too narrow or too short. libpng
|
||||
* expects to be called for each row that is
|
||||
* present in the pass, so it may be necessary to
|
||||
* skip the loop below (over py) if the image is
|
||||
* too narrow.
|
||||
*/
|
||||
if (PNG_PASS_COLS(width, pass) == 0)
|
||||
continue;
|
||||
|
||||
/* We need the starting pixel and the offset
|
||||
* between each pixel in this pass; use the macros
|
||||
* in png.h:
|
||||
*/
|
||||
xstart = PNG_PASS_START_COL(pass);
|
||||
ystart = PNG_PASS_START_ROW(pass);
|
||||
xstep = PNG_PASS_COL_OFFSET(pass);
|
||||
ystep = PNG_PASS_ROW_OFFSET(pass);
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
ystart = xstart = 0;
|
||||
ystep = xstep = 1;
|
||||
}
|
||||
|
||||
/* To find the pixel, loop over 'py' for each pass
|
||||
* reading a row and then checking to see if it
|
||||
* contains the pixel.
|
||||
*/
|
||||
for (py = ystart; py < height; py += ystep)
|
||||
{
|
||||
png_uint_32 px, ppx;
|
||||
|
||||
/* png_read_row takes two pointers. When libpng
|
||||
* handles the interlace the first is filled in
|
||||
* pixel-by-pixel, and the second receives the same
|
||||
* pixels but they are replicated across the
|
||||
* unwritten pixels so far for each pass. When we
|
||||
* do the interlace, however, they just contain
|
||||
* the pixels from the interlace pass - giving
|
||||
* both is wasteful and pointless, so we pass a
|
||||
* NULL pointer.
|
||||
*/
|
||||
png_read_row(png_ptr, row_tmp, NULL);
|
||||
|
||||
/* Now find the pixel if it is in this row; there
|
||||
* are, of course, much better ways of doing this
|
||||
* than using a for loop:
|
||||
*/
|
||||
if (y == py) for (px = xstart, ppx = 0;
|
||||
px < width; px += xstep, ++ppx) if (x == px)
|
||||
{
|
||||
/* 'ppx' is the index of the pixel in the row
|
||||
* buffer.
|
||||
*/
|
||||
print_pixel(png_ptr, info_ptr, row_tmp, ppx);
|
||||
|
||||
/* Now terminate the loops early - we have
|
||||
* found and handled the required data.
|
||||
*/
|
||||
goto pass_loop_end;
|
||||
} /* x loop */
|
||||
} /* y loop */
|
||||
} /* pass loop */
|
||||
|
||||
/* Finally free the temporary buffer: */
|
||||
pass_loop_end:
|
||||
row = NULL;
|
||||
png_free(png_ptr, row_tmp);
|
||||
}
|
||||
|
||||
else
|
||||
png_error(png_ptr, "pngpixel: png_get_IHDR failed");
|
||||
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
/* Else libpng has raised an error. An error message has
|
||||
* already been output, so it is only necessary to clean up
|
||||
* locally allocated data:
|
||||
*/
|
||||
if (row != NULL)
|
||||
{
|
||||
/* The default implementation of png_free never errors out
|
||||
* (it just crashes if something goes wrong), but the safe
|
||||
* way of using it is still to clear 'row' before calling
|
||||
* png_free:
|
||||
*/
|
||||
png_bytep row_tmp = row;
|
||||
row = NULL;
|
||||
png_free(png_ptr, row_tmp);
|
||||
}
|
||||
}
|
||||
|
||||
png_destroy_info_struct(png_ptr, &info_ptr);
|
||||
}
|
||||
|
||||
else
|
||||
fprintf(stderr, "pngpixel: out of memory allocating png_info\n");
|
||||
|
||||
png_destroy_read_struct(&png_ptr, NULL, NULL);
|
||||
}
|
||||
|
||||
else
|
||||
fprintf(stderr, "pngpixel: out of memory allocating png_struct\n");
|
||||
}
|
||||
|
||||
else
|
||||
fprintf(stderr, "pngpixel: %s: could not open file\n", argv[3]);
|
||||
}
|
||||
|
||||
else
|
||||
/* Wrong number of arguments */
|
||||
fprintf(stderr, "pngpixel: usage: pngpixel x y png-file\n");
|
||||
|
||||
return result;
|
||||
}
|
||||
92
contrib/examples/pngtopng.c
Normal file
92
contrib/examples/pngtopng.c
Normal file
@@ -0,0 +1,92 @@
|
||||
/*- pngtopng
|
||||
*
|
||||
* COPYRIGHT: Written by John Cunningham Bowler, 2011.
|
||||
* To the extent possible under law, the author has waived all copyright and
|
||||
* related or neighboring rights to this work. This work is published from:
|
||||
* United States.
|
||||
*
|
||||
* Read a PNG and write it out in a fixed format, using the 'simplified API'
|
||||
* that was introduced in libpng-1.6.0.
|
||||
*
|
||||
* This sample code is just the code from the top of 'example.c' with some error
|
||||
* handling added. See example.c for more comments.
|
||||
*/
|
||||
#include <stddef.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
/* Normally use <png.h> here to get the installed libpng, but this is done to
|
||||
* ensure the code picks up the local libpng implementation:
|
||||
*/
|
||||
#include "../../png.h"
|
||||
|
||||
int main(int argc, const char **argv)
|
||||
{
|
||||
int result = 1;
|
||||
|
||||
if (argc == 3)
|
||||
{
|
||||
png_image image;
|
||||
|
||||
/* Only the image structure version number needs to be set. */
|
||||
memset(&image, 0, sizeof image);
|
||||
image.version = PNG_IMAGE_VERSION;
|
||||
|
||||
if (png_image_begin_read_from_file(&image, argv[1]))
|
||||
{
|
||||
png_bytep buffer;
|
||||
|
||||
/* Change this to try different formats! If you set a colormap format
|
||||
* then you must also supply a colormap below.
|
||||
*/
|
||||
image.format = PNG_FORMAT_RGBA;
|
||||
|
||||
buffer = malloc(PNG_IMAGE_SIZE(image));
|
||||
|
||||
if (buffer != NULL)
|
||||
{
|
||||
if (png_image_finish_read(&image, NULL/*background*/, buffer,
|
||||
0/*row_stride*/, NULL/*colormap for PNG_FORMAT_FLAG_COLORMAP */))
|
||||
{
|
||||
if (png_image_write_to_file(&image, argv[2],
|
||||
0/*convert_to_8bit*/, buffer, 0/*row_stride*/,
|
||||
NULL/*colormap*/))
|
||||
result = 0;
|
||||
|
||||
else
|
||||
fprintf(stderr, "pngtopng: write %s: %s\n", argv[2],
|
||||
image.message);
|
||||
|
||||
free(buffer);
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "pngtopng: read %s: %s\n", argv[1],
|
||||
image.message);
|
||||
|
||||
/* This is the only place where a 'free' is required; libpng does
|
||||
* the cleanup on error and success, but in this case we couldn't
|
||||
* complete the read because of running out of memory.
|
||||
*/
|
||||
png_image_free(&image);
|
||||
}
|
||||
}
|
||||
|
||||
else
|
||||
fprintf(stderr, "pngtopng: out of memory: %lu bytes\n",
|
||||
(unsigned long)PNG_IMAGE_SIZE(image));
|
||||
}
|
||||
|
||||
else
|
||||
/* Failed to read the first argument: */
|
||||
fprintf(stderr, "pngtopng: %s: %s\n", argv[1], image.message);
|
||||
}
|
||||
|
||||
else
|
||||
/* Wrong number of arguments */
|
||||
fprintf(stderr, "pngtopng: usage: pngtopng input-file output-file\n");
|
||||
|
||||
return result;
|
||||
}
|
||||
@@ -23,9 +23,9 @@
|
||||
|
||||
# macros --------------------------------------------------------------------
|
||||
|
||||
PNGINC = -I/usr/local/include/libpng15
|
||||
PNGLIB = -L/usr/local/lib -lpng15 # dynamically linked against libpng
|
||||
#PNGLIB = /usr/local/lib/libpng15.a # statically linked against libpng
|
||||
PNGINC = -I/usr/local/include/libpng16
|
||||
PNGLIB = -L/usr/local/lib -lpng16 # dynamically linked against libpng
|
||||
#PNGLIB = /usr/local/lib/libpng16.a # statically linked against libpng
|
||||
# or:
|
||||
#PNGINC = -I../..
|
||||
#PNGLIB = -L../.. -lpng
|
||||
|
||||
@@ -26,14 +26,14 @@
|
||||
# macros --------------------------------------------------------------------
|
||||
|
||||
#PNGDIR = /usr/local/lib
|
||||
#PNGINC = -I/usr/local/include/libpng15
|
||||
#PNGLIBd = -L$(PNGDIR) -lpng15 # dynamically linked, installed libpng
|
||||
#PNGLIBs = $(PNGDIR)/libpng15.a # statically linked, installed libpng
|
||||
#PNGINC = -I/usr/local/include/libpng16
|
||||
#PNGLIBd = -L$(PNGDIR) -lpng16 # dynamically linked, installed libpng
|
||||
#PNGLIBs = $(PNGDIR)/libpng16.a # statically linked, installed libpng
|
||||
# or:
|
||||
PNGDIR = ../..# this one is for libpng-x.y.z/contrib/gregbook builds
|
||||
#PNGDIR = ../libpng
|
||||
PNGINC = -I$(PNGDIR)
|
||||
PNGLIBd = -Wl,-rpath,$(PNGDIR) -L$(PNGDIR) -lpng15 # dynamically linked
|
||||
PNGLIBd = -Wl,-rpath,$(PNGDIR) -L$(PNGDIR) -lpng16 # dynamically linked
|
||||
PNGLIBs = $(PNGDIR)/libpng.a # statically linked, local libpng
|
||||
|
||||
ZDIR = /usr/local/lib
|
||||
|
||||
@@ -136,29 +136,23 @@ int readpng2_init(mainprog_info *mainprog_ptr)
|
||||
* used, i.e., all chunks recognized by libpng except for IHDR, PLTE, IDAT,
|
||||
* IEND, tRNS, bKGD, gAMA, and sRGB (small performance improvement) */
|
||||
{
|
||||
/* These byte strings were copied from png.h. If a future libpng
|
||||
* version recognizes more chunks, add them to this list. If a
|
||||
* future version of readpng2.c recognizes more chunks, delete them
|
||||
* from this list. */
|
||||
static /* const */ png_byte chunks_to_ignore[] = {
|
||||
99, 72, 82, 77, '\0', /* cHRM */
|
||||
104, 73, 83, 84, '\0', /* hIST */
|
||||
105, 67, 67, 80, '\0', /* iCCP */
|
||||
105, 84, 88, 116, '\0', /* iTXt */
|
||||
111, 70, 70, 115, '\0', /* oFFs */
|
||||
112, 67, 65, 76, '\0', /* pCAL */
|
||||
112, 72, 89, 115, '\0', /* pHYs */
|
||||
115, 66, 73, 84, '\0', /* sBIT */
|
||||
115, 67, 65, 76, '\0', /* sCAL */
|
||||
115, 80, 76, 84, '\0', /* sPLT */
|
||||
115, 84, 69, 82, '\0', /* sTER */
|
||||
116, 69, 88, 116, '\0', /* tEXt */
|
||||
116, 73, 77, 69, '\0', /* tIME */
|
||||
122, 84, 88, 116, '\0' /* zTXt */
|
||||
};
|
||||
/* These byte strings were copied from png.h. If a future version
|
||||
* of readpng2.c recognizes more chunks, add them to this list.
|
||||
*/
|
||||
static PNG_CONST png_byte chunks_to_process[] = {
|
||||
98, 75, 71, 68, '\0', /* bKGD */
|
||||
103, 65, 77, 65, '\0', /* gAMA */
|
||||
115, 82, 71, 66, '\0', /* sRGB */
|
||||
};
|
||||
|
||||
png_set_keep_unknown_chunks(png_ptr, 1 /* PNG_HANDLE_CHUNK_NEVER */,
|
||||
chunks_to_ignore, sizeof(chunks_to_ignore)/5);
|
||||
/* Ignore all chunks except for IHDR, PLTE, tRNS, IDAT, and IEND */
|
||||
png_set_keep_unknown_chunks(png_ptr, -1 /* PNG_HANDLE_CHUNK_NEVER */,
|
||||
NULL, -1);
|
||||
|
||||
/* But do not ignore chunks in the "chunks_to_process" list */
|
||||
png_set_keep_unknown_chunks(png_ptr,
|
||||
0 /* PNG_HANDLE_CHUNK_AS_DEFAULT */, chunks_to_process,
|
||||
sizeof(chunks_to_process)/5);
|
||||
}
|
||||
#endif /* PNG_HANDLE_AS_UNKNOWN_SUPPORTED */
|
||||
|
||||
|
||||
57
contrib/libtests/fakepng.c
Normal file
57
contrib/libtests/fakepng.c
Normal file
@@ -0,0 +1,57 @@
|
||||
/* Fake a PNG - just write it out directly. */
|
||||
#include <stdio.h>
|
||||
#include <zlib.h> /* for crc32 */
|
||||
|
||||
void
|
||||
put_uLong(uLong val)
|
||||
{
|
||||
putchar(val >> 24);
|
||||
putchar(val >> 16);
|
||||
putchar(val >> 8);
|
||||
putchar(val >> 0);
|
||||
}
|
||||
|
||||
void
|
||||
put_chunk(const unsigned char *chunk, uInt length)
|
||||
{
|
||||
uLong crc;
|
||||
|
||||
put_uLong(length-4); /* Exclude the tag */
|
||||
|
||||
fwrite(chunk, length, 1, stdout);
|
||||
|
||||
crc = crc32(0, Z_NULL, 0);
|
||||
put_uLong(crc32(crc, chunk, length));
|
||||
}
|
||||
|
||||
const unsigned char signature[] =
|
||||
{
|
||||
137, 80, 78, 71, 13, 10, 26, 10
|
||||
};
|
||||
|
||||
const unsigned char IHDR[] =
|
||||
{
|
||||
73, 72, 68, 82, /* IHDR */
|
||||
0, 0, 0, 1, /* width */
|
||||
0, 0, 0, 1, /* height */
|
||||
1, /* bit depth */
|
||||
0, /* color type: greyscale */
|
||||
0, /* compression method */
|
||||
0, /* filter method */
|
||||
0 /* interlace method: none */
|
||||
};
|
||||
|
||||
const unsigned char unknown[] =
|
||||
{
|
||||
'u', 'n', 'K', 'n' /* "unKn" - private safe to copy */
|
||||
};
|
||||
|
||||
int
|
||||
main(void)
|
||||
{
|
||||
fwrite(signature, sizeof signature, 1, stdout);
|
||||
put_chunk(IHDR, sizeof IHDR);
|
||||
|
||||
for(;;)
|
||||
put_chunk(unknown, sizeof unknown);
|
||||
}
|
||||
102
contrib/libtests/gentests.sh
Executable file
102
contrib/libtests/gentests.sh
Executable file
@@ -0,0 +1,102 @@
|
||||
#!/bin/sh
|
||||
#
|
||||
# Copyright (c) 2013 John Cunningham Bowler
|
||||
#
|
||||
# Last changed in libpng 1.6.0 [February 14, 2013]
|
||||
#
|
||||
# This code is released under the libpng license.
|
||||
# For conditions of distribution and use, see the disclaimer
|
||||
# and license in png.h
|
||||
#
|
||||
# Generate a set of PNG test images. The images are generated in a
|
||||
# sub-directory called 'tests' by default, however a command line argument will
|
||||
# change that name. The generation requires a built version of makepng in the
|
||||
# current directory.
|
||||
#
|
||||
usage(){
|
||||
exec >&2
|
||||
echo "$0 [<directory>]"
|
||||
echo ' Generate a set of PNG test files in "directory" ("tests" by default)'
|
||||
exit 1
|
||||
}
|
||||
|
||||
mp="$PWD/makepng"
|
||||
test -x "$mp" || {
|
||||
exec >&2
|
||||
echo "$0: the 'makepng' program must exist"
|
||||
echo " in the directory within which this program:"
|
||||
echo " $mp"
|
||||
echo " is executed"
|
||||
usage
|
||||
}
|
||||
|
||||
# Just one argument: the directory
|
||||
testdir="tests"
|
||||
test $# -gt 1 && {
|
||||
testdir="$1"
|
||||
shift
|
||||
}
|
||||
test $# -eq 0 || usage
|
||||
|
||||
# Take care not to clobber something
|
||||
if test -e "$testdir"
|
||||
then
|
||||
test -d "$testdir" || usage
|
||||
else
|
||||
# mkdir -p isn't portable, so do the following
|
||||
mkdir "$testdir" 2>/dev/null || mkdir -p "$testdir" || usage
|
||||
fi
|
||||
|
||||
# This fails in a very satisfactory way if it's not accessible
|
||||
cd "$testdir"
|
||||
:>"test$$.png" || {
|
||||
exec >&2
|
||||
echo "$testdir: directory not writable"
|
||||
usage
|
||||
}
|
||||
rm "test$$.png" || {
|
||||
exec >&2
|
||||
echo "$testdir: you have create but not write privileges here."
|
||||
echo " This is unexpected. You have a spurion; "'"'"test$$.png"'"'"."
|
||||
echo " You need to remove this yourself. Try a different directory."
|
||||
exit 1
|
||||
}
|
||||
|
||||
# Now call makepng ($mp) to create every file we can think of with a
|
||||
# reasonable name
|
||||
doit(){
|
||||
for gamma in "" --sRGB --linear --1.8
|
||||
do
|
||||
case "$gamma" in
|
||||
"")
|
||||
gname=;;
|
||||
--sRGB)
|
||||
gname="-srgb";;
|
||||
--linear)
|
||||
gname="-lin";;
|
||||
--1.8)
|
||||
gname="-18";;
|
||||
*)
|
||||
gname="-$gamma";;
|
||||
esac
|
||||
"$mp" $gamma "$1" "$2" "test-$1-$2$gname.png"
|
||||
done
|
||||
}
|
||||
#
|
||||
for ct in gray palette
|
||||
do
|
||||
for bd in 1 2 4 8
|
||||
do
|
||||
doit "$ct" "$bd"
|
||||
done
|
||||
done
|
||||
#
|
||||
doit "gray" "16"
|
||||
#
|
||||
for ct in gray-alpha rgb rgb-alpha
|
||||
do
|
||||
for bd in 8 16
|
||||
do
|
||||
doit "$ct" "$bd"
|
||||
done
|
||||
done
|
||||
1486
contrib/libtests/makepng.c
Normal file
1486
contrib/libtests/makepng.c
Normal file
File diff suppressed because it is too large
Load Diff
3700
contrib/libtests/pngstest.c
Normal file
3700
contrib/libtests/pngstest.c
Normal file
File diff suppressed because it is too large
Load Diff
960
contrib/libtests/pngunknown.c
Normal file
960
contrib/libtests/pngunknown.c
Normal file
@@ -0,0 +1,960 @@
|
||||
|
||||
/* pngunknown.c - test the read side unknown chunk handling
|
||||
*
|
||||
* Last changed in libpng 1.6.0 [(PENDING RELEASE)]
|
||||
* Copyright (c) 2013 Glenn Randers-Pehrson
|
||||
* Written by John Cunningham Bowler
|
||||
*
|
||||
* This code is released under the libpng license.
|
||||
* For conditions of distribution and use, see the disclaimer
|
||||
* and license in png.h
|
||||
*
|
||||
* NOTES:
|
||||
* This is a C program that is intended to be linked against libpng. It
|
||||
* allows the libpng unknown handling code to be tested by interpreting
|
||||
* arguments to save or discard combinations of chunks. The program is
|
||||
* currently just a minimal validation for the built-in libpng facilities.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <setjmp.h>
|
||||
|
||||
/* Define the following to use this test against your installed libpng, rather
|
||||
* than the one being built here:
|
||||
*/
|
||||
#ifdef PNG_FREESTANDING_TESTS
|
||||
# include <png.h>
|
||||
#else
|
||||
# include "../../png.h"
|
||||
#endif
|
||||
|
||||
#ifdef PNG_READ_SUPPORTED
|
||||
|
||||
#if PNG_LIBPNG_VER < 10500
|
||||
/* This deliberately lacks the PNG_CONST. */
|
||||
typedef png_byte *png_const_bytep;
|
||||
|
||||
/* This is copied from 1.5.1 png.h: */
|
||||
#define PNG_INTERLACE_ADAM7_PASSES 7
|
||||
#define PNG_PASS_START_ROW(pass) (((1U&~(pass))<<(3-((pass)>>1)))&7)
|
||||
#define PNG_PASS_START_COL(pass) (((1U& (pass))<<(3-(((pass)+1)>>1)))&7)
|
||||
#define PNG_PASS_ROW_SHIFT(pass) ((pass)>2?(8-(pass))>>1:3)
|
||||
#define PNG_PASS_COL_SHIFT(pass) ((pass)>1?(7-(pass))>>1:3)
|
||||
#define PNG_PASS_ROWS(height, pass) (((height)+(((1<<PNG_PASS_ROW_SHIFT(pass))\
|
||||
-1)-PNG_PASS_START_ROW(pass)))>>PNG_PASS_ROW_SHIFT(pass))
|
||||
#define PNG_PASS_COLS(width, pass) (((width)+(((1<<PNG_PASS_COL_SHIFT(pass))\
|
||||
-1)-PNG_PASS_START_COL(pass)))>>PNG_PASS_COL_SHIFT(pass))
|
||||
#define PNG_ROW_FROM_PASS_ROW(yIn, pass) \
|
||||
(((yIn)<<PNG_PASS_ROW_SHIFT(pass))+PNG_PASS_START_ROW(pass))
|
||||
#define PNG_COL_FROM_PASS_COL(xIn, pass) \
|
||||
(((xIn)<<PNG_PASS_COL_SHIFT(pass))+PNG_PASS_START_COL(pass))
|
||||
#define PNG_PASS_MASK(pass,off) ( \
|
||||
((0x110145AFU>>(((7-(off))-(pass))<<2)) & 0xFU) | \
|
||||
((0x01145AF0U>>(((7-(off))-(pass))<<2)) & 0xF0U))
|
||||
#define PNG_ROW_IN_INTERLACE_PASS(y, pass) \
|
||||
((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1)
|
||||
#define PNG_COL_IN_INTERLACE_PASS(x, pass) \
|
||||
((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1)
|
||||
|
||||
/* These are needed too for the default build: */
|
||||
#define PNG_WRITE_16BIT_SUPPORTED
|
||||
#define PNG_READ_16BIT_SUPPORTED
|
||||
|
||||
/* This comes from pnglibconf.h afer 1.5: */
|
||||
#define PNG_FP_1 100000
|
||||
#define PNG_GAMMA_THRESHOLD_FIXED\
|
||||
((png_fixed_point)(PNG_GAMMA_THRESHOLD * PNG_FP_1))
|
||||
#endif
|
||||
|
||||
#if PNG_LIBPNG_VER < 10600
|
||||
/* 1.6.0 constifies many APIs. The following exists to allow pngvalid to be
|
||||
* compiled against earlier versions.
|
||||
*/
|
||||
# define png_const_structp png_structp
|
||||
#endif
|
||||
|
||||
|
||||
/* Copied from pngpriv.h */
|
||||
#define PNG_32b(b,s) ((png_uint_32)(b) << (s))
|
||||
#define PNG_CHUNK(b1,b2,b3,b4) \
|
||||
(PNG_32b(b1,24) | PNG_32b(b2,16) | PNG_32b(b3,8) | PNG_32b(b4,0))
|
||||
|
||||
#define png_IHDR PNG_CHUNK( 73, 72, 68, 82)
|
||||
#define png_IDAT PNG_CHUNK( 73, 68, 65, 84)
|
||||
#define png_IEND PNG_CHUNK( 73, 69, 78, 68)
|
||||
#define png_PLTE PNG_CHUNK( 80, 76, 84, 69)
|
||||
#define png_bKGD PNG_CHUNK( 98, 75, 71, 68)
|
||||
#define png_cHRM PNG_CHUNK( 99, 72, 82, 77)
|
||||
#define png_gAMA PNG_CHUNK(103, 65, 77, 65)
|
||||
#define png_hIST PNG_CHUNK(104, 73, 83, 84)
|
||||
#define png_iCCP PNG_CHUNK(105, 67, 67, 80)
|
||||
#define png_iTXt PNG_CHUNK(105, 84, 88, 116)
|
||||
#define png_oFFs PNG_CHUNK(111, 70, 70, 115)
|
||||
#define png_pCAL PNG_CHUNK(112, 67, 65, 76)
|
||||
#define png_sCAL PNG_CHUNK(115, 67, 65, 76)
|
||||
#define png_pHYs PNG_CHUNK(112, 72, 89, 115)
|
||||
#define png_sBIT PNG_CHUNK(115, 66, 73, 84)
|
||||
#define png_sPLT PNG_CHUNK(115, 80, 76, 84)
|
||||
#define png_sRGB PNG_CHUNK(115, 82, 71, 66)
|
||||
#define png_sTER PNG_CHUNK(115, 84, 69, 82)
|
||||
#define png_tEXt PNG_CHUNK(116, 69, 88, 116)
|
||||
#define png_tIME PNG_CHUNK(116, 73, 77, 69)
|
||||
#define png_tRNS PNG_CHUNK(116, 82, 78, 83)
|
||||
#define png_zTXt PNG_CHUNK(122, 84, 88, 116)
|
||||
#define png_vpAg PNG_CHUNK('v', 'p', 'A', 'g')
|
||||
|
||||
/* Test on flag values as defined in the spec (section 5.4): */
|
||||
#define PNG_CHUNK_ANCILLARY(c ) (1 & ((c) >> 29))
|
||||
#define PNG_CHUNK_CRITICAL(c) (!PNG_CHUNK_ANCILLARY(c))
|
||||
#define PNG_CHUNK_PRIVATE(c) (1 & ((c) >> 21))
|
||||
#define PNG_CHUNK_RESERVED(c) (1 & ((c) >> 13))
|
||||
#define PNG_CHUNK_SAFE_TO_COPY(c) (1 & ((c) >> 5))
|
||||
|
||||
/* Chunk information */
|
||||
#define PNG_INFO_tEXt 0x10000000U
|
||||
#define PNG_INFO_iTXt 0x20000000U
|
||||
#define PNG_INFO_zTXt 0x40000000U
|
||||
|
||||
#define PNG_INFO_sTER 0x01000000U
|
||||
#define PNG_INFO_vpAg 0x02000000U
|
||||
|
||||
#define ABSENT 0
|
||||
#define START 1
|
||||
#define END 2
|
||||
|
||||
static struct
|
||||
{
|
||||
char name[5];
|
||||
png_uint_32 flag;
|
||||
png_uint_32 tag;
|
||||
int unknown; /* Chunk not known to libpng */
|
||||
int all; /* Chunk set by the '-1' option */
|
||||
int position; /* position in pngtest.png */
|
||||
int keep; /* unknown handling setting */
|
||||
} chunk_info[] = {
|
||||
/* Critical chunks */
|
||||
{ "IDAT", PNG_INFO_IDAT, png_IDAT, 0, 0, START, 0 }, /* must be [0] */
|
||||
{ "PLTE", PNG_INFO_PLTE, png_PLTE, 0, 0, ABSENT, 0 },
|
||||
|
||||
/* Non-critical chunks that libpng handles */
|
||||
{ "bKGD", PNG_INFO_bKGD, png_bKGD, 0, 1, START, 0 },
|
||||
{ "cHRM", PNG_INFO_cHRM, png_cHRM, 0, 1, START, 0 },
|
||||
{ "gAMA", PNG_INFO_gAMA, png_gAMA, 0, 1, START, 0 },
|
||||
{ "hIST", PNG_INFO_hIST, png_hIST, 0, 1, ABSENT, 0 },
|
||||
{ "iCCP", PNG_INFO_iCCP, png_iCCP, 0, 1, ABSENT, 0 },
|
||||
{ "iTXt", PNG_INFO_iTXt, png_iTXt, 0, 1, ABSENT, 0 },
|
||||
{ "oFFs", PNG_INFO_oFFs, png_oFFs, 0, 1, START, 0 },
|
||||
{ "pCAL", PNG_INFO_pCAL, png_pCAL, 0, 1, START, 0 },
|
||||
{ "pHYs", PNG_INFO_pHYs, png_pHYs, 0, 1, START, 0 },
|
||||
{ "sBIT", PNG_INFO_sBIT, png_sBIT, 0, 1, START, 0 },
|
||||
{ "sCAL", PNG_INFO_sCAL, png_sCAL, 0, 1, START, 0 },
|
||||
{ "sPLT", PNG_INFO_sPLT, png_sPLT, 0, 1, ABSENT, 0 },
|
||||
{ "sRGB", PNG_INFO_sRGB, png_sRGB, 0, 1, START, 0 },
|
||||
{ "tEXt", PNG_INFO_tEXt, png_tEXt, 0, 1, START, 0 },
|
||||
{ "tIME", PNG_INFO_tIME, png_tIME, 0, 1, START, 0 },
|
||||
{ "tRNS", PNG_INFO_tRNS, png_tRNS, 0, 0, ABSENT, 0 },
|
||||
{ "zTXt", PNG_INFO_zTXt, png_zTXt, 0, 1, END, 0 },
|
||||
|
||||
/* No libpng handling */
|
||||
{ "sTER", PNG_INFO_sTER, png_sTER, 1, 1, START, 0 },
|
||||
{ "vpAg", PNG_INFO_vpAg, png_vpAg, 1, 0, START, 0 },
|
||||
};
|
||||
|
||||
#define NINFO ((int)((sizeof chunk_info)/(sizeof chunk_info[0])))
|
||||
|
||||
static void
|
||||
clear_keep(void)
|
||||
{
|
||||
int i = NINFO;
|
||||
while (--i >= 0)
|
||||
chunk_info[i].keep = 0;
|
||||
}
|
||||
|
||||
static int
|
||||
find(const char *name)
|
||||
{
|
||||
int i = NINFO;
|
||||
while (--i >= 0)
|
||||
{
|
||||
if (memcmp(chunk_info[i].name, name, 4) == 0)
|
||||
break;
|
||||
}
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
static int
|
||||
findb(const png_byte *name)
|
||||
{
|
||||
int i = NINFO;
|
||||
while (--i >= 0)
|
||||
{
|
||||
if (memcmp(chunk_info[i].name, name, 4) == 0)
|
||||
break;
|
||||
}
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
static int
|
||||
find_by_flag(png_uint_32 flag)
|
||||
{
|
||||
int i = NINFO;
|
||||
|
||||
while (--i >= 0) if (chunk_info[i].flag == flag) return i;
|
||||
|
||||
fprintf(stderr, "pngunknown: internal error\n");
|
||||
exit(4);
|
||||
}
|
||||
|
||||
static int
|
||||
ancillary(const char *name)
|
||||
{
|
||||
return PNG_CHUNK_ANCILLARY(PNG_CHUNK(name[0], name[1], name[2], name[3]));
|
||||
}
|
||||
|
||||
static int
|
||||
ancillaryb(const png_byte *name)
|
||||
{
|
||||
return PNG_CHUNK_ANCILLARY(PNG_CHUNK(name[0], name[1], name[2], name[3]));
|
||||
}
|
||||
|
||||
/* Type of an error_ptr */
|
||||
typedef struct
|
||||
{
|
||||
jmp_buf error_return;
|
||||
png_structp png_ptr;
|
||||
png_infop info_ptr, end_ptr;
|
||||
int error_count;
|
||||
int warning_count;
|
||||
const char *program;
|
||||
const char *file;
|
||||
const char *test;
|
||||
} display;
|
||||
|
||||
static const char init[] = "initialization";
|
||||
static const char cmd[] = "command line";
|
||||
|
||||
static void
|
||||
init_display(display *d, const char *program)
|
||||
{
|
||||
memset(d, 0, sizeof *d);
|
||||
d->png_ptr = NULL;
|
||||
d->info_ptr = d->end_ptr = NULL;
|
||||
d->error_count = d->warning_count = 0;
|
||||
d->program = program;
|
||||
d->file = program;
|
||||
d->test = init;
|
||||
}
|
||||
|
||||
static void
|
||||
clean_display(display *d)
|
||||
{
|
||||
png_destroy_read_struct(&d->png_ptr, &d->info_ptr, &d->end_ptr);
|
||||
|
||||
/* This must not happen - it might cause an app crash */
|
||||
if (d->png_ptr != NULL || d->info_ptr != NULL || d->end_ptr != NULL)
|
||||
{
|
||||
fprintf(stderr, "%s(%s): png_destroy_read_struct error\n", d->file,
|
||||
d->test);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
/* Invalidate the test */
|
||||
d->test = init;
|
||||
}
|
||||
|
||||
PNG_FUNCTION(void, display_exit, (display *d), static PNG_NORETURN)
|
||||
{
|
||||
++(d->error_count);
|
||||
|
||||
if (d->png_ptr != NULL)
|
||||
clean_display(d);
|
||||
|
||||
/* During initialization and if this is a single command line argument set
|
||||
* exit now - there is only one test, otherwise longjmp to do the next test.
|
||||
*/
|
||||
if (d->test == init || d->test == cmd)
|
||||
exit(1);
|
||||
|
||||
longjmp(d->error_return, 1);
|
||||
}
|
||||
|
||||
static int
|
||||
display_rc(const display *d, int strict)
|
||||
{
|
||||
return d->error_count + (strict ? d->warning_count : 0);
|
||||
}
|
||||
|
||||
/* libpng error and warning callbacks */
|
||||
PNG_FUNCTION(void, error, (png_structp png_ptr, const char *message),
|
||||
static PNG_NORETURN)
|
||||
{
|
||||
display *d = (display*)png_get_error_ptr(png_ptr);
|
||||
|
||||
fprintf(stderr, "%s(%s): libpng error: %s\n", d->file, d->test, message);
|
||||
display_exit(d);
|
||||
}
|
||||
|
||||
static void
|
||||
warning(png_structp png_ptr, const char *message)
|
||||
{
|
||||
display *d = (display*)png_get_error_ptr(png_ptr);
|
||||
|
||||
fprintf(stderr, "%s(%s): libpng warning: %s\n", d->file, d->test, message);
|
||||
++(d->warning_count);
|
||||
}
|
||||
|
||||
static png_uint_32
|
||||
get_valid(display *d, png_infop info_ptr)
|
||||
{
|
||||
png_uint_32 flags = png_get_valid(d->png_ptr, info_ptr, (png_uint_32)~0);
|
||||
|
||||
/* Map the text chunks back into the flags */
|
||||
{
|
||||
png_textp text;
|
||||
png_uint_32 ntext = png_get_text(d->png_ptr, info_ptr, &text, NULL);
|
||||
|
||||
while (ntext-- > 0) switch (text[ntext].compression)
|
||||
{
|
||||
case -1:
|
||||
flags |= PNG_INFO_tEXt;
|
||||
break;
|
||||
case 0:
|
||||
flags |= PNG_INFO_zTXt;
|
||||
break;
|
||||
case 1:
|
||||
case 2:
|
||||
flags |= PNG_INFO_iTXt;
|
||||
break;
|
||||
default:
|
||||
fprintf(stderr, "%s(%s): unknown text compression %d\n", d->file,
|
||||
d->test, text[ntext].compression);
|
||||
display_exit(d);
|
||||
}
|
||||
}
|
||||
|
||||
return flags;
|
||||
}
|
||||
|
||||
static png_uint_32
|
||||
get_unknown(display *d, int def, png_infop info_ptr)
|
||||
{
|
||||
/* Create corresponding 'unknown' flags */
|
||||
png_uint_32 flags = 0;
|
||||
{
|
||||
png_unknown_chunkp unknown;
|
||||
int num_unknown = png_get_unknown_chunks(d->png_ptr, info_ptr, &unknown);
|
||||
|
||||
while (--num_unknown >= 0)
|
||||
{
|
||||
int chunk = findb(unknown[num_unknown].name);
|
||||
|
||||
/* Chunks not known to pngunknown must be validated here; since they
|
||||
* must also be unknown to libpng the 'def' behavior should have been
|
||||
* used.
|
||||
*/
|
||||
if (chunk < 0) switch (def)
|
||||
{
|
||||
default: /* impossible */
|
||||
case PNG_HANDLE_CHUNK_AS_DEFAULT:
|
||||
case PNG_HANDLE_CHUNK_NEVER:
|
||||
fprintf(stderr, "%s(%s): %s: %s: unknown chunk saved\n",
|
||||
d->file, d->test, def ? "discard" : "default",
|
||||
unknown[num_unknown].name);
|
||||
++(d->error_count);
|
||||
break;
|
||||
|
||||
case PNG_HANDLE_CHUNK_IF_SAFE:
|
||||
if (!ancillaryb(unknown[num_unknown].name))
|
||||
{
|
||||
fprintf(stderr,
|
||||
"%s(%s): if-safe: %s: unknown critical chunk saved\n",
|
||||
d->file, d->test, unknown[num_unknown].name);
|
||||
++(d->error_count);
|
||||
break;
|
||||
}
|
||||
/* FALL THROUGH (safe) */
|
||||
case PNG_HANDLE_CHUNK_ALWAYS:
|
||||
break;
|
||||
}
|
||||
|
||||
else
|
||||
flags |= chunk_info[chunk].flag;
|
||||
}
|
||||
}
|
||||
|
||||
return flags;
|
||||
}
|
||||
|
||||
static int
|
||||
check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/,
|
||||
display *d)
|
||||
{
|
||||
int i, def = PNG_HANDLE_CHUNK_AS_DEFAULT, npasses, ipass;
|
||||
png_uint_32 height;
|
||||
|
||||
/* Some of these errors are permanently fatal and cause an exit here, others
|
||||
* are per-test and cause an error return.
|
||||
*/
|
||||
d->png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, d, error,
|
||||
warning);
|
||||
if (d->png_ptr == NULL)
|
||||
{
|
||||
fprintf(stderr, "%s(%s): could not allocate png struct\n", d->file,
|
||||
d->test);
|
||||
/* Terminate here, this error is not test specific. */
|
||||
exit(1);
|
||||
}
|
||||
|
||||
d->info_ptr = png_create_info_struct(d->png_ptr);
|
||||
d->end_ptr = png_create_info_struct(d->png_ptr);
|
||||
if (d->info_ptr == NULL || d->end_ptr == NULL)
|
||||
{
|
||||
fprintf(stderr, "%s(%s): could not allocate png info\n", d->file,
|
||||
d->test);
|
||||
clean_display(d);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
png_init_io(d->png_ptr, fp);
|
||||
|
||||
/* Handle each argument in turn; multiple settings are possible for the same
|
||||
* chunk and multiple calls will occur (the last one should override all
|
||||
* preceding ones).
|
||||
*/
|
||||
for (i=0; i<argc; ++i)
|
||||
{
|
||||
const char *equals = strchr(argv[i], '=');
|
||||
|
||||
if (equals != NULL)
|
||||
{
|
||||
int chunk, option;
|
||||
|
||||
if (strcmp(equals+1, "default") == 0)
|
||||
option = PNG_HANDLE_CHUNK_AS_DEFAULT;
|
||||
else if (strcmp(equals+1, "discard") == 0)
|
||||
option = PNG_HANDLE_CHUNK_NEVER;
|
||||
else if (strcmp(equals+1, "if-safe") == 0)
|
||||
option = PNG_HANDLE_CHUNK_IF_SAFE;
|
||||
else if (strcmp(equals+1, "save") == 0)
|
||||
option = PNG_HANDLE_CHUNK_ALWAYS;
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "%s(%s): %s: unrecognized chunk option\n", d->file,
|
||||
d->test, argv[i]);
|
||||
display_exit(d);
|
||||
}
|
||||
|
||||
switch (equals - argv[i])
|
||||
{
|
||||
case 4: /* chunk name */
|
||||
chunk = find(argv[i]);
|
||||
|
||||
if (chunk >= 0)
|
||||
{
|
||||
/* These #if tests have the effect of skipping the arguments
|
||||
* if SAVE support is unavailable - we can't do a useful test
|
||||
* in this case, so we just check the arguments! This could
|
||||
* be improved in the future by using the read callback.
|
||||
*/
|
||||
# ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
|
||||
png_byte name[5];
|
||||
|
||||
memcpy(name, chunk_info[chunk].name, 5);
|
||||
png_set_keep_unknown_chunks(d->png_ptr, option, name, 1);
|
||||
chunk_info[chunk].keep = option;
|
||||
# endif
|
||||
continue;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case 7: /* default */
|
||||
if (memcmp(argv[i], "default", 7) == 0)
|
||||
{
|
||||
# ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
|
||||
png_set_keep_unknown_chunks(d->png_ptr, option, NULL, 0);
|
||||
# endif
|
||||
def = option;
|
||||
continue;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case 3: /* all */
|
||||
if (memcmp(argv[i], "all", 3) == 0)
|
||||
{
|
||||
# ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
|
||||
png_set_keep_unknown_chunks(d->png_ptr, option, NULL, -1);
|
||||
def = option;
|
||||
|
||||
for (chunk = 0; chunk < NINFO; ++chunk)
|
||||
if (chunk_info[chunk].all)
|
||||
chunk_info[chunk].keep = option;
|
||||
# endif
|
||||
continue;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
default: /* some misplaced = */
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
fprintf(stderr, "%s(%s): %s: unrecognized chunk argument\n", d->file,
|
||||
d->test, argv[i]);
|
||||
display_exit(d);
|
||||
}
|
||||
|
||||
png_read_info(d->png_ptr, d->info_ptr);
|
||||
|
||||
switch (png_get_interlace_type(d->png_ptr, d->info_ptr))
|
||||
{
|
||||
case PNG_INTERLACE_NONE:
|
||||
npasses = 1;
|
||||
break;
|
||||
|
||||
case PNG_INTERLACE_ADAM7:
|
||||
npasses = PNG_INTERLACE_ADAM7_PASSES;
|
||||
break;
|
||||
|
||||
default:
|
||||
/* Hard error because it is not test specific */
|
||||
fprintf(stderr, "%s(%s): invalid interlace type\n", d->file, d->test);
|
||||
clean_display(d);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
/* Skip the image data, if IDAT is not being handled then don't do this
|
||||
* because it will cause a CRC error.
|
||||
*/
|
||||
if (chunk_info[0/*IDAT*/].keep == PNG_HANDLE_CHUNK_AS_DEFAULT)
|
||||
{
|
||||
png_start_read_image(d->png_ptr);
|
||||
height = png_get_image_height(d->png_ptr, d->info_ptr);
|
||||
|
||||
if (npasses > 1)
|
||||
{
|
||||
png_uint_32 width = png_get_image_width(d->png_ptr, d->info_ptr);
|
||||
|
||||
for (ipass=0; ipass<npasses; ++ipass)
|
||||
{
|
||||
png_uint_32 wPass = PNG_PASS_COLS(width, ipass);
|
||||
|
||||
if (wPass > 0)
|
||||
{
|
||||
png_uint_32 y;
|
||||
|
||||
for (y=0; y<height; ++y) if (PNG_ROW_IN_INTERLACE_PASS(y, ipass))
|
||||
png_read_row(d->png_ptr, NULL, NULL);
|
||||
}
|
||||
}
|
||||
} /* interlaced */
|
||||
|
||||
else /* not interlaced */
|
||||
{
|
||||
png_uint_32 y;
|
||||
|
||||
for (y=0; y<height; ++y)
|
||||
png_read_row(d->png_ptr, NULL, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
png_read_end(d->png_ptr, d->end_ptr);
|
||||
|
||||
flags[0] = get_valid(d, d->info_ptr);
|
||||
flags[1] = get_unknown(d, def, d->info_ptr);
|
||||
|
||||
/* Only png_read_png sets PNG_INFO_IDAT! */
|
||||
flags[chunk_info[0/*IDAT*/].keep != PNG_HANDLE_CHUNK_AS_DEFAULT] |=
|
||||
PNG_INFO_IDAT;
|
||||
|
||||
flags[2] = get_valid(d, d->end_ptr);
|
||||
flags[3] = get_unknown(d, def, d->end_ptr);
|
||||
|
||||
clean_display(d);
|
||||
|
||||
return def;
|
||||
}
|
||||
|
||||
static void
|
||||
check_error(display *d, png_uint_32 flags, const char *message)
|
||||
{
|
||||
while (flags)
|
||||
{
|
||||
png_uint_32 flag = flags & -(png_int_32)flags;
|
||||
int i = find_by_flag(flag);
|
||||
|
||||
fprintf(stderr, "%s(%s): chunk %s: %s\n", d->file, d->test,
|
||||
chunk_info[i].name, message);
|
||||
++(d->error_count);
|
||||
|
||||
flags &= ~flag;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
check_handling(display *d, int def, png_uint_32 chunks, png_uint_32 known,
|
||||
png_uint_32 unknown, const char *position)
|
||||
{
|
||||
while (chunks)
|
||||
{
|
||||
png_uint_32 flag = chunks & -(png_int_32)chunks;
|
||||
int i = find_by_flag(flag);
|
||||
int keep = chunk_info[i].keep;
|
||||
const char *type;
|
||||
const char *errorx = NULL;
|
||||
|
||||
if (chunk_info[i].unknown)
|
||||
{
|
||||
if (keep == PNG_HANDLE_CHUNK_AS_DEFAULT)
|
||||
{
|
||||
type = "UNKNOWN (default)";
|
||||
keep = def;
|
||||
}
|
||||
|
||||
else
|
||||
type = "UNKNOWN (specified)";
|
||||
|
||||
if (flag & known)
|
||||
errorx = "chunk processed";
|
||||
|
||||
else switch (keep)
|
||||
{
|
||||
case PNG_HANDLE_CHUNK_AS_DEFAULT:
|
||||
if (flag & unknown)
|
||||
errorx = "DEFAULT: unknown chunk saved";
|
||||
break;
|
||||
|
||||
case PNG_HANDLE_CHUNK_NEVER:
|
||||
if (flag & unknown)
|
||||
errorx = "DISCARD: unknown chunk saved";
|
||||
break;
|
||||
|
||||
case PNG_HANDLE_CHUNK_IF_SAFE:
|
||||
if (ancillary(chunk_info[i].name))
|
||||
{
|
||||
if (!(flag & unknown))
|
||||
errorx = "IF-SAFE: unknown ancillary chunk lost";
|
||||
}
|
||||
|
||||
else if (flag & unknown)
|
||||
errorx = "IF-SAFE: unknown critical chunk saved";
|
||||
break;
|
||||
|
||||
case PNG_HANDLE_CHUNK_ALWAYS:
|
||||
if (!(flag & unknown))
|
||||
errorx = "SAVE: unknown chunk lost";
|
||||
break;
|
||||
|
||||
default:
|
||||
errorx = "internal error: bad keep";
|
||||
break;
|
||||
}
|
||||
} /* unknown chunk */
|
||||
|
||||
else /* known chunk */
|
||||
{
|
||||
type = "KNOWN";
|
||||
|
||||
if (flag & known)
|
||||
{
|
||||
/* chunk was processed, it won't have been saved because that is
|
||||
* caught below when checking for inconsistent processing.
|
||||
*/
|
||||
if (keep != PNG_HANDLE_CHUNK_AS_DEFAULT)
|
||||
errorx = "!DEFAULT: known chunk processed";
|
||||
}
|
||||
|
||||
else /* not processed */ switch (keep)
|
||||
{
|
||||
case PNG_HANDLE_CHUNK_AS_DEFAULT:
|
||||
errorx = "DEFAULT: known chunk not processed";
|
||||
break;
|
||||
|
||||
case PNG_HANDLE_CHUNK_NEVER:
|
||||
if (flag & unknown)
|
||||
errorx = "DISCARD: known chunk saved";
|
||||
break;
|
||||
|
||||
case PNG_HANDLE_CHUNK_IF_SAFE:
|
||||
if (ancillary(chunk_info[i].name))
|
||||
{
|
||||
if (!(flag & unknown))
|
||||
errorx = "IF-SAFE: known ancillary chunk lost";
|
||||
}
|
||||
|
||||
else if (flag & unknown)
|
||||
errorx = "IF-SAFE: known critical chunk saved";
|
||||
break;
|
||||
|
||||
case PNG_HANDLE_CHUNK_ALWAYS:
|
||||
if (!(flag & unknown))
|
||||
errorx = "SAVE: known chunk lost";
|
||||
break;
|
||||
|
||||
default:
|
||||
errorx = "internal error: bad keep (2)";
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (errorx != NULL)
|
||||
{
|
||||
++(d->error_count);
|
||||
fprintf(stderr, "%s(%s): %s %s %s: %s\n",
|
||||
d->file, d->test, type, chunk_info[i].name, position, errorx);
|
||||
}
|
||||
|
||||
chunks &= ~flag;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
perform_one_test(FILE *fp, int argc, const char **argv,
|
||||
png_uint_32 *default_flags, display *d)
|
||||
{
|
||||
int def;
|
||||
png_uint_32 flags[2][4];
|
||||
|
||||
rewind(fp);
|
||||
clear_keep();
|
||||
memcpy(flags[0], default_flags, sizeof flags[0]);
|
||||
|
||||
def = check(fp, argc, argv, flags[1], d);
|
||||
|
||||
/* Chunks should either be known or unknown, never both and this should apply
|
||||
* whether the chunk is before or after the IDAT (actually, the app can
|
||||
* probably change this by swapping the handling after the image, but this
|
||||
* test does not do that.)
|
||||
*/
|
||||
check_error(d, (flags[0][0]|flags[0][2]) & (flags[0][1]|flags[0][3]),
|
||||
"chunk handled inconsistently in count tests");
|
||||
check_error(d, (flags[1][0]|flags[1][2]) & (flags[1][1]|flags[1][3]),
|
||||
"chunk handled inconsistently in option tests");
|
||||
|
||||
/* Now find out what happened to each chunk before and after the IDAT and
|
||||
* determine if the behavior was correct. First some basic sanity checks,
|
||||
* any known chunk should be known in the original count, any unknown chunk
|
||||
* should be either known or unknown in the original.
|
||||
*/
|
||||
{
|
||||
png_uint_32 test;
|
||||
|
||||
test = flags[1][0] & ~flags[0][0];
|
||||
check_error(d, test, "new known chunk before IDAT");
|
||||
test = flags[1][1] & ~(flags[0][0] | flags[0][1]);
|
||||
check_error(d, test, "new unknown chunk before IDAT");
|
||||
test = flags[1][2] & ~flags[0][2];
|
||||
check_error(d, test, "new known chunk after IDAT");
|
||||
test = flags[1][3] & ~(flags[0][2] | flags[0][3]);
|
||||
check_error(d, test, "new unknown chunk after IDAT");
|
||||
}
|
||||
|
||||
/* Now each chunk in the original list should have been handled according to
|
||||
* the options set for that chunk, regardless of whether libpng knows about
|
||||
* it or not.
|
||||
*/
|
||||
check_handling(d, def, flags[0][0] | flags[0][1], flags[1][0], flags[1][1],
|
||||
"before IDAT");
|
||||
check_handling(d, def, flags[0][2] | flags[0][3], flags[1][2], flags[1][3],
|
||||
"after IDAT");
|
||||
}
|
||||
|
||||
static void
|
||||
perform_one_test_safe(FILE *fp, int argc, const char **argv,
|
||||
png_uint_32 *default_flags, display *d, const char *test)
|
||||
{
|
||||
if (setjmp(d->error_return) == 0)
|
||||
{
|
||||
d->test = test; /* allow use of d->error_return */
|
||||
perform_one_test(fp, argc, argv, default_flags, d);
|
||||
d->test = init; /* prevent use of d->error_return */
|
||||
}
|
||||
}
|
||||
|
||||
static const char *standard_tests[] =
|
||||
{
|
||||
"discard", "default=discard", 0,
|
||||
"save", "default=save", 0,
|
||||
"if-safe", "default=if-safe", 0,
|
||||
"vpAg", "vpAg=if-safe", 0,
|
||||
"sTER", "sTER=if-safe", 0,
|
||||
"IDAT", "default=discard", "IDAT=save", 0,
|
||||
"sAPI", "bKGD=save", "cHRM=save", "gAMA=save", "all=discard", "iCCP=save",
|
||||
"sBIT=save", "sRGB=save", 0,
|
||||
0/*end*/
|
||||
};
|
||||
|
||||
static PNG_NORETURN void
|
||||
usage(const char *program, const char *reason)
|
||||
{
|
||||
fprintf(stderr, "pngunknown: %s: usage:\n %s [--strict] "
|
||||
"--default|{(CHNK|default|all)=(default|discard|if-safe|save)} "
|
||||
"testfile.png\n", reason, program);
|
||||
exit(2);
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, const char **argv)
|
||||
{
|
||||
FILE *fp;
|
||||
png_uint_32 default_flags[4/*valid,unknown{before,after}*/];
|
||||
int strict = 0, default_tests = 0;
|
||||
const char *count_argv = "default=save";
|
||||
const char *touch_file = NULL;
|
||||
display d;
|
||||
|
||||
init_display(&d, argv[0]);
|
||||
|
||||
while (++argv, --argc > 0)
|
||||
{
|
||||
if (strcmp(*argv, "--strict") == 0)
|
||||
strict = 1;
|
||||
|
||||
else if (strcmp(*argv, "--default") == 0)
|
||||
default_tests = 1;
|
||||
|
||||
else if (strcmp(*argv, "--touch") == 0)
|
||||
{
|
||||
if (argc > 1)
|
||||
touch_file = *++argv, --argc;
|
||||
|
||||
else
|
||||
usage(d.program, "--touch: missing file name");
|
||||
}
|
||||
|
||||
else
|
||||
break;
|
||||
}
|
||||
|
||||
/* A file name is required, but there should be no other arguments if
|
||||
* --default was specified.
|
||||
*/
|
||||
if (argc <= 0)
|
||||
usage(d.program, "missing test file");
|
||||
|
||||
/* GCC BUG: if (default_tests && argc != 1) triggers some weird GCC argc
|
||||
* optimization which causes warnings with -Wstrict-overflow!
|
||||
*/
|
||||
else if (default_tests) if (argc != 1)
|
||||
usage(d.program, "extra arguments");
|
||||
|
||||
# ifndef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
|
||||
fprintf(stderr, "%s: warning: no 'save' support so arguments ignored\n",
|
||||
d.program);
|
||||
# endif
|
||||
|
||||
/* The name of the test file is the last argument; remove it. */
|
||||
d.file = argv[--argc];
|
||||
|
||||
fp = fopen(d.file, "rb");
|
||||
if (fp == NULL)
|
||||
{
|
||||
perror(d.file);
|
||||
exit(2);
|
||||
}
|
||||
|
||||
/* First find all the chunks, known and unknown, in the test file, a failure
|
||||
* here aborts the whole test.
|
||||
*/
|
||||
if (check(fp, 1, &count_argv, default_flags, &d) !=
|
||||
PNG_HANDLE_CHUNK_ALWAYS)
|
||||
{
|
||||
fprintf(stderr, "%s: %s: internal error\n", d.program, d.file);
|
||||
exit(3);
|
||||
}
|
||||
|
||||
/* Now find what the various supplied options cause to change: */
|
||||
if (!default_tests)
|
||||
{
|
||||
d.test = cmd; /* acts as a flag to say exit, do not longjmp */
|
||||
perform_one_test(fp, argc, argv, default_flags, &d);
|
||||
d.test = init;
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
const char **test = standard_tests;
|
||||
|
||||
/* Set the exit_test pointer here so we can continue after a libpng error.
|
||||
* NOTE: this leaks memory because the png_struct data from the failing
|
||||
* test is never freed.
|
||||
*/
|
||||
while (*test)
|
||||
{
|
||||
const char *this_test = *test++;
|
||||
const char **next = test;
|
||||
int count = display_rc(&d, strict), new_count;
|
||||
const char *result;
|
||||
int arg_count = 0;
|
||||
|
||||
while (*next) ++next, ++arg_count;
|
||||
|
||||
perform_one_test_safe(fp, arg_count, test, default_flags, &d,
|
||||
this_test);
|
||||
|
||||
new_count = display_rc(&d, strict);
|
||||
|
||||
if (new_count == count)
|
||||
result = "PASS";
|
||||
|
||||
else
|
||||
result = "FAIL";
|
||||
|
||||
printf("%s: %s %s\n", result, d.program, this_test);
|
||||
|
||||
test = next+1;
|
||||
}
|
||||
}
|
||||
|
||||
fclose(fp);
|
||||
|
||||
if (display_rc(&d, strict) == 0)
|
||||
{
|
||||
/* Success, touch the success file if appropriate */
|
||||
if (touch_file != NULL)
|
||||
{
|
||||
FILE *fsuccess = fopen(touch_file, "wt");
|
||||
|
||||
if (fsuccess != NULL)
|
||||
{
|
||||
int err = 0;
|
||||
fprintf(fsuccess, "PNG unknown tests succeeded\n");
|
||||
fflush(fsuccess);
|
||||
err = ferror(fsuccess);
|
||||
|
||||
if (fclose(fsuccess) || err)
|
||||
{
|
||||
fprintf(stderr, "%s: write failed\n", touch_file);
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "%s: open failed\n", touch_file);
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
#else
|
||||
int
|
||||
main(void)
|
||||
{
|
||||
fprintf(stderr,
|
||||
" test ignored because libpng was not built with unknown chunk support\n");
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
@@ -1,7 +1,7 @@
|
||||
|
||||
/* pngvalid.c - validate libpng by constructing then reading png files.
|
||||
*
|
||||
* Last changed in libpng 1.5.14 [%RDATE%]
|
||||
* Last changed in libpng 1.6.0 [February 14, 2013]
|
||||
* Copyright (c) 2013 Glenn Randers-Pehrson
|
||||
* Written by John Cunningham Bowler
|
||||
*
|
||||
@@ -4754,7 +4754,7 @@ standard_check_text(png_const_structp pp, png_const_textp tp,
|
||||
|
||||
static void
|
||||
standard_text_validate(standard_display *dp, png_const_structp pp,
|
||||
png_const_infop pi, int check_end)
|
||||
png_infop pi)
|
||||
{
|
||||
png_textp tp = NULL;
|
||||
png_uint_32 num_text = png_get_text(pp, pi, &tp, NULL);
|
||||
@@ -4762,13 +4762,7 @@ standard_text_validate(standard_display *dp, png_const_structp pp,
|
||||
if (num_text == 2 && tp != NULL)
|
||||
{
|
||||
standard_check_text(pp, tp, "image name", dp->ps->current->name);
|
||||
|
||||
/* This exists because prior to 1.6 the progressive reader left the
|
||||
* png_struct z_stream unreset at the end of the image, so subsequent
|
||||
* attempts to use it simply returns Z_STREAM_END.
|
||||
*/
|
||||
if (check_end)
|
||||
standard_check_text(pp, tp+1, "end marker", "end");
|
||||
standard_check_text(pp, tp+1, "end marker", "end");
|
||||
}
|
||||
|
||||
else
|
||||
@@ -4781,7 +4775,7 @@ standard_text_validate(standard_display *dp, png_const_structp pp,
|
||||
}
|
||||
}
|
||||
#else
|
||||
# define standard_text_validate(dp,pp,pi,check_end) ((void)0)
|
||||
# define standard_text_validate(dp,pp,pi) ((void)0)
|
||||
#endif
|
||||
|
||||
static void
|
||||
@@ -4871,8 +4865,7 @@ standard_end(png_structp ppIn, png_infop pi)
|
||||
/* Validate the image - progressive reading only produces one variant for
|
||||
* interlaced images.
|
||||
*/
|
||||
standard_text_validate(dp, pp, pi,
|
||||
PNG_LIBPNG_VER >= 10600/*check_end: see comments above*/);
|
||||
standard_text_validate(dp, pp, pi);
|
||||
standard_image_validate(dp, pp, 0, -1);
|
||||
}
|
||||
|
||||
@@ -4943,7 +4936,7 @@ standard_test(png_store* PNG_CONST psIn, png_uint_32 PNG_CONST id,
|
||||
*/
|
||||
if (!d.speed)
|
||||
{
|
||||
standard_text_validate(&d, pp, pi, 1/*check_end*/);
|
||||
standard_text_validate(&d, pp, pi);
|
||||
standard_image_validate(&d, pp, 0, 1);
|
||||
}
|
||||
else
|
||||
|
||||
104
contrib/libtests/readpng.c
Normal file
104
contrib/libtests/readpng.c
Normal file
@@ -0,0 +1,104 @@
|
||||
/* readpng.c
|
||||
*
|
||||
* Copyright (c) 2013 John Cunningham Bowler
|
||||
*
|
||||
* 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
|
||||
* and license in png.h
|
||||
*
|
||||
* Load an arbitrary number of PNG files (from the command line, or, if there
|
||||
* are no arguments on the command line, from stdin) then run a time test by
|
||||
* reading each file by row. The test does nothing with the read result and
|
||||
* does no transforms. The only output is a time as a floating point number of
|
||||
* seconds with 9 decimal digits.
|
||||
*/
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#if (defined HAVE_CONFIG_H) && !(defined PNG_NO_CONFIG_H)
|
||||
# include <config.h>
|
||||
#endif
|
||||
|
||||
/* Define the following to use this test against your installed libpng, rather
|
||||
* than the one being built here:
|
||||
*/
|
||||
#ifdef PNG_FREESTANDING_TESTS
|
||||
# include <png.h>
|
||||
#else
|
||||
# include "../../png.h"
|
||||
#endif
|
||||
|
||||
static int
|
||||
read_png(FILE *fp)
|
||||
{
|
||||
png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,0);
|
||||
png_infop info_ptr = NULL;
|
||||
png_bytep row = NULL, display = NULL;
|
||||
|
||||
if (png_ptr == NULL)
|
||||
return 0;
|
||||
|
||||
if (setjmp(png_jmpbuf(png_ptr)))
|
||||
{
|
||||
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
|
||||
if (row != NULL) free(row);
|
||||
if (display != NULL) free(display);
|
||||
return 0;
|
||||
}
|
||||
|
||||
png_init_io(png_ptr, fp);
|
||||
|
||||
info_ptr = png_create_info_struct(png_ptr);
|
||||
if (info_ptr == NULL)
|
||||
png_error(png_ptr, "OOM allocating info structure");
|
||||
|
||||
png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_ALWAYS, NULL, 0);
|
||||
|
||||
png_read_info(png_ptr, info_ptr);
|
||||
|
||||
{
|
||||
png_size_t rowbytes = png_get_rowbytes(png_ptr, info_ptr);
|
||||
|
||||
row = malloc(rowbytes);
|
||||
display = malloc(rowbytes);
|
||||
|
||||
if (row == NULL || display == NULL)
|
||||
png_error(png_ptr, "OOM allocating row buffers");
|
||||
|
||||
{
|
||||
png_uint_32 height = png_get_image_height(png_ptr, info_ptr);
|
||||
int passes = png_set_interlace_handling(png_ptr);
|
||||
int pass;
|
||||
|
||||
png_start_read_image(png_ptr);
|
||||
|
||||
for (pass = 0; pass < passes; ++pass)
|
||||
{
|
||||
png_uint_32 y = height;
|
||||
|
||||
/* NOTE: this trashes the row each time; interlace handling won't
|
||||
* work, but this avoids memory thrashing for speed testing.
|
||||
*/
|
||||
while (y-- > 0)
|
||||
png_read_row(png_ptr, row, display);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Make sure to read to the end of the file: */
|
||||
png_read_end(png_ptr, info_ptr);
|
||||
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
|
||||
free(row);
|
||||
free(display);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
main(void)
|
||||
{
|
||||
/* Exit code 0 on success. */
|
||||
return !read_png(stdin);
|
||||
}
|
||||
999
contrib/libtests/tarith.c
Normal file
999
contrib/libtests/tarith.c
Normal file
@@ -0,0 +1,999 @@
|
||||
|
||||
/* tarith.c
|
||||
*
|
||||
* Copyright (c) 2011-2013 John Cunningham Bowler
|
||||
*
|
||||
* Last changed in libpng 1.6.0 [February 14, 2013]
|
||||
*
|
||||
* This code is released under the libpng license.
|
||||
* For conditions of distribution and use, see the disclaimer
|
||||
* and license in png.h
|
||||
*
|
||||
* Test internal arithmetic functions of libpng.
|
||||
*
|
||||
* This code must be linked against a math library (-lm), but does not require
|
||||
* libpng or zlib to work. Because it includes the complete source of 'png.c'
|
||||
* it tests the code with whatever compiler options are used to build it.
|
||||
* Changing these options can substantially change the errors in the
|
||||
* calculations that the compiler chooses!
|
||||
*/
|
||||
#define _POSIX_SOURCE 1
|
||||
#define _ISOC99_SOURCE 1
|
||||
|
||||
/* Obtain a copy of the code to be tested (plus other things), disabling
|
||||
* stuff that is not required.
|
||||
*/
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include "../../pngpriv.h"
|
||||
|
||||
#define png_error png_warning
|
||||
|
||||
void png_warning(png_const_structrp png_ptr, png_const_charp msg)
|
||||
{
|
||||
fprintf(stderr, "validation: %s\n", msg);
|
||||
}
|
||||
|
||||
#define png_fixed_error png_fixed_warning
|
||||
|
||||
void png_fixed_warning(png_const_structrp png_ptr, png_const_charp msg)
|
||||
{
|
||||
fprintf(stderr, "overflow in: %s\n", msg);
|
||||
}
|
||||
|
||||
#define png_set_error_fn(pp, ep, efp, wfp) ((void)0)
|
||||
#define png_malloc(pp, s) malloc(s)
|
||||
#define png_malloc_warn(pp, s) malloc(s)
|
||||
#define png_malloc_base(pp, s) malloc(s)
|
||||
#define png_calloc(pp, s) calloc(1, (s))
|
||||
#define png_free(pp, s) free(s)
|
||||
|
||||
#define png_safecat(b, sb, pos, str) (pos)
|
||||
#define png_format_number(start, end, format, number) (start)
|
||||
|
||||
#define crc32(crc, pp, s) (crc)
|
||||
#define inflateReset(zs) Z_OK
|
||||
|
||||
#define png_create_struct(type) (0)
|
||||
#define png_destroy_struct(pp) ((void)0)
|
||||
#define png_create_struct_2(type, m, mm) (0)
|
||||
#define png_destroy_struct_2(pp, f, mm) ((void)0)
|
||||
|
||||
#undef PNG_SIMPLIFIED_READ_SUPPORTED
|
||||
#undef PNG_SIMPLIFIED_WRITE_SUPPORTED
|
||||
#undef PNG_USER_MEM_SUPPORTED
|
||||
|
||||
#include "../../png.c"
|
||||
|
||||
/* Validate ASCII to fp routines. */
|
||||
static int verbose = 0;
|
||||
|
||||
int validation_ascii_to_fp(int count, int argc, char **argv)
|
||||
{
|
||||
int showall = 0;
|
||||
double max_error=2; /* As a percentage error-in-last-digit/.5 */
|
||||
double max_error_abs=17; /* Used when precision is DBL_DIG */
|
||||
double max = 0;
|
||||
double max_abs = 0;
|
||||
double test = 0; /* Important to test this. */
|
||||
int precision = 5;
|
||||
int nonfinite = 0;
|
||||
int finite = 0;
|
||||
int ok = 0;
|
||||
int failcount = 0;
|
||||
int minorarith = 0;
|
||||
|
||||
while (--argc > 0)
|
||||
if (strcmp(*++argv, "-a") == 0)
|
||||
showall = 1;
|
||||
else if (strcmp(*argv, "-e") == 0 && argc > 0)
|
||||
{
|
||||
--argc;
|
||||
max_error = atof(*++argv);
|
||||
}
|
||||
else if (strcmp(*argv, "-E") == 0 && argc > 0)
|
||||
{
|
||||
--argc;
|
||||
max_error_abs = atof(*++argv);
|
||||
}
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "unknown argument %s\n", *argv);
|
||||
return 1;
|
||||
}
|
||||
|
||||
do
|
||||
{
|
||||
png_size_t index;
|
||||
int state, failed = 0;
|
||||
char buffer[64];
|
||||
|
||||
if (isfinite(test))
|
||||
++finite;
|
||||
else
|
||||
++nonfinite;
|
||||
|
||||
if (verbose)
|
||||
fprintf(stderr, "%.*g %d\n", DBL_DIG, test, precision);
|
||||
|
||||
/* Check for overflow in the buffer by setting a marker. */
|
||||
memset(buffer, 71, sizeof buffer);
|
||||
|
||||
png_ascii_from_fp(0, buffer, precision+10, test, precision);
|
||||
|
||||
/* Allow for a three digit exponent, this stuff will fail if
|
||||
* the exponent is bigger than this!
|
||||
*/
|
||||
if (buffer[precision+7] != 71)
|
||||
{
|
||||
fprintf(stderr, "%g[%d] -> '%s'[%lu] buffer overflow\n", test,
|
||||
precision, buffer, (unsigned long)strlen(buffer));
|
||||
failed = 1;
|
||||
}
|
||||
|
||||
/* Following are used for the number parser below and must be
|
||||
* initialized to zero.
|
||||
*/
|
||||
state = 0;
|
||||
index = 0;
|
||||
if (!isfinite(test))
|
||||
{
|
||||
/* Expect 'inf' */
|
||||
if (test >= 0 && strcmp(buffer, "inf") ||
|
||||
test < 0 && strcmp(buffer, "-inf"))
|
||||
{
|
||||
fprintf(stderr, "%g[%d] -> '%s' but expected 'inf'\n", test,
|
||||
precision, buffer);
|
||||
failed = 1;
|
||||
}
|
||||
}
|
||||
else if (!png_check_fp_number(buffer, precision+10, &state, &index) ||
|
||||
buffer[index] != 0)
|
||||
{
|
||||
fprintf(stderr, "%g[%d] -> '%s' but has bad format ('%c')\n", test,
|
||||
precision, buffer, buffer[index]);
|
||||
failed = 1;
|
||||
}
|
||||
else if (PNG_FP_IS_NEGATIVE(state) && !(test < 0))
|
||||
{
|
||||
fprintf(stderr, "%g[%d] -> '%s' but negative value not so reported\n",
|
||||
test, precision, buffer);
|
||||
failed = 1;
|
||||
assert(!PNG_FP_IS_ZERO(state));
|
||||
assert(!PNG_FP_IS_POSITIVE(state));
|
||||
}
|
||||
else if (PNG_FP_IS_ZERO(state) && !(test == 0))
|
||||
{
|
||||
fprintf(stderr, "%g[%d] -> '%s' but zero value not so reported\n",
|
||||
test, precision, buffer);
|
||||
failed = 1;
|
||||
assert(!PNG_FP_IS_NEGATIVE(state));
|
||||
assert(!PNG_FP_IS_POSITIVE(state));
|
||||
}
|
||||
else if (PNG_FP_IS_POSITIVE(state) && !(test > 0))
|
||||
{
|
||||
fprintf(stderr, "%g[%d] -> '%s' but postive value not so reported\n",
|
||||
test, precision, buffer);
|
||||
failed = 1;
|
||||
assert(!PNG_FP_IS_NEGATIVE(state));
|
||||
assert(!PNG_FP_IS_ZERO(state));
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Check the result against the original. */
|
||||
double out = atof(buffer);
|
||||
double change = fabs((out - test)/test);
|
||||
double allow = .5/pow(10,
|
||||
(precision >= DBL_DIG) ? DBL_DIG-1 : precision-1);
|
||||
|
||||
/* NOTE: if you hit this error case are you compiling with gcc
|
||||
* and -O0? Try -O2 - the errors can accumulate if the FP
|
||||
* code above is not optimized and may drift outside the .5 in
|
||||
* DBL_DIG allowed. In any case a small number of errors may
|
||||
* occur (very small ones - 1 or 2%) because of rounding in the
|
||||
* calculations, either in the conversion API or in atof.
|
||||
*/
|
||||
if (change >= allow && (isfinite(out) ||
|
||||
fabs(test/DBL_MAX) <= 1-allow))
|
||||
{
|
||||
double percent = (precision >= DBL_DIG) ? max_error_abs : max_error;
|
||||
double allowp = (change-allow)*100/allow;
|
||||
|
||||
if (precision >= DBL_DIG)
|
||||
{
|
||||
if (max_abs < allowp) max_abs = allowp;
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
if (max < allowp) max = allowp;
|
||||
}
|
||||
|
||||
if (showall || allowp >= percent)
|
||||
{
|
||||
fprintf(stderr,
|
||||
"%.*g[%d] -> '%s' -> %.*g number changed (%g > %g (%d%%))\n",
|
||||
DBL_DIG, test, precision, buffer, DBL_DIG, out, change, allow,
|
||||
(int)round(allowp));
|
||||
failed = 1;
|
||||
}
|
||||
else
|
||||
++minorarith;
|
||||
}
|
||||
}
|
||||
|
||||
if (failed)
|
||||
++failcount;
|
||||
else
|
||||
++ok;
|
||||
|
||||
skip:
|
||||
/* Generate a new number and precision. */
|
||||
precision = rand();
|
||||
if (precision & 1) test = -test;
|
||||
precision >>= 1;
|
||||
|
||||
/* Generate random numbers. */
|
||||
if (test == 0 || !isfinite(test))
|
||||
test = precision+1;
|
||||
else
|
||||
{
|
||||
/* Derive the exponent from the previous rand() value. */
|
||||
int exponent = precision % (DBL_MAX_EXP - DBL_MIN_EXP) + DBL_MIN_EXP;
|
||||
int tmp;
|
||||
test = frexp(test * rand(), &tmp);
|
||||
test = ldexp(test, exponent);
|
||||
precision >>= 8; /* arbitrary */
|
||||
}
|
||||
|
||||
/* This limits the precision to 32 digits, enough for standard
|
||||
* IEEE implementations which have at most 15 digits.
|
||||
*/
|
||||
precision = (precision & 0x1f) + 1;
|
||||
}
|
||||
while (--count);
|
||||
|
||||
printf("Tested %d finite values, %d non-finite, %d OK (%d failed) %d minor "
|
||||
"arithmetic errors\n", finite, nonfinite, ok, failcount, minorarith);
|
||||
printf(" Error with >=%d digit precision %.2f%%\n", DBL_DIG, max_abs);
|
||||
printf(" Error with < %d digit precision %.2f%%\n", DBL_DIG, max);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Observe that valid FP numbers have the forms listed in the PNG extensions
|
||||
* specification:
|
||||
*
|
||||
* [+,-]{integer,integer.fraction,.fraction}[{e,E}[+,-]integer]
|
||||
*
|
||||
* Test each of these in turn, including invalid cases.
|
||||
*/
|
||||
typedef enum checkfp_state
|
||||
{
|
||||
start, fraction, exponent, states
|
||||
} checkfp_state;
|
||||
|
||||
/* The characters (other than digits) that characterize the states: */
|
||||
static const char none[] = "";
|
||||
static const char hexdigits[16] = "0123456789ABCDEF";
|
||||
|
||||
static const struct
|
||||
{
|
||||
const char *start; /* Characters valid at the start */
|
||||
const char *end; /* Valid characters that end the state */
|
||||
const char *tests; /* Characters to test after 2 digits seen */
|
||||
}
|
||||
state_characters[states] =
|
||||
{
|
||||
/* start: */ { "+-.", ".eE", "+-.e*0369" },
|
||||
/* fraction: */ { none, "eE", "+-.E#0147" },
|
||||
/* exponent: */ { "+-", none, "+-.eE^0258" }
|
||||
};
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char number[1024]; /* Buffer for number being tested */
|
||||
int limit; /* Command line limit */
|
||||
int verbose; /* Shadows global variable */
|
||||
int ctimes; /* Number of numbers tested */
|
||||
int cmillions; /* Count of millions of numbers */
|
||||
int cinvalid; /* Invalid strings checked */
|
||||
int cnoaccept; /* Characters not accepted */
|
||||
}
|
||||
checkfp_command;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int cnumber; /* Index into number string */
|
||||
checkfp_state check_state; /* Current number state */
|
||||
int at_start; /* At start (first character) of state */
|
||||
int cdigits_in_state; /* Digits seen in that state */
|
||||
int limit; /* Limit on same for checking all chars */
|
||||
int state; /* Current parser state */
|
||||
int is_negative; /* Number is negative */
|
||||
int is_zero; /* Number is (still) zero */
|
||||
int number_was_valid; /* Previous character validity */
|
||||
}
|
||||
checkfp_control;
|
||||
|
||||
static int check_all_characters(checkfp_command *co, checkfp_control c);
|
||||
|
||||
static int check_some_characters(checkfp_command *co, checkfp_control c,
|
||||
const char *tests);
|
||||
|
||||
static int check_one_character(checkfp_command *co, checkfp_control c, int ch)
|
||||
{
|
||||
/* Test this character (ch) to ensure the parser does the correct thing.
|
||||
*/
|
||||
png_size_t index = 0;
|
||||
const char test = (char)ch;
|
||||
const int number_is_valid = png_check_fp_number(&test, 1, &c.state, &index);
|
||||
const int character_accepted = (index == 1);
|
||||
|
||||
if (c.check_state != exponent && isdigit(ch) && ch != '0')
|
||||
c.is_zero = 0;
|
||||
|
||||
if (c.check_state == start && c.at_start && ch == '-')
|
||||
c.is_negative = 1;
|
||||
|
||||
if (isprint(ch))
|
||||
co->number[c.cnumber++] = (char)ch;
|
||||
else
|
||||
{
|
||||
co->number[c.cnumber++] = '<';
|
||||
co->number[c.cnumber++] = hexdigits[(ch >> 4) & 0xf];
|
||||
co->number[c.cnumber++] = hexdigits[ch & 0xf];
|
||||
co->number[c.cnumber++] = '>';
|
||||
}
|
||||
co->number[c.cnumber] = 0;
|
||||
|
||||
if (co->verbose > 1)
|
||||
fprintf(stderr, "%s\n", co->number);
|
||||
|
||||
if (++(co->ctimes) == 1000000)
|
||||
{
|
||||
if (co->verbose == 1)
|
||||
fputc('.', stderr);
|
||||
co->ctimes = 0;
|
||||
++(co->cmillions);
|
||||
}
|
||||
|
||||
if (!number_is_valid)
|
||||
++(co->cinvalid);
|
||||
|
||||
if (!character_accepted)
|
||||
++(co->cnoaccept);
|
||||
|
||||
/* This should never fail (it's a serious bug if it does): */
|
||||
if (index != 0 && index != 1)
|
||||
{
|
||||
fprintf(stderr, "%s: read beyond end of string (%lu)\n", co->number,
|
||||
(unsigned long)index);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Validate the new state, note that the PNG_FP_IS_ macros all return
|
||||
* false unless the number is valid.
|
||||
*/
|
||||
if (PNG_FP_IS_NEGATIVE(c.state) !=
|
||||
(number_is_valid && !c.is_zero && c.is_negative))
|
||||
{
|
||||
fprintf(stderr, "%s: negative when it is not\n", co->number);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (PNG_FP_IS_ZERO(c.state) != (number_is_valid && c.is_zero))
|
||||
{
|
||||
fprintf(stderr, "%s: zero when it is not\n", co->number);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (PNG_FP_IS_POSITIVE(c.state) !=
|
||||
(number_is_valid && !c.is_zero && !c.is_negative))
|
||||
{
|
||||
fprintf(stderr, "%s: positive when it is not\n", co->number);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Testing a digit */
|
||||
if (isdigit(ch))
|
||||
{
|
||||
if (!character_accepted)
|
||||
{
|
||||
fprintf(stderr, "%s: digit '%c' not accepted\n", co->number, ch);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!number_is_valid)
|
||||
{
|
||||
fprintf(stderr, "%s: saw a digit (%c) but number not valid\n",
|
||||
co->number, ch);
|
||||
return 0;
|
||||
}
|
||||
|
||||
++c.cdigits_in_state;
|
||||
c.at_start = 0;
|
||||
c.number_was_valid = 1;
|
||||
|
||||
/* Continue testing characters in this state. Either test all of
|
||||
* them or, if we have already seen one digit in this state, just test a
|
||||
* limited set.
|
||||
*/
|
||||
if (c.cdigits_in_state < 1)
|
||||
return check_all_characters(co, c);
|
||||
|
||||
else
|
||||
return check_some_characters(co, c,
|
||||
state_characters[c.check_state].tests);
|
||||
}
|
||||
|
||||
/* A non-digit; is it allowed here? */
|
||||
else if (((ch == '+' || ch == '-') && c.check_state != fraction &&
|
||||
c.at_start) ||
|
||||
(ch == '.' && c.check_state == start) ||
|
||||
((ch == 'e' || ch == 'E') && c.number_was_valid &&
|
||||
c.check_state != exponent))
|
||||
{
|
||||
if (!character_accepted)
|
||||
{
|
||||
fprintf(stderr, "%s: character '%c' not accepted\n", co->number, ch);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* The number remains valid after start of fraction but nowhere else. */
|
||||
if (number_is_valid && (c.check_state != start || ch != '.'))
|
||||
{
|
||||
fprintf(stderr, "%s: saw a non-digit (%c) but number valid\n",
|
||||
co->number, ch);
|
||||
return 0;
|
||||
}
|
||||
|
||||
c.number_was_valid = number_is_valid;
|
||||
|
||||
/* Check for a state change. When changing to 'fraction' if the number
|
||||
* is valid at this point set the at_start to false to allow an exponent
|
||||
* 'e' to come next.
|
||||
*/
|
||||
if (c.check_state == start && ch == '.')
|
||||
{
|
||||
c.check_state = fraction;
|
||||
c.at_start = !number_is_valid;
|
||||
c.cdigits_in_state = 0;
|
||||
c.limit = co->limit;
|
||||
return check_all_characters(co, c);
|
||||
}
|
||||
|
||||
else if (c.check_state < exponent && (ch == 'e' || ch == 'E'))
|
||||
{
|
||||
c.check_state = exponent;
|
||||
c.at_start = 1;
|
||||
c.cdigits_in_state = 0;
|
||||
c.limit = co->limit;
|
||||
return check_all_characters(co, c);
|
||||
}
|
||||
|
||||
/* Else it was a sign, and the state doesn't change. */
|
||||
else
|
||||
{
|
||||
if (ch != '-' && ch != '+')
|
||||
{
|
||||
fprintf(stderr, "checkfp: internal error (1)\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
c.at_start = 0;
|
||||
return check_all_characters(co, c);
|
||||
}
|
||||
}
|
||||
|
||||
/* Testing an invalid character */
|
||||
else
|
||||
{
|
||||
if (character_accepted)
|
||||
{
|
||||
fprintf(stderr, "%s: character '%c' [0x%.2x] accepted\n", co->number,
|
||||
ch, ch);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (number_is_valid != c.number_was_valid)
|
||||
{
|
||||
fprintf(stderr,
|
||||
"%s: character '%c' [0x%.2x] changed number validity\n", co->number,
|
||||
ch, ch);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Do nothing - the parser has stuck; return success and keep going with
|
||||
* the next character.
|
||||
*/
|
||||
}
|
||||
|
||||
/* Successful return (the caller will try the next character.) */
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int check_all_characters(checkfp_command *co, checkfp_control c)
|
||||
{
|
||||
int ch;
|
||||
|
||||
if (c.cnumber+4 < sizeof co->number) for (ch=0; ch<256; ++ch)
|
||||
{
|
||||
if (!check_one_character(co, c, ch))
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int check_some_characters(checkfp_command *co, checkfp_control c,
|
||||
const char *tests)
|
||||
{
|
||||
int i;
|
||||
|
||||
--(c.limit);
|
||||
|
||||
if (c.cnumber+4 < sizeof co->number && c.limit >= 0)
|
||||
{
|
||||
if (c.limit > 0) for (i=0; tests[i]; ++i)
|
||||
{
|
||||
if (!check_one_character(co, c, tests[i]))
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* At the end check all the characters. */
|
||||
else
|
||||
return check_all_characters(co, c);
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int validation_checkfp(int count, int argc, char **argv)
|
||||
{
|
||||
int result;
|
||||
checkfp_command command;
|
||||
checkfp_control control;
|
||||
|
||||
command.number[0] = 0;
|
||||
command.limit = 3;
|
||||
command.verbose = verbose;
|
||||
command.ctimes = 0;
|
||||
command.cmillions = 0;
|
||||
command.cinvalid = 0;
|
||||
command.cnoaccept = 0;
|
||||
|
||||
while (--argc > 0)
|
||||
{
|
||||
++argv;
|
||||
if (argc > 1 && strcmp(*argv, "-l") == 0)
|
||||
{
|
||||
--argc;
|
||||
command.limit = atoi(*++argv);
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "unknown argument %s\n", *argv);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
control.cnumber = 0;
|
||||
control.check_state = start;
|
||||
control.at_start = 1;
|
||||
control.cdigits_in_state = 0;
|
||||
control.limit = command.limit;
|
||||
control.state = 0;
|
||||
control.is_negative = 0;
|
||||
control.is_zero = 1;
|
||||
control.number_was_valid = 0;
|
||||
|
||||
result = check_all_characters(&command, control);
|
||||
|
||||
printf("checkfp: %s: checked %d,%.3d,%.3d,%.3d strings (%d invalid)\n",
|
||||
result ? "pass" : "FAIL", command.cmillions / 1000,
|
||||
command.cmillions % 1000, command.ctimes / 1000, command.ctimes % 1000,
|
||||
command.cinvalid);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
int validation_muldiv(int count, int argc, char **argv)
|
||||
{
|
||||
int tested = 0;
|
||||
int overflow = 0;
|
||||
int error = 0;
|
||||
int error64 = 0;
|
||||
int passed = 0;
|
||||
int randbits = 0;
|
||||
png_uint_32 randbuffer;
|
||||
png_fixed_point a;
|
||||
png_int_32 times, div;
|
||||
|
||||
while (--argc > 0)
|
||||
{
|
||||
fprintf(stderr, "unknown argument %s\n", *++argv);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Find out about the random number generator. */
|
||||
randbuffer = RAND_MAX;
|
||||
while (randbuffer != 0) ++randbits, randbuffer >>= 1;
|
||||
printf("Using random number generator that makes %d bits\n", randbits);
|
||||
for (div=0; div<32; div += randbits)
|
||||
randbuffer = (randbuffer << randbits) ^ rand();
|
||||
|
||||
a = 0;
|
||||
times = div = 0;
|
||||
do
|
||||
{
|
||||
png_fixed_point result;
|
||||
/* NOTE: your mileage may vary, a type is required below that can
|
||||
* hold 64 bits or more, if floating point is used a 64 bit or
|
||||
* better mantissa is required.
|
||||
*/
|
||||
long long int fp, fpround;
|
||||
unsigned long hi, lo;
|
||||
int ok;
|
||||
|
||||
/* Check the values, png_64bit_product can only handle positive
|
||||
* numbers, so correct for that here.
|
||||
*/
|
||||
{
|
||||
long u1, u2;
|
||||
int n = 0;
|
||||
if (a < 0) u1 = -a, n = 1; else u1 = a;
|
||||
if (times < 0) u2 = -times, n = !n; else u2 = times;
|
||||
png_64bit_product(u1, u2, &hi, &lo);
|
||||
if (n)
|
||||
{
|
||||
/* -x = ~x+1 */
|
||||
lo = ((~lo) + 1) & 0xffffffff;
|
||||
hi = ~hi;
|
||||
if (lo == 0) ++hi;
|
||||
}
|
||||
}
|
||||
|
||||
fp = a;
|
||||
fp *= times;
|
||||
if ((fp & 0xffffffff) != lo || ((fp >> 32) & 0xffffffff) != hi)
|
||||
{
|
||||
fprintf(stderr, "png_64bit_product %d * %d -> %lx|%.8lx not %llx\n",
|
||||
a, times, hi, lo, fp);
|
||||
++error64;
|
||||
}
|
||||
|
||||
if (div != 0)
|
||||
{
|
||||
/* Round - this is C round to zero. */
|
||||
if ((fp < 0) != (div < 0))
|
||||
fp -= div/2;
|
||||
else
|
||||
fp += div/2;
|
||||
|
||||
fp /= div;
|
||||
fpround = fp;
|
||||
/* Assume 2's complement here: */
|
||||
ok = fpround <= PNG_UINT_31_MAX &&
|
||||
fpround >= -1-(long long int)PNG_UINT_31_MAX;
|
||||
if (!ok) ++overflow;
|
||||
}
|
||||
else
|
||||
ok = 0, ++overflow, fpround = fp/*misleading*/;
|
||||
|
||||
if (verbose)
|
||||
fprintf(stderr, "TEST %d * %d / %d -> %lld (%s)\n", a, times, div,
|
||||
fp, ok ? "ok" : "overflow");
|
||||
|
||||
++tested;
|
||||
if (png_muldiv(&result, a, times, div) != ok)
|
||||
{
|
||||
++error;
|
||||
if (ok)
|
||||
fprintf(stderr, "%d * %d / %d -> overflow (expected %lld)\n", a,
|
||||
times, div, fp);
|
||||
else
|
||||
fprintf(stderr, "%d * %d / %d -> %d (expected overflow %lld)\n", a,
|
||||
times, div, result, fp);
|
||||
}
|
||||
else if (ok && result != fpround)
|
||||
{
|
||||
++error;
|
||||
fprintf(stderr, "%d * %d / %d -> %d not %lld\n", a, times, div, result,
|
||||
fp);
|
||||
}
|
||||
else
|
||||
++passed;
|
||||
|
||||
/* Generate three new values, this uses rand() and rand() only returns
|
||||
* up to RAND_MAX.
|
||||
*/
|
||||
/* CRUDE */
|
||||
a += times;
|
||||
times += div;
|
||||
div = randbuffer;
|
||||
randbuffer = (randbuffer << randbits) ^ rand();
|
||||
}
|
||||
while (--count > 0);
|
||||
|
||||
printf("%d tests including %d overflows, %d passed, %d failed (%d 64 bit "
|
||||
"errors)\n", tested, overflow, passed, error, error64);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* When FP is on this just becomes a speed test - compile without FP to get real
|
||||
* validation.
|
||||
*/
|
||||
#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
|
||||
#define LN2 .000010576586617430806112933839 /* log(2)/65536 */
|
||||
#define L2INV 94548.46219969910586572651 /* 65536/log(2) */
|
||||
|
||||
/* For speed testing, need the internal functions too: */
|
||||
static png_uint_32 png_log8bit(unsigned x)
|
||||
{
|
||||
if (x > 0)
|
||||
return (png_uint_32)floor(.5-log(x/255.)*L2INV);
|
||||
|
||||
return 0xffffffff;
|
||||
}
|
||||
|
||||
static png_uint_32 png_log16bit(png_uint_32 x)
|
||||
{
|
||||
if (x > 0)
|
||||
return (png_uint_32)floor(.5-log(x/65535.)*L2INV);
|
||||
|
||||
return 0xffffffff;
|
||||
}
|
||||
|
||||
static png_uint_32 png_exp(png_uint_32 x)
|
||||
{
|
||||
return (png_uint_32)floor(.5 + exp(x * -LN2) * 0xffffffffU);
|
||||
}
|
||||
|
||||
static png_byte png_exp8bit(png_uint_32 log)
|
||||
{
|
||||
return (png_byte)floor(.5 + exp(log * -LN2) * 255);
|
||||
}
|
||||
|
||||
static png_uint_16 png_exp16bit(png_uint_32 log)
|
||||
{
|
||||
return (png_uint_16)floor(.5 + exp(log * -LN2) * 65535);
|
||||
}
|
||||
#endif /* FLOATING_ARITHMETIC */
|
||||
|
||||
int validation_gamma(int argc, char **argv)
|
||||
{
|
||||
double gamma[9] = { 2.2, 1.8, 1.52, 1.45, 1., 1/1.45, 1/1.52, 1/1.8, 1/2.2 };
|
||||
double maxerr;
|
||||
int i, silent=0, onlygamma=0;
|
||||
|
||||
/* Silence the output with -s, just test the gamma functions with -g: */
|
||||
while (--argc > 0)
|
||||
if (strcmp(*++argv, "-s") == 0)
|
||||
silent = 1;
|
||||
else if (strcmp(*argv, "-g") == 0)
|
||||
onlygamma = 1;
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "unknown argument %s\n", *argv);
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (!onlygamma)
|
||||
{
|
||||
/* First validate the log functions: */
|
||||
maxerr = 0;
|
||||
for (i=0; i<256; ++i)
|
||||
{
|
||||
double correct = -log(i/255.)/log(2.)*65536;
|
||||
double error = png_log8bit(i) - correct;
|
||||
|
||||
if (i != 0 && fabs(error) > maxerr)
|
||||
maxerr = fabs(error);
|
||||
|
||||
if (i == 0 && png_log8bit(i) != 0xffffffff ||
|
||||
i != 0 && png_log8bit(i) != floor(correct+.5))
|
||||
{
|
||||
fprintf(stderr, "8 bit log error: %d: got %u, expected %f\n",
|
||||
i, png_log8bit(i), correct);
|
||||
}
|
||||
}
|
||||
|
||||
if (!silent)
|
||||
printf("maximum 8 bit log error = %f\n", maxerr);
|
||||
|
||||
maxerr = 0;
|
||||
for (i=0; i<65536; ++i)
|
||||
{
|
||||
double correct = -log(i/65535.)/log(2.)*65536;
|
||||
double error = png_log16bit(i) - correct;
|
||||
|
||||
if (i != 0 && fabs(error) > maxerr)
|
||||
maxerr = fabs(error);
|
||||
|
||||
if (i == 0 && png_log16bit(i) != 0xffffffff ||
|
||||
i != 0 && png_log16bit(i) != floor(correct+.5))
|
||||
{
|
||||
if (error > .68) /* By experiment error is less than .68 */
|
||||
{
|
||||
fprintf(stderr, "16 bit log error: %d: got %u, expected %f"
|
||||
" error: %f\n", i, png_log16bit(i), correct, error);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!silent)
|
||||
printf("maximum 16 bit log error = %f\n", maxerr);
|
||||
|
||||
/* Now exponentiations. */
|
||||
maxerr = 0;
|
||||
for (i=0; i<=0xfffff; ++i)
|
||||
{
|
||||
double correct = exp(-i/65536. * log(2.)) * (65536. * 65536);
|
||||
double error = png_exp(i) - correct;
|
||||
|
||||
if (fabs(error) > maxerr)
|
||||
maxerr = fabs(error);
|
||||
if (fabs(error) > 1883) /* By experiment. */
|
||||
{
|
||||
fprintf(stderr, "32 bit exp error: %d: got %u, expected %f"
|
||||
" error: %f\n", i, png_exp(i), correct, error);
|
||||
}
|
||||
}
|
||||
|
||||
if (!silent)
|
||||
printf("maximum 32 bit exp error = %f\n", maxerr);
|
||||
|
||||
maxerr = 0;
|
||||
for (i=0; i<=0xfffff; ++i)
|
||||
{
|
||||
double correct = exp(-i/65536. * log(2.)) * 255;
|
||||
double error = png_exp8bit(i) - correct;
|
||||
|
||||
if (fabs(error) > maxerr)
|
||||
maxerr = fabs(error);
|
||||
if (fabs(error) > .50002) /* By experiment */
|
||||
{
|
||||
fprintf(stderr, "8 bit exp error: %d: got %u, expected %f"
|
||||
" error: %f\n", i, png_exp8bit(i), correct, error);
|
||||
}
|
||||
}
|
||||
|
||||
if (!silent)
|
||||
printf("maximum 8 bit exp error = %f\n", maxerr);
|
||||
|
||||
maxerr = 0;
|
||||
for (i=0; i<=0xfffff; ++i)
|
||||
{
|
||||
double correct = exp(-i/65536. * log(2.)) * 65535;
|
||||
double error = png_exp16bit(i) - correct;
|
||||
|
||||
if (fabs(error) > maxerr)
|
||||
maxerr = fabs(error);
|
||||
if (fabs(error) > .524) /* By experiment */
|
||||
{
|
||||
fprintf(stderr, "16 bit exp error: %d: got %u, expected %f"
|
||||
" error: %f\n", i, png_exp16bit(i), correct, error);
|
||||
}
|
||||
}
|
||||
|
||||
if (!silent)
|
||||
printf("maximum 16 bit exp error = %f\n", maxerr);
|
||||
} /* !onlygamma */
|
||||
|
||||
/* Test the overall gamma correction. */
|
||||
for (i=0; i<9; ++i)
|
||||
{
|
||||
unsigned j;
|
||||
double g = gamma[i];
|
||||
png_fixed_point gfp = floor(g * PNG_FP_1 + .5);
|
||||
|
||||
if (!silent)
|
||||
printf("Test gamma %f\n", g);
|
||||
|
||||
maxerr = 0;
|
||||
for (j=0; j<256; ++j)
|
||||
{
|
||||
double correct = pow(j/255., g) * 255;
|
||||
png_byte out = png_gamma_8bit_correct(j, gfp);
|
||||
double error = out - correct;
|
||||
|
||||
if (fabs(error) > maxerr)
|
||||
maxerr = fabs(error);
|
||||
if (out != floor(correct+.5))
|
||||
{
|
||||
fprintf(stderr, "8bit %d ^ %f: got %d expected %f error %f\n",
|
||||
j, g, out, correct, error);
|
||||
}
|
||||
}
|
||||
|
||||
if (!silent)
|
||||
printf("gamma %f: maximum 8 bit error %f\n", g, maxerr);
|
||||
|
||||
maxerr = 0;
|
||||
for (j=0; j<65536; ++j)
|
||||
{
|
||||
double correct = pow(j/65535., g) * 65535;
|
||||
png_uint_16 out = png_gamma_16bit_correct(j, gfp);
|
||||
double error = out - correct;
|
||||
|
||||
if (fabs(error) > maxerr)
|
||||
maxerr = fabs(error);
|
||||
if (fabs(error) > 1.62)
|
||||
{
|
||||
fprintf(stderr, "16bit %d ^ %f: got %d expected %f error %f\n",
|
||||
j, g, out, correct, error);
|
||||
}
|
||||
}
|
||||
|
||||
if (!silent)
|
||||
printf("gamma %f: maximum 16 bit error %f\n", g, maxerr);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**************************** VALIDATION TESTS ********************************/
|
||||
/* Various validation routines are included herein, they require some
|
||||
* definition for png_warning and png_error, seetings of VALIDATION:
|
||||
*
|
||||
* 1: validates the ASCII to floating point conversions
|
||||
* 2: validates png_muldiv
|
||||
* 3: accuracy test of fixed point gamma tables
|
||||
*/
|
||||
|
||||
/* The following COUNT (10^8) takes about 1 hour on a 1GHz Pentium IV
|
||||
* processor.
|
||||
*/
|
||||
#define COUNT 1000000000
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
int count = COUNT;
|
||||
|
||||
while (argc > 1)
|
||||
{
|
||||
if (argc > 2 && strcmp(argv[1], "-c") == 0)
|
||||
{
|
||||
count = atoi(argv[2]);
|
||||
argc -= 2;
|
||||
argv += 2;
|
||||
}
|
||||
|
||||
else if (strcmp(argv[1], "-v") == 0)
|
||||
{
|
||||
++verbose;
|
||||
--argc;
|
||||
++argv;
|
||||
}
|
||||
|
||||
else
|
||||
break;
|
||||
}
|
||||
|
||||
if (count > 0 && argc > 1)
|
||||
{
|
||||
if (strcmp(argv[1], "ascii") == 0)
|
||||
return validation_ascii_to_fp(count, argc-1, argv+1);
|
||||
else if (strcmp(argv[1], "checkfp") == 0)
|
||||
return validation_checkfp(count, argc-1, argv+1);
|
||||
else if (strcmp(argv[1], "muldiv") == 0)
|
||||
return validation_muldiv(count, argc-1, argv+1);
|
||||
else if (strcmp(argv[1], "gamma") == 0)
|
||||
return validation_gamma(argc-1, argv+1);
|
||||
}
|
||||
|
||||
/* Bad argument: */
|
||||
fprintf(stderr,
|
||||
"usage: tarith [-v] [-c count] {ascii,muldiv,gamma} [args]\n");
|
||||
fprintf(stderr, " arguments: ascii [-a (all results)] [-e error%%]\n");
|
||||
fprintf(stderr, " checkfp [-l max-number-chars]\n");
|
||||
fprintf(stderr, " muldiv\n");
|
||||
fprintf(stderr, " gamma -s (silent) -g (only gamma; no log)\n");
|
||||
return 1;
|
||||
}
|
||||
24
contrib/libtests/test-pngstest.sh
Executable file
24
contrib/libtests/test-pngstest.sh
Executable file
@@ -0,0 +1,24 @@
|
||||
#!/bin/sh
|
||||
#
|
||||
# Run the simplified API tests
|
||||
err=0
|
||||
|
||||
echo >> pngtest-log.txt
|
||||
echo "============ pngstest.sh ==============" >> pngtest-log.txt
|
||||
|
||||
echo "Running test-pngstest.sh"
|
||||
for image in ${srcdir}/contrib/pngsuite/*.png
|
||||
do
|
||||
for opts in ""
|
||||
do
|
||||
if ./pngstest --strict --log "$@" $opts $image >>pngtest-log.txt 2>&1
|
||||
then
|
||||
echo " PASS: pngstest $opts $image"
|
||||
else
|
||||
echo " FAIL: pngstest $opts $image"
|
||||
err=1
|
||||
fi
|
||||
done
|
||||
done
|
||||
|
||||
exit $err
|
||||
38
contrib/libtests/test-pngunknown.sh
Executable file
38
contrib/libtests/test-pngunknown.sh
Executable file
@@ -0,0 +1,38 @@
|
||||
#!/bin/sh
|
||||
#
|
||||
# Run the unknown API tests
|
||||
err=0
|
||||
image="${srcdir}/pngtest.png"
|
||||
#
|
||||
# stream 4 is used for the output of the shell, pngtest-log.txt gets all the
|
||||
# normal program output.
|
||||
exec 4>&1 1>>pngtest-log.txt 2>&1
|
||||
|
||||
echo
|
||||
echo "============ test-pngunknown.sh =============="
|
||||
|
||||
echo "Running test-pngunknown.sh" >&4
|
||||
|
||||
for tests in \
|
||||
"discard default=discard"\
|
||||
"save default=save"\
|
||||
"if-safe default=if-safe"\
|
||||
"vpAg vpAg=if-safe"\
|
||||
"sTER sTER=if-safe"\
|
||||
"IDAT default=discard IDAT=save"\
|
||||
"sAPI bKGD=save cHRM=save gAMA=save all=discard iCCP=save sBIT=save sRGB=save"
|
||||
do
|
||||
set $tests
|
||||
test="$1"
|
||||
shift
|
||||
|
||||
if ./pngunknown "$@" "$image" 4>&-
|
||||
then
|
||||
echo " PASS: test-pngunknown $test" >&4
|
||||
else
|
||||
echo " FAIL: test-pngunknown $test" >&4
|
||||
err=1
|
||||
fi
|
||||
done
|
||||
|
||||
exit $err
|
||||
21
contrib/libtests/test-pngvalid-full.sh
Executable file
21
contrib/libtests/test-pngvalid-full.sh
Executable file
@@ -0,0 +1,21 @@
|
||||
#!/bin/sh
|
||||
#
|
||||
# Run a sequence of gamma tests quietly
|
||||
err=0
|
||||
|
||||
echo >> pngtest-log.txt
|
||||
echo "============ pngvalid-full.sh ==============" >> pngtest-log.txt
|
||||
|
||||
echo "Running test-pngvalid-full.sh"
|
||||
for gamma in threshold transform sbit 16-to-8 background alpha-mode "transform --expand16" "background --expand16" "alpha-mode --expand16"
|
||||
do
|
||||
if ./pngvalid "$@" --gamma-$gamma >> pngtest-log.txt 2>&1
|
||||
then
|
||||
echo " PASS: pngvalid" "$@" "--gamma-$gamma"
|
||||
else
|
||||
echo " FAIL: pngvalid" "$@" "--gamma-$gamma"
|
||||
err=1
|
||||
fi
|
||||
done
|
||||
|
||||
exit $err
|
||||
30
contrib/libtests/test-pngvalid-simple.sh
Executable file
30
contrib/libtests/test-pngvalid-simple.sh
Executable file
@@ -0,0 +1,30 @@
|
||||
#!/bin/sh
|
||||
#
|
||||
# Run a sequence of tests quietly, without the slow
|
||||
# gamma tests
|
||||
err=0
|
||||
|
||||
echo >> pngtest-log.txt
|
||||
echo "============ pngvalid-simple.sh ==============" >> pngtest-log.txt
|
||||
echo "Running test-pngvalid-simple.sh"
|
||||
# The options to test are:
|
||||
#
|
||||
# standard tests with and without progressive reading and interlace
|
||||
# size images with and without progressive reading
|
||||
# transform tests (standard, non-interlaced only)
|
||||
#
|
||||
for opts in "--standard" "--standard --progressive-read" \
|
||||
"--standard --interlace" "--standard --progressive-read --interlace" \
|
||||
"--size" "--size --progressive-read" \
|
||||
"--transform"
|
||||
do
|
||||
if ./pngvalid "$@" $opts >> pngtest-log.txt 2>&1
|
||||
then
|
||||
echo " PASS: pngvalid" "$@" $opts
|
||||
else
|
||||
echo " FAIL: pngvalid" "$@" $opts
|
||||
err=1
|
||||
fi
|
||||
done
|
||||
|
||||
exit $err
|
||||
303
contrib/libtests/timepng.c
Normal file
303
contrib/libtests/timepng.c
Normal file
@@ -0,0 +1,303 @@
|
||||
/* timepng.c
|
||||
*
|
||||
* Copyright (c) 2013 John Cunningham Bowler
|
||||
*
|
||||
* Last changed in libpng 1.6.0 [February 14, 2013]
|
||||
*
|
||||
* This code is released under the libpng license.
|
||||
* For conditions of distribution and use, see the disclaimer
|
||||
* and license in png.h
|
||||
*
|
||||
* Load an arbitrary number of PNG files (from the command line, or, if there
|
||||
* are no arguments on the command line, from stdin) then run a time test by
|
||||
* reading each file by row. The test does nothing with the read result and
|
||||
* does no transforms. The only output is a time as a floating point number of
|
||||
* seconds with 9 decimal digits.
|
||||
*/
|
||||
#define _POSIX_C_SOURCE 199309L /* for clock_gettime */
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <time.h>
|
||||
|
||||
#if (defined HAVE_CONFIG_H) && !(defined PNG_NO_CONFIG_H)
|
||||
# include <config.h>
|
||||
#endif
|
||||
|
||||
/* Define the following to use this test against your installed libpng, rather
|
||||
* than the one being built here:
|
||||
*/
|
||||
#ifdef PNG_FREESTANDING_TESTS
|
||||
# include <png.h>
|
||||
#else
|
||||
# include "../../png.h"
|
||||
#endif
|
||||
|
||||
static int read_png(FILE *fp)
|
||||
{
|
||||
png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,0);
|
||||
png_infop info_ptr = NULL;
|
||||
png_bytep row = NULL, display = NULL;
|
||||
|
||||
if (png_ptr == NULL)
|
||||
return 0;
|
||||
|
||||
if (setjmp(png_jmpbuf(png_ptr)))
|
||||
{
|
||||
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
|
||||
if (row != NULL) free(row);
|
||||
if (display != NULL) free(display);
|
||||
return 0;
|
||||
}
|
||||
|
||||
png_init_io(png_ptr, fp);
|
||||
|
||||
info_ptr = png_create_info_struct(png_ptr);
|
||||
if (info_ptr == NULL)
|
||||
png_error(png_ptr, "OOM allocating info structure");
|
||||
|
||||
png_read_info(png_ptr, info_ptr);
|
||||
|
||||
{
|
||||
png_size_t rowbytes = png_get_rowbytes(png_ptr, info_ptr);
|
||||
|
||||
row = malloc(rowbytes);
|
||||
display = malloc(rowbytes);
|
||||
|
||||
if (row == NULL || display == NULL)
|
||||
png_error(png_ptr, "OOM allocating row buffers");
|
||||
|
||||
{
|
||||
png_uint_32 height = png_get_image_height(png_ptr, info_ptr);
|
||||
int passes = png_set_interlace_handling(png_ptr);
|
||||
int pass;
|
||||
|
||||
png_start_read_image(png_ptr);
|
||||
|
||||
for (pass = 0; pass < passes; ++pass)
|
||||
{
|
||||
png_uint_32 y = height;
|
||||
|
||||
/* NOTE: this trashes the row each time; interlace handling won't
|
||||
* work, but this avoids memory thrashing for speed testing.
|
||||
*/
|
||||
while (y-- > 0)
|
||||
png_read_row(png_ptr, row, display);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Make sure to read to the end of the file: */
|
||||
png_read_end(png_ptr, info_ptr);
|
||||
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
|
||||
free(row);
|
||||
free(display);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int mytime(struct timespec *t)
|
||||
{
|
||||
/* Do the timing using clock_gettime and the per-process timer. */
|
||||
if (!clock_gettime(CLOCK_PROCESS_CPUTIME_ID, t))
|
||||
return 1;
|
||||
|
||||
perror("CLOCK_PROCESS_CPUTIME_ID");
|
||||
fprintf(stderr, "timepng: could not get the time\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int perform_one_test(FILE *fp, int nfiles)
|
||||
{
|
||||
int i;
|
||||
struct timespec before, after;
|
||||
|
||||
/* Clear out all errors: */
|
||||
rewind(fp);
|
||||
|
||||
if (mytime(&before))
|
||||
{
|
||||
for (i=0; i<nfiles; ++i)
|
||||
{
|
||||
if (read_png(fp))
|
||||
{
|
||||
if (ferror(fp))
|
||||
{
|
||||
perror("temporary file");
|
||||
fprintf(stderr, "file %d: error reading PNG data\n", i);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
perror("temporary file");
|
||||
fprintf(stderr, "file %d: error from libpng\n", i);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
else
|
||||
return 0;
|
||||
|
||||
if (mytime(&after))
|
||||
{
|
||||
/* Work out the time difference and print it - this is the only output,
|
||||
* so flush it immediately.
|
||||
*/
|
||||
unsigned long s = after.tv_sec - before.tv_sec;
|
||||
long ns = after.tv_nsec - before.tv_nsec;
|
||||
|
||||
if (ns < 0)
|
||||
{
|
||||
--s;
|
||||
ns += 1000000000;
|
||||
|
||||
if (ns < 0)
|
||||
{
|
||||
fprintf(stderr, "timepng: bad clock from kernel\n");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
printf("%lu.%.9ld\n", s, ns);
|
||||
fflush(stdout);
|
||||
if (ferror(stdout))
|
||||
{
|
||||
fprintf(stderr, "timepng: error writing output\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Successful return */
|
||||
return 1;
|
||||
}
|
||||
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int add_one_file(FILE *fp, char *name)
|
||||
{
|
||||
FILE *ip = fopen(name, "rb");
|
||||
|
||||
if (ip != NULL)
|
||||
{
|
||||
int ch;
|
||||
for (;;)
|
||||
{
|
||||
ch = getc(ip);
|
||||
if (ch == EOF) break;
|
||||
putc(ch, fp);
|
||||
}
|
||||
|
||||
if (ferror(ip))
|
||||
{
|
||||
perror(name);
|
||||
fprintf(stderr, "%s: read error\n", name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
(void)fclose(ip);
|
||||
|
||||
if (ferror(fp))
|
||||
{
|
||||
perror("temporary file");
|
||||
fprintf(stderr, "temporary file write error\n");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
perror(name);
|
||||
fprintf(stderr, "%s: open failed\n", name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
int ok = 0;
|
||||
FILE *fp = tmpfile();
|
||||
|
||||
if (fp != NULL)
|
||||
{
|
||||
int err = 0;
|
||||
int nfiles = 0;
|
||||
|
||||
if (argc > 1)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i=1; i<argc; ++i)
|
||||
{
|
||||
if (add_one_file(fp, argv[i]))
|
||||
++nfiles;
|
||||
|
||||
else
|
||||
{
|
||||
err = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
char filename[FILENAME_MAX+1];
|
||||
|
||||
while (fgets(filename, FILENAME_MAX+1, stdin))
|
||||
{
|
||||
int len = strlen(filename);
|
||||
|
||||
if (filename[len-1] == '\n')
|
||||
{
|
||||
filename[len-1] = 0;
|
||||
if (add_one_file(fp, filename))
|
||||
++nfiles;
|
||||
|
||||
else
|
||||
{
|
||||
err = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "timepng: truncated file name ...%s\n",
|
||||
filename+len-32);
|
||||
err = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (ferror(stdin))
|
||||
{
|
||||
fprintf(stderr, "timepng: stdin: read error\n");
|
||||
err = 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (!err)
|
||||
{
|
||||
if (nfiles > 0)
|
||||
ok = perform_one_test(fp, nfiles);
|
||||
|
||||
else
|
||||
fprintf(stderr, "usage: timepng {files} or ls files | timepng\n");
|
||||
}
|
||||
|
||||
(void)fclose(fp);
|
||||
}
|
||||
|
||||
else
|
||||
fprintf(stderr, "timepng: could not open temporary file\n");
|
||||
|
||||
/* Exit code 0 on success. */
|
||||
return ok == 0;
|
||||
}
|
||||
@@ -1,3 +1,4 @@
|
||||
|
||||
This demonstrates the use of PNG_USER_CONFIG, pngusr.h and pngusr.dfa
|
||||
to build minimal decoder, encoder, and progressive reader applications.
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# pngminim/decoder/pngusr.dfa
|
||||
#
|
||||
# Copyright (c) 2010-2011 Glenn Randers-Pehrson
|
||||
# Copyright (c) 2010-2013 Glenn Randers-Pehrson
|
||||
#
|
||||
# This code is released under the libpng license.
|
||||
# For conditions of distribution and use, see the disclaimer
|
||||
@@ -37,3 +37,4 @@ option SETJMP on
|
||||
option STDIO on
|
||||
option READ_EXPAND on
|
||||
option READ_STRIP_16_TO_8 on
|
||||
option USER_LIMITS on
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
/* minrdpngconf.h: headers to make a minimal png-read-only library
|
||||
*
|
||||
* Copyright (c) 2007, 2010-2011 Glenn Randers-Pehrson
|
||||
* Copyright (c) 2007, 2010-2013 Glenn Randers-Pehrson
|
||||
*
|
||||
* This code is released under the libpng license.
|
||||
* For conditions of distribution and use, see the disclaimer
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# pngminim/encoder/pngusr.dfa
|
||||
#
|
||||
# Copyright (c) 2010-2011 Glenn Randers-Pehrson
|
||||
# Copyright (c) 2010-2013 Glenn Randers-Pehrson
|
||||
#
|
||||
# This code is released under the libpng license.
|
||||
# For conditions of distribution and use, see the disclaimer
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
/* minwrpngconf.h: headers to make a minimal png-write-only library
|
||||
*
|
||||
* Copyright (c) 2007, 2010-2011 Glenn Randers-Pehrson
|
||||
* Copyright (c) 2007, 2010-2013 Glenn Randers-Pehrson
|
||||
*
|
||||
* This code is released under the libpng license.
|
||||
* For conditions of distribution and use, see the disclaimer
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# pngminim/preader/pngusr.dfa
|
||||
#
|
||||
# Copyright (c) 2010-2011 Glenn Randers-Pehrson
|
||||
# Copyright (c) 2010-2013 Glenn Randers-Pehrson
|
||||
#
|
||||
# This code is released under the libpng license.
|
||||
# For conditions of distribution and use, see the disclaimer
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
/* minrdpngconf.h: headers to make a minimal png-read-only library
|
||||
*
|
||||
* Copyright (c) 2009, 2010-2011 Glenn Randers-Pehrson
|
||||
* Copyright (c) 2009, 2010-2013 Glenn Randers-Pehrson
|
||||
*
|
||||
* This code is released under the libpng license.
|
||||
* For conditions of distribution and use, see the disclaimer
|
||||
|
||||
@@ -8,9 +8,9 @@ LD=$(CC)
|
||||
RM=rm -f
|
||||
|
||||
#PNGPATH = /usr/local
|
||||
#PNGINC = -I$(PNGPATH)/include/libpng15
|
||||
#PNGLIB = -L$(PNGPATH)/lib -lpng15
|
||||
#PNGLIBS = $(PNGPATH)/lib/libpng15.a
|
||||
#PNGINC = -I$(PNGPATH)/include/libpng16
|
||||
#PNGLIB = -L$(PNGPATH)/lib -lpng16
|
||||
#PNGLIBS = $(PNGPATH)/lib/libpng16.a
|
||||
PNGINC = -I../..
|
||||
PNGLIB = -L../.. -lpng
|
||||
PNGLIBS = ../../libpng.a
|
||||
|
||||
@@ -18,6 +18,7 @@
|
||||
#include <mem.h>
|
||||
#include <fcntl.h>
|
||||
#endif
|
||||
#include <zlib.h>
|
||||
|
||||
#ifndef BOOL
|
||||
#define BOOL unsigned char
|
||||
|
||||
@@ -18,6 +18,7 @@
|
||||
#include <mem.h>
|
||||
#include <fcntl.h>
|
||||
#endif
|
||||
#include <zlib.h>
|
||||
|
||||
#ifndef BOOL
|
||||
#define BOOL unsigned char
|
||||
@@ -197,6 +198,9 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
|
||||
char height_token[16];
|
||||
char maxval_token[16];
|
||||
int color_type;
|
||||
unsigned long ul_width, ul_alpha_width;
|
||||
unsigned long ul_height, ul_alpha_height;
|
||||
unsigned long ul_maxval;
|
||||
png_uint_32 width, alpha_width;
|
||||
png_uint_32 height, alpha_height;
|
||||
png_uint_32 maxval;
|
||||
@@ -227,11 +231,15 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
|
||||
raw = (type_token[1] == '5');
|
||||
color_type = PNG_COLOR_TYPE_GRAY;
|
||||
get_token(pnm_file, width_token);
|
||||
sscanf (width_token, "%lu", &width);
|
||||
sscanf (width_token, "%lu", &ul_width);
|
||||
width = (png_uint_32) ul_width;
|
||||
get_token(pnm_file, height_token);
|
||||
sscanf (height_token, "%lu", &height);
|
||||
sscanf (height_token, "%lu", &ul_height);
|
||||
height = (png_uint_32) ul_height;
|
||||
get_token(pnm_file, maxval_token);
|
||||
sscanf (maxval_token, "%lu", &maxval);
|
||||
sscanf (maxval_token, "%lu", &ul_maxval);
|
||||
maxval = (png_uint_32) ul_maxval;
|
||||
|
||||
if (maxval <= 1)
|
||||
bit_depth = 1;
|
||||
else if (maxval <= 3)
|
||||
@@ -248,11 +256,14 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
|
||||
raw = (type_token[1] == '6');
|
||||
color_type = PNG_COLOR_TYPE_RGB;
|
||||
get_token(pnm_file, width_token);
|
||||
sscanf (width_token, "%lu", &width);
|
||||
sscanf (width_token, "%lu", &ul_width);
|
||||
width = (png_uint_32) ul_width;
|
||||
get_token(pnm_file, height_token);
|
||||
sscanf (height_token, "%lu", &height);
|
||||
sscanf (height_token, "%lu", &ul_height);
|
||||
height = (png_uint_32) ul_height;
|
||||
get_token(pnm_file, maxval_token);
|
||||
sscanf (maxval_token, "%lu", &maxval);
|
||||
sscanf (maxval_token, "%lu", &ul_maxval);
|
||||
maxval = (png_uint_32) ul_maxval;
|
||||
if (maxval <= 1)
|
||||
bit_depth = 1;
|
||||
else if (maxval <= 3)
|
||||
@@ -287,15 +298,18 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
|
||||
{
|
||||
alpha_raw = (type_token[1] == '5');
|
||||
get_token(alpha_file, width_token);
|
||||
sscanf (width_token, "%lu", &alpha_width);
|
||||
sscanf (width_token, "%lu", &ul_alpha_width);
|
||||
alpha_width=(png_uint_32) ul_alpha_width;
|
||||
if (alpha_width != width)
|
||||
return FALSE;
|
||||
get_token(alpha_file, height_token);
|
||||
sscanf (height_token, "%lu", &alpha_height);
|
||||
sscanf (height_token, "%lu", &ul_alpha_height);
|
||||
alpha_height = (png_uint_32) ul_alpha_height;
|
||||
if (alpha_height != height)
|
||||
return FALSE;
|
||||
get_token(alpha_file, maxval_token);
|
||||
sscanf (maxval_token, "%lu", &maxval);
|
||||
sscanf (maxval_token, "%lu", &ul_maxval);
|
||||
maxval = (png_uint_32) ul_maxval;
|
||||
if (maxval <= 1)
|
||||
alpha_depth = 1;
|
||||
else if (maxval <= 3)
|
||||
@@ -510,6 +524,7 @@ png_uint_32 get_value (FILE *pnm_file, int depth)
|
||||
{
|
||||
static png_uint_32 mask = 0;
|
||||
png_byte token[16];
|
||||
unsigned long ul_ret_value;
|
||||
png_uint_32 ret_value;
|
||||
int i = 0;
|
||||
|
||||
@@ -518,7 +533,8 @@ png_uint_32 get_value (FILE *pnm_file, int depth)
|
||||
mask = (mask << 1) | 0x01;
|
||||
|
||||
get_token (pnm_file, (char *) token);
|
||||
sscanf ((const char *) token, "%lu", &ret_value);
|
||||
sscanf ((const char *) token, "%lu", &ul_ret_value);
|
||||
ret_value = (png_uint_32) ul_ret_value;
|
||||
|
||||
ret_value &= mask;
|
||||
|
||||
|
||||
26
contrib/tools/README.txt
Normal file
26
contrib/tools/README.txt
Normal file
@@ -0,0 +1,26 @@
|
||||
This directory (contrib/tools) contains tools used by the authors of libpng.
|
||||
|
||||
Code and data placed in this directory is not required to build libpng,
|
||||
however the code in this directory has been used to generate data or code in
|
||||
the body of the libpng source. The source code identifies where this has
|
||||
been done. Code in this directory may not compile on all operating systems
|
||||
that libpng supports.
|
||||
|
||||
NO COPYRIGHT RIGHTS ARE CLAIMED TO ANY OF THE FILES IN THIS DIRECTORY.
|
||||
|
||||
To the extent possible under law, the authors have waived all copyright and
|
||||
related or neighboring rights to this work. This work is published from:
|
||||
United States.
|
||||
|
||||
The files may be used freely in any way.
|
||||
|
||||
The source code and comments in this directory are the original work of the
|
||||
people named below. No other person or organization has made contributions to
|
||||
the work in this directory.
|
||||
|
||||
ORIGINAL AUTHORS
|
||||
The following people have contributed to the code in this directory. None
|
||||
of the people below claim any rights with regard to the contents of this
|
||||
directory.
|
||||
|
||||
John Bowler <jbowler@acm.org>
|
||||
102
contrib/tools/checksum-icc.c
Normal file
102
contrib/tools/checksum-icc.c
Normal file
@@ -0,0 +1,102 @@
|
||||
/* checksum-icc.c
|
||||
*
|
||||
* Copyright (c) 2013 John Cunningham Bowler
|
||||
*
|
||||
* Last changed in libpng 1.6.0 [February 14, 2013]
|
||||
*
|
||||
* This code is released under the libpng license.
|
||||
* For conditions of distribution and use, see the disclaimer
|
||||
* and license in png.h
|
||||
*
|
||||
* Generate crc32 and adler32 checksums of the given input files, used to
|
||||
* generate check-codes for use when matching ICC profiles within libpng.
|
||||
*/
|
||||
#include <stdio.h>
|
||||
|
||||
#include <zlib.h>
|
||||
|
||||
static int
|
||||
read_one_file(FILE *ip, const char *name)
|
||||
{
|
||||
uLong length = 0;
|
||||
uLong a32 = adler32(0, NULL, 0);
|
||||
uLong c32 = crc32(0, NULL, 0);
|
||||
Byte header[132];
|
||||
|
||||
for (;;)
|
||||
{
|
||||
int ch = getc(ip);
|
||||
Byte b;
|
||||
|
||||
if (ch == EOF) break;
|
||||
|
||||
b = (Byte)ch;
|
||||
|
||||
if (length < sizeof header)
|
||||
header[length] = b;
|
||||
|
||||
++length;
|
||||
a32 = adler32(a32, &b, 1);
|
||||
c32 = crc32(c32, &b, 1);
|
||||
}
|
||||
|
||||
if (ferror(ip))
|
||||
return 0;
|
||||
|
||||
/* Success */
|
||||
printf("PNG_ICC_CHECKSUM(0x%8.8lx, 0x%8.8lx,\n PNG_MD5("
|
||||
"0x%2.2x%2.2x%2.2x%2.2x, 0x%2.2x%2.2x%2.2x%2.2x, 0x%2.2x%2.2x%2.2x%2.2x,"
|
||||
" 0x%2.2x%2.2x%2.2x%2.2x), %d,\n"
|
||||
" \"%4.4d/%2.2d/%2.2d %2.2d:%2.2d:%2.2d\", %lu, \"%s\")\n",
|
||||
(unsigned long)a32, (unsigned long)c32,
|
||||
header[84], header[85], header[86], header[87],
|
||||
header[88], header[89], header[90], header[91],
|
||||
header[92], header[93], header[94], header[95],
|
||||
header[96], header[97], header[98], header[99],
|
||||
# define u16(x) (header[x] * 256 + header[x+1])
|
||||
# define u32(x) (u16(x) * 65536 + u16(x+2))
|
||||
u32(64), u16(24), u16(26), u16(28), u16(30), u16(32), u16(34),
|
||||
(unsigned long)length, name);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
int err = 0;
|
||||
|
||||
printf("/* adler32, crc32, MD5[16], intent, date, length, file-name */\n");
|
||||
|
||||
if (argc > 1)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i=1; i<argc; ++i)
|
||||
{
|
||||
FILE *ip = fopen(argv[i], "rb");
|
||||
|
||||
if (ip == NULL || !read_one_file(ip, argv[i]))
|
||||
{
|
||||
err = 1;
|
||||
perror(argv[i]);
|
||||
fprintf(stderr, "%s: read error\n", argv[i]);
|
||||
printf("/* ERROR: %s */\n", argv[i]);
|
||||
}
|
||||
|
||||
(void)fclose(ip);
|
||||
}
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
if (!read_one_file(stdin, "-"))
|
||||
{
|
||||
err = 1;
|
||||
perror("stdin");
|
||||
fprintf(stderr, "stdin: read error\n");
|
||||
printf("/* ERROR: stdin */\n");
|
||||
}
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
137
contrib/tools/chkfmt
Executable file
137
contrib/tools/chkfmt
Executable file
@@ -0,0 +1,137 @@
|
||||
#!/bin/sh
|
||||
#
|
||||
# Check the format of the source files in the current directory - checks for a
|
||||
# line length of 80 characters max and no tab characters.
|
||||
#
|
||||
# Optionally arguments are files or directories to check.
|
||||
#
|
||||
# -v: output the long lines (makes fixing them easier)
|
||||
# -e: spawn an editor for each file that needs a change ($EDITOR must be
|
||||
# defined). When using -e the script MUST be run from an interactive
|
||||
# command line.
|
||||
verbose=
|
||||
edit=
|
||||
vers=
|
||||
test "$1" = "-v" && {
|
||||
shift
|
||||
verbose=yes
|
||||
}
|
||||
test "$1" = "-e" && {
|
||||
shift
|
||||
if test -n "$EDITOR"
|
||||
then
|
||||
edit=yes
|
||||
|
||||
# Copy the standard streams for the editor
|
||||
exec 3>&0 4>&1 5>&2
|
||||
else
|
||||
echo "chkfmt -e: EDITOR must be defined" >&2
|
||||
exit 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Function to edit a single file - if the file isn't changed ask the user
|
||||
# whether or not to continue. This stuff only works if the script is run from
|
||||
# the command line (otherwise, don't specify -e or you will be sorry).
|
||||
doed(){
|
||||
cp "$file" "$file".orig
|
||||
"$EDITOR" "$file" 0>&3 1>&4 2>&5 3>&- 4>&- 5>&- || exit 1
|
||||
if cmp -s "$file".orig "$file"
|
||||
then
|
||||
rm "$file".orig
|
||||
echo -n "$file: file not changed, type anything to continue: " >&5
|
||||
read ans 0>&3
|
||||
test -n "$ans" || return 1
|
||||
fi
|
||||
return 0
|
||||
}
|
||||
|
||||
# In beta versions the version string which appears in files can be a little
|
||||
# long and cause spuriously overlong lines. To avoid this subtitute the version
|
||||
# string with a 'standard' version a.b.cc before checking for long lines.
|
||||
if test -r png.h
|
||||
then
|
||||
vers="`sed -n -e \
|
||||
's/^#define PNG_LIBPNG_VER_STRING .\([0-9]\.[0-9]\.[0-9][0-9a-z]*\).$/\1/p' \
|
||||
png.h`"
|
||||
echo "chkfmt: checking version $vers"
|
||||
fi
|
||||
if test -z "$vers"
|
||||
then
|
||||
echo "chkfmt: png.h not found, ignoring version number" >&2
|
||||
fi
|
||||
|
||||
test -n "$1" || set -- .
|
||||
find "$@" \( -type d \( -name '.git' -o -name '.libs' -o -name 'projects' \) \
|
||||
-prune \) -o \( -type f \
|
||||
! -name '*.[oa]' ! -name '*.l[oa]' ! -name '*.png' ! -name '*.out' \
|
||||
! -name '*.jpg' ! -name '*.patch' ! -name '*.obj' ! -name '*.exe' \
|
||||
! -name '*.com' ! -name '*.tar.*' ! -name '*.zip' ! -name '*.ico' \
|
||||
! -name '*.res' ! -name '*.rc' ! -name '*.mms' ! -name '*.rej' \
|
||||
! -name '*.dsp' ! -name '*.orig' ! -name '*.dfn' ! -name '*.swp' \
|
||||
! -name '~*' ! -name '*.3' \
|
||||
! -name 'missing' ! -name 'mkinstalldirs' ! -name 'depcomp' \
|
||||
! -name 'aclocal.m4' ! -name 'install-sh' ! -name 'Makefile.in' \
|
||||
! -name 'ltmain.sh' ! -name 'config*' -print \) | {
|
||||
st=0
|
||||
while read file
|
||||
do
|
||||
case "$file" in
|
||||
*.mak|*[Mm]akefile.*|*[Mm]akefile)
|
||||
# Makefiles require tabs, dependency lines can be this long.
|
||||
check_tabs=
|
||||
line_length=100;;
|
||||
*.awk)
|
||||
# Includes literal tabs
|
||||
check_tabs=
|
||||
# The following is arbitrary
|
||||
line_length=132;;
|
||||
*contrib/*/*.[ch])
|
||||
check_tabs=yes
|
||||
line_length=96;;
|
||||
*)
|
||||
check_tabs=yes
|
||||
line_length=80;;
|
||||
esac
|
||||
|
||||
# Note that vers can only contain 0-9, . and a-z
|
||||
if test -n "$vers"
|
||||
then
|
||||
sed -e "s/$vers/a.b.cc/g" "$file" >"$file".$$
|
||||
else
|
||||
cp "$file" "$file".$$
|
||||
fi
|
||||
splt="`fold -$line_length "$file".$$ | diff -c "$file".$$ -`"
|
||||
rm "$file".$$
|
||||
|
||||
if test -n "$splt"
|
||||
then
|
||||
echo "$file: lines too long"
|
||||
st=1
|
||||
if test -n "$EDITOR" -a -n "$edit"
|
||||
then
|
||||
doed "$file" || exit 1
|
||||
elif test -n "$verbose"
|
||||
then
|
||||
echo "$splt"
|
||||
fi
|
||||
fi
|
||||
if test -n "$check_tabs"
|
||||
then
|
||||
tab="`tr -c -d '\t' <"$file"`"
|
||||
if test -n "$tab"
|
||||
then
|
||||
echo "$file: file contains tab characters"
|
||||
st=1
|
||||
if test -n "$EDITOR" -a -n "$edit"
|
||||
then
|
||||
doed "$file" || exit 1
|
||||
elif test -n "$verbose"
|
||||
then
|
||||
echo "$splt"
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
done
|
||||
exit $st
|
||||
}
|
||||
188
contrib/tools/cvtcolor.c
Normal file
188
contrib/tools/cvtcolor.c
Normal file
@@ -0,0 +1,188 @@
|
||||
/*-
|
||||
* convert.c
|
||||
*
|
||||
* Last changed in libpng 1.6.0 [February 14, 2013]
|
||||
*
|
||||
* COPYRIGHT: Written by John Cunningham Bowler, 2012.
|
||||
* To the extent possible under law, the author has waived all copyright and
|
||||
* related or neighboring rights to this work. This work is published from:
|
||||
* United States.
|
||||
*
|
||||
* Convert 8-bit sRGB or 16-bit linear values to another format.
|
||||
*/
|
||||
#define _ISOC99_SOURCE 1
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include <fenv.h>
|
||||
|
||||
#include "sRGB.h"
|
||||
|
||||
static void
|
||||
usage(const char *prog)
|
||||
{
|
||||
fprintf(stderr,
|
||||
"%s: usage: %s [-linear|-sRGB] [-gray|-color] component{1,4}\n",
|
||||
prog, prog);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
unsigned long
|
||||
component(const char *prog, const char *arg, int issRGB)
|
||||
{
|
||||
char *ep;
|
||||
unsigned long c = strtoul(arg, &ep, 0);
|
||||
|
||||
if (ep <= arg || *ep || c > 65535 || (issRGB && c > 255))
|
||||
{
|
||||
fprintf(stderr, "%s: %s: invalid component value (%lu)\n", prog, arg, c);
|
||||
usage(prog);
|
||||
}
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, const char **argv)
|
||||
{
|
||||
const char *prog = *argv++;
|
||||
int to_linear = 0, to_gray = 0, to_color = 0;
|
||||
int channels = 0;
|
||||
double c[4];
|
||||
|
||||
/* FE_TONEAREST is the IEEE754 round to nearest, preferring even, mode; i.e.
|
||||
* everything rounds to the nearest value except that '.5' rounds to the
|
||||
* nearest even value.
|
||||
*/
|
||||
fesetround(FE_TONEAREST);
|
||||
|
||||
c[3] = c[2] = c[1] = c[0] = 0;
|
||||
|
||||
while (--argc > 0 && **argv == '-')
|
||||
{
|
||||
const char *arg = 1+*argv++;
|
||||
|
||||
if (strcmp(arg, "sRGB") == 0)
|
||||
to_linear = 0;
|
||||
|
||||
else if (strcmp(arg, "linear") == 0)
|
||||
to_linear = 1;
|
||||
|
||||
else if (strcmp(arg, "gray") == 0)
|
||||
to_gray = 1, to_color = 0;
|
||||
|
||||
else if (strcmp(arg, "color") == 0)
|
||||
to_gray = 0, to_color = 1;
|
||||
|
||||
else
|
||||
usage(prog);
|
||||
}
|
||||
|
||||
switch (argc)
|
||||
{
|
||||
default:
|
||||
usage(prog);
|
||||
break;
|
||||
|
||||
case 4:
|
||||
c[3] = component(prog, argv[3], to_linear);
|
||||
++channels;
|
||||
case 3:
|
||||
c[2] = component(prog, argv[2], to_linear);
|
||||
++channels;
|
||||
case 2:
|
||||
c[1] = component(prog, argv[1], to_linear);
|
||||
++channels;
|
||||
case 1:
|
||||
c[0] = component(prog, argv[0], to_linear);
|
||||
++channels;
|
||||
break;
|
||||
}
|
||||
|
||||
if (to_linear)
|
||||
{
|
||||
int i;
|
||||
int components = channels;
|
||||
|
||||
if ((components & 1) == 0)
|
||||
--components;
|
||||
|
||||
for (i=0; i<components; ++i) c[i] = linear_from_sRGB(c[i] / 255);
|
||||
if (components < channels)
|
||||
c[components] = c[components] / 255;
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
int i;
|
||||
for (i=0; i<4; ++i) c[i] /= 65535;
|
||||
|
||||
if ((channels & 1) == 0)
|
||||
{
|
||||
double alpha = c[channels-1];
|
||||
|
||||
if (alpha > 0)
|
||||
for (i=0; i<channels-1; ++i) c[i] /= alpha;
|
||||
else
|
||||
for (i=0; i<channels-1; ++i) c[i] = 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (to_gray)
|
||||
{
|
||||
if (channels < 3)
|
||||
{
|
||||
fprintf(stderr, "%s: too few channels (%d) for -gray\n",
|
||||
prog, channels);
|
||||
usage(prog);
|
||||
}
|
||||
|
||||
c[0] = YfromRGB(c[0], c[1], c[2]);
|
||||
channels -= 2;
|
||||
}
|
||||
|
||||
if (to_color)
|
||||
{
|
||||
if (channels > 2)
|
||||
{
|
||||
fprintf(stderr, "%s: too many channels (%d) for -color\n",
|
||||
prog, channels);
|
||||
usage(prog);
|
||||
}
|
||||
|
||||
c[3] = c[1]; /* alpha, if present */
|
||||
c[2] = c[1] = c[0];
|
||||
}
|
||||
|
||||
if (to_linear)
|
||||
{
|
||||
int i;
|
||||
if ((channels & 1) == 0)
|
||||
{
|
||||
double alpha = c[channels-1];
|
||||
for (i=0; i<channels-1; ++i) c[i] *= alpha;
|
||||
}
|
||||
|
||||
for (i=0; i<channels; ++i) c[i] = nearbyint(c[i] * 65535);
|
||||
}
|
||||
|
||||
else /* to sRGB */
|
||||
{
|
||||
int i = (channels+1)&~1;
|
||||
while (--i >= 0)
|
||||
c[i] = sRGB_from_linear(c[i]);
|
||||
|
||||
for (i=0; i<channels; ++i) c[i] = nearbyint(c[i] * 255);
|
||||
}
|
||||
|
||||
{
|
||||
int i;
|
||||
for (i=0; i<channels; ++i) printf(" %g", c[i]);
|
||||
}
|
||||
printf("\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
110
contrib/tools/intgamma.sh
Normal file
110
contrib/tools/intgamma.sh
Normal file
@@ -0,0 +1,110 @@
|
||||
#!/bin/sh
|
||||
#
|
||||
# intgamma.sh
|
||||
#
|
||||
# Last changed in libpng 1.6.0 [February 14, 2013]
|
||||
#
|
||||
# COPYRIGHT: Written by John Cunningham Bowler, 2012.
|
||||
# To the extent possible under law, the author has waived all copyright and
|
||||
# related or neighboring rights to this work. This work is published from:
|
||||
# United States.
|
||||
#
|
||||
# Shell script to generate png.c 8-bit and 16-bit log tables (see the code in
|
||||
# png.c for details).
|
||||
#
|
||||
# This script uses the "bc" arbitrary precision calculator to calculate 32-bit
|
||||
# fixed point values of logarithms appropriate to finding the log of an 8-bit
|
||||
# (0..255) value and a similar table for the exponent calculation.
|
||||
#
|
||||
# "bc" must be on the path when the script is executed, and the math library
|
||||
# (-lm) must be available
|
||||
#
|
||||
# function to print out a list of numbers as integers; the function truncates
|
||||
# the integers which must be one-per-line
|
||||
function print(){
|
||||
awk 'BEGIN{
|
||||
str = ""
|
||||
}
|
||||
{
|
||||
sub("\\.[0-9]*$", "")
|
||||
if ($0 == "")
|
||||
$0 = "0"
|
||||
|
||||
if (str == "")
|
||||
t = " " $0 "U"
|
||||
else
|
||||
t = str ", " $0 "U"
|
||||
|
||||
if (length(t) >= 80) {
|
||||
print str ","
|
||||
str = " " $0 "U"
|
||||
} else
|
||||
str = t
|
||||
}
|
||||
END{
|
||||
print str
|
||||
}'
|
||||
}
|
||||
#
|
||||
# The logarithm table.
|
||||
cat <<END
|
||||
/* 8-bit log table: png_8bit_l2[128]
|
||||
* This is a table of -log(value/255)/log(2) for 'value' in the range 128 to
|
||||
* 255, so it's the base 2 logarithm of a normalized 8-bit floating point
|
||||
* mantissa. The numbers are 32-bit fractions.
|
||||
*/
|
||||
static const png_uint_32
|
||||
png_8bit_l2[128] =
|
||||
{
|
||||
END
|
||||
#
|
||||
bc -lqws <<END | print
|
||||
f=65536*65536/l(2)
|
||||
for (i=128;i<256;++i) { .5 - l(i/255)*f; }
|
||||
END
|
||||
echo '};'
|
||||
echo
|
||||
#
|
||||
# The exponent table.
|
||||
cat <<END
|
||||
/* The 'exp()' case must invert the above, taking a 20-bit fixed point
|
||||
* logarithmic value and returning a 16 or 8-bit number as appropriate. In
|
||||
* each case only the low 16 bits are relevant - the fraction - since the
|
||||
* integer bits (the top 4) simply determine a shift.
|
||||
*
|
||||
* The worst case is the 16-bit distinction between 65535 and 65534; this
|
||||
* requires perhaps spurious accuracy in the decoding of the logarithm to
|
||||
* distinguish log2(65535/65534.5) - 10^-5 or 17 bits. There is little chance
|
||||
* of getting this accuracy in practice.
|
||||
*
|
||||
* To deal with this the following exp() function works out the exponent of the
|
||||
* frational part of the logarithm by using an accurate 32-bit value from the
|
||||
* top four fractional bits then multiplying in the remaining bits.
|
||||
*/
|
||||
static const png_uint_32
|
||||
png_32bit_exp[16] =
|
||||
{
|
||||
END
|
||||
#
|
||||
bc -lqws <<END | print
|
||||
f=l(2)/16
|
||||
for (i=0;i<16;++i) {
|
||||
x = .5 + e(-i*f)*2^32;
|
||||
if (x >= 2^32) x = 2^32-1;
|
||||
x;
|
||||
}
|
||||
END
|
||||
echo '};'
|
||||
echo
|
||||
#
|
||||
# And the table of adjustment values.
|
||||
cat <<END
|
||||
/* Adjustment table; provided to explain the numbers in the code below. */
|
||||
#if 0
|
||||
END
|
||||
bc -lqws <<END | awk '{ printf "%5d %s\n", 12-NR, $0 }'
|
||||
for (i=11;i>=0;--i){
|
||||
(1 - e(-(2^i)/65536*l(2))) * 2^(32-i)
|
||||
}
|
||||
END
|
||||
echo '#endif'
|
||||
430
contrib/tools/makesRGB.c
Normal file
430
contrib/tools/makesRGB.c
Normal file
@@ -0,0 +1,430 @@
|
||||
/* makesRGB.c -- build sRGB-to-linear and linear-to-sRGB conversion tables
|
||||
*
|
||||
* Last changed in libpng 1.6.0 [February 14, 2013]
|
||||
*
|
||||
* COPYRIGHT: Written by John Cunningham Bowler, 2012.
|
||||
* To the extent possible under law, the author has waived all copyright and
|
||||
* related or neighboring rights to this work. This work is published from:
|
||||
* United States.
|
||||
*
|
||||
* Make a table to convert 8-bit sRGB encoding values into the closest 16-bit
|
||||
* linear value.
|
||||
*
|
||||
* Make two tables to take a linear value scaled to 255*65535 and return an
|
||||
* approximation to the 8-bit sRGB encoded value. Calculate the error in these
|
||||
* tables and display it.
|
||||
*/
|
||||
#define _C99_SOURCE 1
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
/* pngpriv.h includes the definition of 'PNG_sRGB_FROM_LINEAR' which is required
|
||||
* to verify the actual code.
|
||||
*/
|
||||
#include "../../pngpriv.h"
|
||||
|
||||
#include "sRGB.h"
|
||||
|
||||
/* The tables are declared 'const' in pngpriv.h, so this redefines the tables to
|
||||
* be used.
|
||||
*/
|
||||
#define png_sRGB_table sRGB_table
|
||||
#define png_sRGB_base sRGB_base
|
||||
#define png_sRGB_delta sRGB_delta
|
||||
|
||||
static png_uint_16 png_sRGB_table[256];
|
||||
static png_uint_16 png_sRGB_base[512];
|
||||
static png_byte png_sRGB_delta[512];
|
||||
|
||||
static const unsigned int max_input = 255*65535;
|
||||
|
||||
double
|
||||
fsRGB(double l)
|
||||
{
|
||||
return sRGB_from_linear(l/max_input);
|
||||
}
|
||||
|
||||
double
|
||||
sRGB(unsigned int i)
|
||||
{
|
||||
return fsRGB(i);
|
||||
}
|
||||
|
||||
double
|
||||
finvsRGB(unsigned int i)
|
||||
{
|
||||
return 65535 * linear_from_sRGB(i/255.);
|
||||
}
|
||||
|
||||
png_uint_16
|
||||
invsRGB(unsigned int i)
|
||||
{
|
||||
unsigned int x = nearbyint(finvsRGB(i));
|
||||
|
||||
if (x > 65535)
|
||||
{
|
||||
fprintf(stderr, "invsRGB(%u) overflows to %u\n", i, x);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
return (png_uint_16)x;
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, char **argv)
|
||||
{
|
||||
unsigned int i, i16, ibase;
|
||||
double min_error = 0;
|
||||
double max_error = 0;
|
||||
double min_error16 = 0;
|
||||
double max_error16 = 0;
|
||||
double adjust;
|
||||
double adjust_lo = 0.4, adjust_hi = 0.6, adjust_mid = 0.5;
|
||||
unsigned int ec_lo = 0, ec_hi = 0, ec_mid = 0;
|
||||
unsigned int error_count = 0;
|
||||
unsigned int error_count16 = 0;
|
||||
int test_only = 0;
|
||||
|
||||
if (argc > 1)
|
||||
test_only = strcmp("--test", argv[1]) == 0;
|
||||
|
||||
/* Initialize the encoding table first. */
|
||||
for (i=0; i<256; ++i)
|
||||
{
|
||||
png_sRGB_table[i] = invsRGB(i);
|
||||
}
|
||||
|
||||
/* Now work out the decoding tables (this is where the error comes in because
|
||||
* there are 512 set points and 512 straight lines between them.)
|
||||
*/
|
||||
for (;;)
|
||||
{
|
||||
if (ec_lo == 0)
|
||||
adjust = adjust_lo;
|
||||
|
||||
else if (ec_hi == 0)
|
||||
adjust = adjust_hi;
|
||||
|
||||
else if (ec_mid == 0)
|
||||
adjust = adjust_mid;
|
||||
|
||||
else if (ec_mid < ec_hi)
|
||||
adjust = (adjust_mid + adjust_hi)/2;
|
||||
|
||||
else if (ec_mid < ec_lo)
|
||||
adjust = (adjust_mid + adjust_lo)/2;
|
||||
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "not reached: %u .. %u .. %u\n", ec_lo, ec_mid, ec_hi);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
/* Calculate the table using the current 'adjust' */
|
||||
for (i=0; i<=511; ++i)
|
||||
{
|
||||
double lo = 255 * sRGB(i << 15);
|
||||
double hi = 255 * sRGB((i+1) << 15);
|
||||
unsigned int calc;
|
||||
|
||||
calc = nearbyint((lo+adjust) * 256);
|
||||
if (calc > 65535)
|
||||
{
|
||||
fprintf(stderr, "table[%d][0]: overflow %08x (%d)\n", i, calc,
|
||||
calc);
|
||||
exit(1);
|
||||
}
|
||||
png_sRGB_base[i] = calc;
|
||||
|
||||
calc = nearbyint((hi-lo) * 32);
|
||||
if (calc > 255)
|
||||
{
|
||||
fprintf(stderr, "table[%d][1]: overflow %08x (%d)\n", i, calc,
|
||||
calc);
|
||||
exit(1);
|
||||
}
|
||||
png_sRGB_delta[i] = calc;
|
||||
}
|
||||
|
||||
/* Check the 16-bit linear values alone: */
|
||||
error_count16 = 0;
|
||||
for (i16=0; i16 <= 65535; ++i16)
|
||||
{
|
||||
unsigned int i = 255*i16;
|
||||
unsigned int iexact = nearbyint(255*sRGB(i));
|
||||
unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
|
||||
|
||||
if (icalc != iexact)
|
||||
++error_count16;
|
||||
}
|
||||
|
||||
/* Now try changing the adjustment. */
|
||||
if (ec_lo == 0)
|
||||
ec_lo = error_count16;
|
||||
|
||||
else if (ec_hi == 0)
|
||||
ec_hi = error_count16;
|
||||
|
||||
else if (ec_mid == 0)
|
||||
{
|
||||
ec_mid = error_count16;
|
||||
printf("/* initial error counts: %u .. %u .. %u */\n", ec_lo, ec_mid,
|
||||
ec_hi);
|
||||
}
|
||||
|
||||
else if (error_count16 < ec_mid)
|
||||
{
|
||||
printf("/* adjust (mid ): %f: %u -> %u */\n", adjust, ec_mid,
|
||||
error_count16);
|
||||
ec_mid = error_count16;
|
||||
adjust_mid = adjust;
|
||||
}
|
||||
|
||||
else if (adjust < adjust_mid && error_count16 < ec_lo)
|
||||
{
|
||||
printf("/* adjust (low ): %f: %u -> %u */\n", adjust, ec_lo,
|
||||
error_count16);
|
||||
ec_lo = error_count16;
|
||||
adjust_lo = adjust;
|
||||
}
|
||||
|
||||
else if (adjust > adjust_mid && error_count16 < ec_hi)
|
||||
{
|
||||
printf("/* adjust (high): %f: %u -> %u */\n", adjust, ec_hi,
|
||||
error_count16);
|
||||
ec_hi = error_count16;
|
||||
adjust_hi = adjust;
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
adjust = adjust_mid;
|
||||
printf("/* adjust: %f: %u */\n", adjust, ec_mid);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* For each entry in the table try to adjust it to minimize the error count
|
||||
* in that entry. Each entry corresponds to 128 input values.
|
||||
*/
|
||||
for (ibase=0; ibase<65536; ibase+=128)
|
||||
{
|
||||
png_uint_16 base = png_sRGB_base[ibase >> 7], trybase = base, ob=base;
|
||||
png_byte delta = png_sRGB_delta[ibase >> 7], trydelta = delta, od=delta;
|
||||
unsigned int ecbase = 0, eco;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
png_sRGB_base[ibase >> 7] = trybase;
|
||||
png_sRGB_delta[ibase >> 7] = trydelta;
|
||||
|
||||
/* Check the 16-bit linear values alone: */
|
||||
error_count16 = 0;
|
||||
for (i16=ibase; i16 < ibase+128; ++i16)
|
||||
{
|
||||
unsigned int i = 255*i16;
|
||||
unsigned int iexact = nearbyint(255*sRGB(i));
|
||||
unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
|
||||
|
||||
if (icalc != iexact)
|
||||
++error_count16;
|
||||
}
|
||||
|
||||
if (error_count16 == 0)
|
||||
break;
|
||||
|
||||
if (ecbase == 0)
|
||||
{
|
||||
eco = ecbase = error_count16;
|
||||
++trybase; /* First test */
|
||||
}
|
||||
|
||||
else if (error_count16 < ecbase)
|
||||
{
|
||||
if (trybase > base)
|
||||
{
|
||||
base = trybase;
|
||||
++trybase;
|
||||
}
|
||||
else if (trybase < base)
|
||||
{
|
||||
base = trybase;
|
||||
--trybase;
|
||||
}
|
||||
else if (trydelta > delta)
|
||||
{
|
||||
delta = trydelta;
|
||||
++trydelta;
|
||||
}
|
||||
else if (trydelta < delta)
|
||||
{
|
||||
delta = trydelta;
|
||||
--trydelta;
|
||||
}
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "makesRGB: impossible\n");
|
||||
exit(1);
|
||||
}
|
||||
ecbase = error_count16;
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
if (trybase > base)
|
||||
trybase = base-1;
|
||||
else if (trybase < base)
|
||||
{
|
||||
trybase = base;
|
||||
++trydelta;
|
||||
}
|
||||
else if (trydelta > delta)
|
||||
trydelta = delta-1;
|
||||
else if (trydelta < delta)
|
||||
break; /* end of tests */
|
||||
}
|
||||
}
|
||||
|
||||
png_sRGB_base[ibase >> 7] = base;
|
||||
png_sRGB_delta[ibase >> 7] = delta;
|
||||
if (base != ob || delta != od)
|
||||
{
|
||||
printf("/* table[%u]={%u,%u} -> {%u,%u} %u -> %u errors */\n",
|
||||
ibase>>7, ob, od, base, delta, eco, ecbase);
|
||||
}
|
||||
else if (0)
|
||||
printf("/* table[%u]={%u,%u} %u errors */\n", ibase>>7, ob, od,
|
||||
ecbase);
|
||||
}
|
||||
|
||||
/* Only do the full (slow) test at the end: */
|
||||
min_error = -.4999;
|
||||
max_error = .4999;
|
||||
error_count = 0;
|
||||
|
||||
for (i=0; i <= max_input; ++i)
|
||||
{
|
||||
unsigned int iexact = nearbyint(255*sRGB(i));
|
||||
unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
|
||||
|
||||
if (icalc != iexact)
|
||||
{
|
||||
double err = 255*sRGB(i) - icalc;
|
||||
|
||||
if (err > (max_error+.001) || err < (min_error-.001))
|
||||
{
|
||||
printf(
|
||||
"/* 0x%08x: exact: %3d, got: %3d [tables: %08x, %08x] (%f) */\n",
|
||||
i, iexact, icalc, png_sRGB_base[i>>15],
|
||||
png_sRGB_delta[i>>15], err);
|
||||
}
|
||||
|
||||
++error_count;
|
||||
if (err > max_error)
|
||||
max_error = err;
|
||||
else if (err < min_error)
|
||||
min_error = err;
|
||||
}
|
||||
}
|
||||
|
||||
/* Re-check the 16-bit cases too, including the warning if there is an error
|
||||
* bigger than 1.
|
||||
*/
|
||||
error_count16 = 0;
|
||||
max_error16 = 0;
|
||||
min_error16 = 0;
|
||||
for (i16=0; i16 <= 65535; ++i16)
|
||||
{
|
||||
unsigned int i = 255*i16;
|
||||
unsigned int iexact = nearbyint(255*sRGB(i));
|
||||
unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
|
||||
|
||||
if (icalc != iexact)
|
||||
{
|
||||
double err = 255*sRGB(i) - icalc;
|
||||
|
||||
++error_count16;
|
||||
if (err > max_error16)
|
||||
max_error16 = err;
|
||||
else if (err < min_error16)
|
||||
min_error16 = err;
|
||||
|
||||
if (abs(icalc - iexact) > 1)
|
||||
printf(
|
||||
"/* 0x%04x: exact: %3d, got: %3d [tables: %08x, %08x] (%f) */\n",
|
||||
i16, iexact, icalc, png_sRGB_base[i>>15],
|
||||
png_sRGB_delta[i>>15], err);
|
||||
}
|
||||
}
|
||||
|
||||
/* Check the round trip for each 8-bit sRGB value. */
|
||||
for (i16=0; i16 <= 255; ++i16)
|
||||
{
|
||||
unsigned int i = 255 * png_sRGB_table[i16];
|
||||
unsigned int iexact = nearbyint(255*sRGB(i));
|
||||
unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
|
||||
|
||||
if (i16 != iexact)
|
||||
{
|
||||
fprintf(stderr, "8-bit rounding error: %d -> %d\n", i16, iexact);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
if (icalc != i16)
|
||||
{
|
||||
double finv = finvsRGB(i16);
|
||||
|
||||
printf("/* 8-bit roundtrip error: %d -> %f -> %d(%f) */\n",
|
||||
i16, finv, icalc, fsRGB(255*finv));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
printf("/* error: %g - %g, %u (%g%%) of readings inexact */\n",
|
||||
min_error, max_error, error_count, (100.*error_count)/max_input);
|
||||
printf("/* 16-bit error: %g - %g, %u (%g%%) of readings inexact */\n",
|
||||
min_error16, max_error16, error_count16, (100.*error_count16)/65535);
|
||||
|
||||
if (!test_only)
|
||||
{
|
||||
printf("PNG_CONST png_uint_16 png_sRGB_table[256] =\n{\n ");
|
||||
for (i=0; i<255; )
|
||||
{
|
||||
do
|
||||
{
|
||||
printf("%d,", png_sRGB_table[i++]);
|
||||
}
|
||||
while ((i & 0x7) != 0 && i<255);
|
||||
if (i<255) printf("\n ");
|
||||
}
|
||||
printf("%d\n};\n\n", png_sRGB_table[i]);
|
||||
|
||||
|
||||
printf("PNG_CONST png_uint_16 png_sRGB_base[512] =\n{\n ");
|
||||
for (i=0; i<511; )
|
||||
{
|
||||
do
|
||||
{
|
||||
printf("%d,", png_sRGB_base[i++]);
|
||||
}
|
||||
while ((i & 0x7) != 0 && i<511);
|
||||
if (i<511) printf("\n ");
|
||||
}
|
||||
printf("%d\n};\n\n", png_sRGB_base[i]);
|
||||
|
||||
printf("PNG_CONST png_byte png_sRGB_delta[512] =\n{\n ");
|
||||
for (i=0; i<511; )
|
||||
{
|
||||
do
|
||||
{
|
||||
printf("%d,", png_sRGB_delta[i++]);
|
||||
}
|
||||
while ((i & 0xf) != 0 && i<511);
|
||||
if (i<511) printf("\n ");
|
||||
}
|
||||
printf("%d\n};\n\n", png_sRGB_delta[i]);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
48
contrib/tools/sRGB.h
Normal file
48
contrib/tools/sRGB.h
Normal file
@@ -0,0 +1,48 @@
|
||||
/*-
|
||||
* sRGB.h
|
||||
*
|
||||
* Last changed in libpng 1.6.0 [February 14, 2013]
|
||||
*
|
||||
* COPYRIGHT: Written by John Cunningham Bowler, 2012.
|
||||
* To the extent possible under law, the author has waived all copyright and
|
||||
* related or neighboring rights to this work. This work is published from:
|
||||
* United States.
|
||||
*
|
||||
* Utility file; not actually a header, this contains definitions of sRGB
|
||||
* calculation functions for inclusion in those test programs that need them.
|
||||
*
|
||||
* All routines take and return a floating point value in the range
|
||||
* 0 to 1.0, doing a calculation according to the sRGB specification
|
||||
* (in fact the source of the numbers is the wikipedia article at
|
||||
* http://en.wikipedia.org/wiki/SRGB).
|
||||
*/
|
||||
static double
|
||||
sRGB_from_linear(double l)
|
||||
{
|
||||
if (l <= 0.0031308)
|
||||
l *= 12.92;
|
||||
|
||||
else
|
||||
l = 1.055 * pow(l, 1/2.4) - 0.055;
|
||||
|
||||
return l;
|
||||
}
|
||||
|
||||
static double
|
||||
linear_from_sRGB(double s)
|
||||
{
|
||||
if (s <= 0.04045)
|
||||
return s / 12.92;
|
||||
|
||||
else
|
||||
return pow((s+0.055)/1.055, 2.4);
|
||||
}
|
||||
|
||||
static double
|
||||
YfromRGB(double r, double g, double b)
|
||||
{
|
||||
/* Use the sRGB (rounded) coefficients for Rlinear, Glinear, Blinear to get
|
||||
* the CIE Y value (also linear).
|
||||
*/
|
||||
return 0.2126 * r + 0.7152 * g + 0.0722 * b;
|
||||
}
|
||||
Reference in New Issue
Block a user