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.19.tar
This commit is contained in:
Glenn Randers-Pehrson
@@ -1,4 +1,12 @@
|
||||
/* Fake a PNG - just write it out directly. */
|
||||
/* Fake a PNG - just write it out directly.
|
||||
*
|
||||
* COPYRIGHT: Written by John Cunningham Bowler, 2014.
|
||||
* 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.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <zlib.h> /* for crc32 */
|
||||
|
||||
|
||||
@@ -1,8 +1,9 @@
|
||||
/* makepng.c
|
||||
*
|
||||
* Copyright (c) 2013 John Cunningham Bowler
|
||||
*
|
||||
* Last changed in libpng 1.6.1 [March 28, 2013]
|
||||
/* makepng.c */
|
||||
#define _ISOC99_SOURCE
|
||||
/* Copyright: */
|
||||
#define COPYRIGHT "\251 2013,2015 John Cunningham Bowler"
|
||||
/*
|
||||
* Last changed in libpng 1.7.0 [(PENDING RELEASE)]
|
||||
*
|
||||
* This code is released under the libpng license.
|
||||
* For conditions of distribution and use, see the disclaimer
|
||||
@@ -10,8 +11,8 @@
|
||||
*
|
||||
* Make a test PNG image. The arguments are as follows:
|
||||
*
|
||||
* makepng [--sRGB|--linear|--1.8] [--color=<color>] color-type bit-depth \
|
||||
* [file-name]
|
||||
* makepng [--sRGB|--linear|--1.8] [--tRNS] [--nofilters] \
|
||||
* color-type bit-depth [file-name]
|
||||
*
|
||||
* The color-type may be numeric (and must match the numbers used by the PNG
|
||||
* specification) or one of the format names listed below. The bit-depth is the
|
||||
@@ -39,8 +40,8 @@
|
||||
* 4 channels: linear combinations of, from the top-left corner clockwise,
|
||||
* transparent, red, green, blue.
|
||||
*
|
||||
* For color-mapped images a four channel color-map is used and the PNG file has
|
||||
* a tRNS chunk, as follows:
|
||||
* For color-mapped images a four channel color-map is used and if --tRNS is
|
||||
* given the PNG file has a tRNS chunk, as follows:
|
||||
*
|
||||
* 1-bit: entry 0 is transparent-red, entry 1 is opaque-white
|
||||
* 2-bit: entry 0: transparent-green
|
||||
@@ -53,6 +54,9 @@
|
||||
* The palette always has 2^bit-depth entries and the tRNS chunk one fewer. The
|
||||
* image is the 1-channel diamond, but using palette index, not luminosity.
|
||||
*
|
||||
* For formats other than color-mapped ones if --tRNS is specified a tRNS chunk
|
||||
* is generated with all channels equal to the low bits of 0x0101.
|
||||
*
|
||||
* Image size is determined by the final pixel depth in bits, i.e. channels x
|
||||
* bit-depth, as follows:
|
||||
*
|
||||
@@ -60,20 +64,64 @@
|
||||
* 16 bits: 256x256
|
||||
* More than 16 bits: 1024x1024
|
||||
*
|
||||
* Row filtering is turned off (the 'none' filter is used on every row) and the
|
||||
* images are not interlaced.
|
||||
* Row filtering is the libpng default but may be turned off (the 'none' filter
|
||||
* is used on every row) with the --nofilters option.
|
||||
*
|
||||
* The images are not interlaced.
|
||||
*
|
||||
* If file-name is given then the PNG is written to that file, else it is
|
||||
* written to stdout. Notice that stdout is not supported on systems where, by
|
||||
* default, it assumes text output; this program makes no attempt to change the
|
||||
* text mode of stdout!
|
||||
*
|
||||
* makepng --color=<color> ...
|
||||
*
|
||||
* If --color is given then the whole image has that color, color-mapped images
|
||||
* will have exactly one palette entry and all image files with be 16x16 in
|
||||
* size. The color value is 1 to 4 decimal numbers as appropriate for the color
|
||||
* type.
|
||||
*
|
||||
* If file-name is given then the PNG is written to that file, else it is
|
||||
* written to stdout. Notice that stdout is not supported on systems where, by
|
||||
* default, it assumes text output; this program makes no attempt to change the
|
||||
* text mode of stdout!
|
||||
* makepng --small ...
|
||||
*
|
||||
* If --small is given the images are no larger than required to include every
|
||||
* possible pixel value for the format.
|
||||
*
|
||||
* For formats with pixels 8 bits or fewer in size the images consist of a
|
||||
* single row with 2^pixel-depth pixels, one of every possible value.
|
||||
*
|
||||
* For formats with 16-bit pixels a 256x256 image is generated containing every
|
||||
* possible pixel value.
|
||||
*
|
||||
* For larger pixel sizes a 256x256 image is generated where the first row
|
||||
* consists of each pixel that has identical byte values throughout the pixel
|
||||
* followed by rows where the byte values differ within the pixel.
|
||||
*
|
||||
* In all cases the pixel values are arranged in such a way that the SUB and UP
|
||||
* filters give byte sequences for maximal zlib compression. By default (if
|
||||
* --nofilters is not given) the SUB filter is used on the first row and the UP
|
||||
* filter on all following rows.
|
||||
*
|
||||
* The --small option is meant to provide good test-case coverage, however the
|
||||
* images are not easy to examine visually. Without the --small option the
|
||||
* images contain identical color values; the pixel values are adjusted
|
||||
* according to the gamma encoding with no gamma encoding being interpreted as
|
||||
* sRGB.
|
||||
*
|
||||
* LICENSING
|
||||
* =========
|
||||
*
|
||||
* This code is copyright of the authors, see the COPYRIGHT define above. The
|
||||
* code is licensed as above, using the libpng license. The code generates
|
||||
* images which are solely the product of the code; the options choose which of
|
||||
* the many possibilities to generate. The images that result (but not the code
|
||||
* which generates them) are licensed as defined here:
|
||||
*
|
||||
* IMPORTANT: the COPYRIGHT #define must contain ISO-Latin-1 characters, the
|
||||
* IMAGE_LICENSING #define must contain UTF-8 characters. The 'copyright'
|
||||
* symbol 0xA9U (\251) in ISO-Latin-1 encoding and 0xC20xA9 (\302\251) in UTF-8.
|
||||
*/
|
||||
#define _ISOC99_SOURCE /* for strtoull */
|
||||
#define IMAGE_LICENSING "Dedicated to the public domain per Creative Commons "\
|
||||
"license \"CC0 1.0\"; https://creativecommons.org/publicdomain/zero/1.0/"
|
||||
|
||||
#include <stddef.h> /* for offsetof */
|
||||
#include <stdlib.h>
|
||||
@@ -82,6 +130,8 @@
|
||||
#include <ctype.h>
|
||||
#include <math.h>
|
||||
#include <errno.h>
|
||||
#include <assert.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
|
||||
# include <config.h>
|
||||
@@ -96,6 +146,25 @@
|
||||
# include "../../png.h"
|
||||
#endif
|
||||
|
||||
#include <zlib.h>
|
||||
|
||||
/* Work round for GCC complaints about casting a (double) function result to
|
||||
* an unsigned:
|
||||
*/
|
||||
static unsigned int
|
||||
flooru(double d)
|
||||
{
|
||||
d = floor(d);
|
||||
return (unsigned int)d;
|
||||
}
|
||||
|
||||
static png_byte
|
||||
floorb(double d)
|
||||
{
|
||||
d = floor(d);
|
||||
return (png_byte)d;
|
||||
}
|
||||
|
||||
/* This structure is used for inserting extra chunks (the --insert argument, not
|
||||
* documented above.)
|
||||
*/
|
||||
@@ -107,7 +176,7 @@ typedef struct chunk_insert
|
||||
png_charp parameters[1];
|
||||
} chunk_insert;
|
||||
|
||||
static int
|
||||
static unsigned int
|
||||
channels_of_type(int color_type)
|
||||
{
|
||||
if (color_type & PNG_COLOR_MASK_PALETTE)
|
||||
@@ -128,14 +197,15 @@ channels_of_type(int color_type)
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
static unsigned int
|
||||
pixel_depth_of_type(int color_type, int bit_depth)
|
||||
{
|
||||
return channels_of_type(color_type) * bit_depth;
|
||||
}
|
||||
|
||||
static unsigned int
|
||||
image_size_of_type(int color_type, int bit_depth, unsigned int *colors)
|
||||
image_size_of_type(int color_type, int bit_depth, unsigned int *colors,
|
||||
int small)
|
||||
{
|
||||
if (*colors)
|
||||
return 16;
|
||||
@@ -144,7 +214,16 @@ image_size_of_type(int color_type, int bit_depth, unsigned int *colors)
|
||||
{
|
||||
int pixel_depth = pixel_depth_of_type(color_type, bit_depth);
|
||||
|
||||
if (pixel_depth < 8)
|
||||
if (small)
|
||||
{
|
||||
if (pixel_depth <= 8) /* there will be one row */
|
||||
return 1 << pixel_depth;
|
||||
|
||||
else
|
||||
return 256;
|
||||
}
|
||||
|
||||
else if (pixel_depth < 8)
|
||||
return 64;
|
||||
|
||||
else if (pixel_depth > 16)
|
||||
@@ -217,7 +296,8 @@ generate_palette(png_colorp palette, png_bytep trans, int bit_depth,
|
||||
else
|
||||
{
|
||||
unsigned int size = 1U << (bit_depth/2); /* 2, 4 or 16 */
|
||||
unsigned int x, y, ip;
|
||||
unsigned int x, y;
|
||||
volatile unsigned int ip = 0;
|
||||
|
||||
for (x=0; x<size; ++x) for (y=0; y<size; ++y)
|
||||
{
|
||||
@@ -281,7 +361,7 @@ set_value(png_bytep row, size_t rowbytes, png_uint_32 x, unsigned int bit_depth,
|
||||
exit(1);
|
||||
|
||||
case 16:
|
||||
value = (unsigned int)floor(65535*pow(value/65535.,conv)+.5);
|
||||
value = flooru(65535*pow(value/65535.,conv)+.5);
|
||||
*row++ = (png_byte)(value >> 8);
|
||||
*row = (png_byte)value;
|
||||
return;
|
||||
@@ -306,15 +386,148 @@ set_value(png_bytep row, size_t rowbytes, png_uint_32 x, unsigned int bit_depth,
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
static int /* filter mask for row */
|
||||
generate_row(png_bytep row, size_t rowbytes, unsigned int y, int color_type,
|
||||
int bit_depth, png_const_bytep gamma_table, double conv,
|
||||
unsigned int *colors)
|
||||
unsigned int *colors, int small)
|
||||
{
|
||||
png_uint_32 size_max = image_size_of_type(color_type, bit_depth, colors)-1;
|
||||
int filters = 0; /* file *MASK*, 0 means the default, not NONE */
|
||||
png_uint_32 size_max =
|
||||
image_size_of_type(color_type, bit_depth, colors, small)-1;
|
||||
png_uint_32 depth_max = (1U << bit_depth)-1; /* up to 65536 */
|
||||
|
||||
if (colors[0] == 0) switch (channels_of_type(color_type))
|
||||
if (colors[0] == 0) if (small)
|
||||
{
|
||||
unsigned int pixel_depth = pixel_depth_of_type(color_type, bit_depth);
|
||||
|
||||
/* For pixel depths less than 16 generate a single row containing all the
|
||||
* possible pixel values. For 16 generate all 65536 byte pair
|
||||
* combinations in a 256x256 pixel array.
|
||||
*/
|
||||
switch (pixel_depth)
|
||||
{
|
||||
case 1:
|
||||
assert(y == 0 && rowbytes == 1 && size_max == 1);
|
||||
row[0] = 0x6CU; /* binary: 01101100, only top 2 bits used */
|
||||
filters = PNG_FILTER_NONE;
|
||||
break;
|
||||
|
||||
case 2:
|
||||
assert(y == 0 && rowbytes == 1 && size_max == 3);
|
||||
row[0] = 0x1BU; /* binary 00011011, all bits used */
|
||||
filters = PNG_FILTER_NONE;
|
||||
break;
|
||||
|
||||
case 4:
|
||||
assert(y == 0 && rowbytes == 8 && size_max == 15);
|
||||
row[0] = 0x01U;
|
||||
row[1] = 0x23U; /* SUB gives 0x22U for all following bytes */
|
||||
row[2] = 0x45U;
|
||||
row[3] = 0x67U;
|
||||
row[4] = 0x89U;
|
||||
row[5] = 0xABU;
|
||||
row[6] = 0xCDU;
|
||||
row[7] = 0xEFU;
|
||||
filters = PNG_FILTER_SUB;
|
||||
break;
|
||||
|
||||
case 8:
|
||||
/* The row will have all the pixel values in order starting with
|
||||
* '1', the SUB filter will change every byte into '1' (including
|
||||
* the last, which generates pixel value '0'). Since the SUB filter
|
||||
* has value 1 this should result in maximum compression.
|
||||
*/
|
||||
assert(y == 0 && rowbytes == 256 && size_max == 255);
|
||||
for (;;)
|
||||
{
|
||||
row[size_max] = 0xFFU & (size_max+1);
|
||||
if (size_max == 0)
|
||||
break;
|
||||
--size_max;
|
||||
}
|
||||
filters = PNG_FILTER_SUB;
|
||||
break;
|
||||
|
||||
case 16:
|
||||
/* Rows are generated such that each row has a constant difference
|
||||
* between the first and second byte of each pixel and so that the
|
||||
* difference increases by 1 at each row. The rows start with the
|
||||
* first byte value of 0 and the value increases to 255 across the
|
||||
* row.
|
||||
*
|
||||
* The difference starts at 1, so the first row is:
|
||||
*
|
||||
* 0 1 1 2 2 3 3 4 ... 254 255 255 0
|
||||
*
|
||||
* This means that running the SUB filter on the first row produces:
|
||||
*
|
||||
* [SUB==1] 0 1 0 1 0 1...
|
||||
*
|
||||
* Then the difference is 2 on the next row, giving:
|
||||
*
|
||||
* 0 2 1 3 2 4 3 5 ... 254 0 255 1
|
||||
*
|
||||
* When the UP filter is run on this libpng produces:
|
||||
*
|
||||
* [UP ==2] 0 1 0 1 0 1...
|
||||
*
|
||||
* And so on for all the remain rows to the final two * rows:
|
||||
*
|
||||
* row 254: 0 255 1 0 2 1 3 2 4 3 ... 254 253 255 254
|
||||
* row 255: 0 0 1 1 2 2 3 3 4 4 ... 254 254 255 255
|
||||
*/
|
||||
assert(rowbytes == 512 && size_max == 255);
|
||||
for (;;)
|
||||
{
|
||||
row[2*size_max ] = 0xFFU & size_max;
|
||||
row[2*size_max+1] = 0xFFU & (size_max+y+1);
|
||||
if (size_max == 0)
|
||||
break;
|
||||
--size_max;
|
||||
}
|
||||
/* The first row must include PNG_FILTER_UP so that libpng knows we
|
||||
* need to keep it for the following row:
|
||||
*/
|
||||
filters = (y == 0 ? PNG_FILTER_SUB+PNG_FILTER_UP : PNG_FILTER_UP);
|
||||
break;
|
||||
|
||||
case 24:
|
||||
case 32:
|
||||
case 48:
|
||||
case 64:
|
||||
/* The rows are filled by an alogorithm similar to the above, in the
|
||||
* first row pixel bytes are all equal, increasing from 0 by 1 for
|
||||
* each pixel. In the second row the bytes within a pixel are
|
||||
* incremented 1,3,5,7,... from the previous row byte. Using an odd
|
||||
* number ensures all the possible byte values are used.
|
||||
*/
|
||||
assert(size_max == 255 && rowbytes == 256*(pixel_depth>>3));
|
||||
pixel_depth >>= 3; /* now in bytes */
|
||||
while (rowbytes > 0)
|
||||
{
|
||||
const size_t pixel_index = --rowbytes/pixel_depth;
|
||||
|
||||
if (y == 0)
|
||||
row[rowbytes] = 0xFFU & pixel_index;
|
||||
|
||||
else
|
||||
{
|
||||
const size_t byte_offset =
|
||||
rowbytes - pixel_index * pixel_depth;
|
||||
|
||||
row[rowbytes] =
|
||||
0xFFU & (pixel_index + (byte_offset * 2*y) + 1);
|
||||
}
|
||||
}
|
||||
filters = (y == 0 ? PNG_FILTER_SUB+PNG_FILTER_UP : PNG_FILTER_UP);
|
||||
break;
|
||||
|
||||
default:
|
||||
assert(0/*NOT REACHED*/);
|
||||
}
|
||||
}
|
||||
|
||||
else switch (channels_of_type(color_type))
|
||||
{
|
||||
/* 1 channel: a square image with a diamond, the least luminous colors are on
|
||||
* the edge of the image, the most luminous in the center.
|
||||
@@ -526,6 +739,8 @@ generate_row(png_bytep row, size_t rowbytes, unsigned int y, int color_type,
|
||||
colors[0], channels_of_type(color_type));
|
||||
exit(1);
|
||||
}
|
||||
|
||||
return filters;
|
||||
}
|
||||
|
||||
|
||||
@@ -554,7 +769,7 @@ makepng_error(png_structp png_ptr, png_const_charp message)
|
||||
static int /* 0 on success, else an error code */
|
||||
write_png(const char **name, FILE *fp, int color_type, int bit_depth,
|
||||
volatile png_fixed_point gamma, chunk_insert * volatile insert,
|
||||
unsigned int filters, unsigned int *colors)
|
||||
unsigned int filters, unsigned int *colors, int small, int tRNS)
|
||||
{
|
||||
png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
|
||||
name, makepng_error, makepng_warning);
|
||||
@@ -581,6 +796,15 @@ write_png(const char **name, FILE *fp, int color_type, int bit_depth,
|
||||
|
||||
/* Allow benign errors so that we can write PNGs with errors */
|
||||
png_set_benign_errors(png_ptr, 1/*allowed*/);
|
||||
|
||||
/* Max out the text compression level in an attempt to make the license
|
||||
* small. If --small then do the same for the IDAT.
|
||||
*/
|
||||
if (small)
|
||||
png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);
|
||||
|
||||
png_set_text_compression_level(png_ptr, Z_BEST_COMPRESSION);
|
||||
|
||||
png_init_io(png_ptr, fp);
|
||||
|
||||
info_ptr = png_create_info_struct(png_ptr);
|
||||
@@ -588,11 +812,37 @@ write_png(const char **name, FILE *fp, int color_type, int bit_depth,
|
||||
png_error(png_ptr, "OOM allocating info structure");
|
||||
|
||||
{
|
||||
unsigned int size = image_size_of_type(color_type, bit_depth, colors);
|
||||
const unsigned int size =
|
||||
image_size_of_type(color_type, bit_depth, colors, small);
|
||||
unsigned int ysize;
|
||||
png_fixed_point real_gamma = 45455; /* For sRGB */
|
||||
png_byte gamma_table[256];
|
||||
double conv;
|
||||
|
||||
/* Normally images are square, but with 'small' we want to simply generate
|
||||
* all the pixel values, or all that we reasonably can:
|
||||
*/
|
||||
if (small)
|
||||
{
|
||||
const unsigned int pixel_depth =
|
||||
pixel_depth_of_type(color_type, bit_depth);
|
||||
|
||||
if (pixel_depth <= 8U)
|
||||
{
|
||||
assert(size == (1U<<pixel_depth));
|
||||
ysize = 1U;
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
assert(size == 256U);
|
||||
ysize = 256U;
|
||||
}
|
||||
}
|
||||
|
||||
else
|
||||
ysize = size;
|
||||
|
||||
/* This function uses the libpng values used on read to carry extra
|
||||
* information about the gamma:
|
||||
*/
|
||||
@@ -625,13 +875,13 @@ write_png(const char **name, FILE *fp, int color_type, int bit_depth,
|
||||
gamma_table[0] = 0;
|
||||
|
||||
for (i=1; i<255; ++i)
|
||||
gamma_table[i] = (png_byte)floor(pow(i/255.,conv) * 255 + .5);
|
||||
gamma_table[i] = floorb(pow(i/255.,conv) * 255 + .5);
|
||||
|
||||
gamma_table[255] = 255;
|
||||
}
|
||||
}
|
||||
|
||||
png_set_IHDR(png_ptr, info_ptr, size, size, bit_depth, color_type,
|
||||
png_set_IHDR(png_ptr, info_ptr, size, ysize, bit_depth, color_type,
|
||||
PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
|
||||
|
||||
if (color_type & PNG_COLOR_MASK_PALETTE)
|
||||
@@ -643,14 +893,26 @@ write_png(const char **name, FILE *fp, int color_type, int bit_depth,
|
||||
npalette = generate_palette(palette, trans, bit_depth, gamma_table,
|
||||
colors);
|
||||
png_set_PLTE(png_ptr, info_ptr, palette, npalette);
|
||||
png_set_tRNS(png_ptr, info_ptr, trans, npalette-1,
|
||||
NULL/*transparent color*/);
|
||||
|
||||
if (tRNS)
|
||||
png_set_tRNS(png_ptr, info_ptr, trans, npalette-1,
|
||||
NULL/*transparent color*/);
|
||||
|
||||
/* Reset gamma_table to prevent the image rows being changed */
|
||||
for (npalette=0; npalette<256; ++npalette)
|
||||
gamma_table[npalette] = (png_byte)npalette;
|
||||
}
|
||||
|
||||
else if (tRNS)
|
||||
{
|
||||
png_color_16 col;
|
||||
|
||||
col.red = col.green = col.blue = col.gray =
|
||||
0x0101U & ((1U<<bit_depth)-1U);
|
||||
col.index = 0U;
|
||||
png_set_tRNS(png_ptr, info_ptr, NULL/*trans*/, 1U, &col);
|
||||
}
|
||||
|
||||
if (gamma == PNG_DEFAULT_sRGB)
|
||||
png_set_sRGB(png_ptr, info_ptr, PNG_sRGB_INTENT_ABSOLUTE);
|
||||
|
||||
@@ -682,7 +944,11 @@ write_png(const char **name, FILE *fp, int color_type, int bit_depth,
|
||||
png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, filters);
|
||||
|
||||
{
|
||||
int passes = png_set_interlace_handling(png_ptr);
|
||||
# ifdef PNG_WRITE_INTERLACING_SUPPORTED
|
||||
int passes = png_set_interlace_handling(png_ptr);
|
||||
# else /* !WRITE_INTERLACING */
|
||||
int passes = 1;
|
||||
# endif /* !WRITE_INTERLACING */
|
||||
int pass;
|
||||
png_size_t rowbytes = png_get_rowbytes(png_ptr, info_ptr);
|
||||
|
||||
@@ -695,10 +961,15 @@ write_png(const char **name, FILE *fp, int color_type, int bit_depth,
|
||||
{
|
||||
unsigned int y;
|
||||
|
||||
for (y=0; y<size; ++y)
|
||||
for (y=0; y<ysize; ++y)
|
||||
{
|
||||
generate_row(row, rowbytes, y, color_type, bit_depth,
|
||||
gamma_table, conv, colors);
|
||||
unsigned int row_filters =
|
||||
generate_row(row, rowbytes, y, color_type, bit_depth,
|
||||
gamma_table, conv, colors, small);
|
||||
|
||||
if (row_filters != 0 && filters == PNG_ALL_FILTERS)
|
||||
png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, row_filters);
|
||||
|
||||
png_write_row(png_ptr, row);
|
||||
}
|
||||
}
|
||||
@@ -827,7 +1098,7 @@ static png_size_t
|
||||
load_fake(png_charp param, png_bytepp profile)
|
||||
{
|
||||
char *endptr = NULL;
|
||||
unsigned long long int size = strtoull(param, &endptr, 0/*base*/);
|
||||
uint64_t size = strtoull(param, &endptr, 0/*base*/);
|
||||
|
||||
/* The 'fake' format is <number>*[string] */
|
||||
if (endptr != NULL && *endptr == '*')
|
||||
@@ -1062,7 +1333,8 @@ insert_iTXt(png_structp png_ptr, png_infop info_ptr, int nparams,
|
||||
}
|
||||
|
||||
static void
|
||||
insert_hIST(png_structp png_ptr, png_infop info_ptr, int nparams, png_charpp params)
|
||||
insert_hIST(png_structp png_ptr, png_infop info_ptr, int nparams,
|
||||
png_charpp params)
|
||||
{
|
||||
int i;
|
||||
png_uint_16 freq[256];
|
||||
@@ -1231,6 +1503,80 @@ find_insert(png_const_charp what, png_charp param)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* This is necessary because libpng expects writeable strings for things like
|
||||
* text chunks (maybe this should be fixed...)
|
||||
*/
|
||||
static png_charp
|
||||
strstash(png_const_charp foo)
|
||||
{
|
||||
/* The program indicates a memory allocation error by crashing, this is by
|
||||
* design.
|
||||
*/
|
||||
if (foo != NULL)
|
||||
{
|
||||
png_charp bar = malloc(strlen(foo)+1);
|
||||
return strcpy(bar, foo);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static png_charp
|
||||
strstash_list(const png_const_charp *text)
|
||||
{
|
||||
size_t foo = 0;
|
||||
png_charp result, bar;
|
||||
const png_const_charp *line = text;
|
||||
|
||||
while (*line != NULL)
|
||||
foo += strlen(*line++);
|
||||
|
||||
result = bar = malloc(foo+1);
|
||||
|
||||
line = text;
|
||||
while (*line != NULL)
|
||||
{
|
||||
foo = strlen(*line);
|
||||
memcpy(bar, *line++, foo);
|
||||
bar += foo;
|
||||
}
|
||||
|
||||
*bar = 0;
|
||||
return result;
|
||||
}
|
||||
|
||||
/* These are used to insert Copyright and Licence fields, they allow the text to
|
||||
* have \n unlike the --insert option.
|
||||
*/
|
||||
static chunk_insert *
|
||||
add_tEXt(const char *key, const png_const_charp *text)
|
||||
{
|
||||
static char what[5] = { 116, 69, 88, 116, 0 };
|
||||
png_charp parameter_list[3];
|
||||
|
||||
parameter_list[0] = strstash(key);
|
||||
parameter_list[1] = strstash_list(text);
|
||||
parameter_list[2] = NULL;
|
||||
|
||||
return make_insert(what, insert_tEXt, 2, parameter_list);
|
||||
}
|
||||
|
||||
static chunk_insert *
|
||||
add_iTXt(const char *key, const char *language, const char *language_key,
|
||||
const png_const_charp *text)
|
||||
{
|
||||
static char what[5] = { 105, 84, 88, 116, 0 };
|
||||
png_charp parameter_list[5];
|
||||
|
||||
parameter_list[0] = strstash(key);
|
||||
parameter_list[1] = strstash(language);
|
||||
parameter_list[2] = strstash(language_key);
|
||||
parameter_list[3] = strstash_list(text);
|
||||
parameter_list[4] = NULL;
|
||||
|
||||
return make_insert(what, insert_iTXt, 4, parameter_list);
|
||||
}
|
||||
|
||||
/* This is a not-very-good parser for a sequence of numbers (including 0). It
|
||||
* doesn't accept some apparently valid things, but it accepts all the sensible
|
||||
* combinations.
|
||||
@@ -1280,6 +1626,8 @@ main(int argc, char **argv)
|
||||
const char *file_name = NULL;
|
||||
int color_type = 8; /* invalid */
|
||||
int bit_depth = 32; /* invalid */
|
||||
int small = 0; /* make full size images */
|
||||
int tRNS = 0; /* don't output a tRNS chunk */
|
||||
unsigned int colors[5];
|
||||
unsigned int filters = PNG_ALL_FILTERS;
|
||||
png_fixed_point gamma = 0; /* not set */
|
||||
@@ -1292,6 +1640,18 @@ main(int argc, char **argv)
|
||||
{
|
||||
char *arg = *++argv;
|
||||
|
||||
if (strcmp(arg, "--small") == 0)
|
||||
{
|
||||
small = 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (strcmp(arg, "--tRNS") == 0)
|
||||
{
|
||||
tRNS = 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (strcmp(arg, "--sRGB") == 0)
|
||||
{
|
||||
gamma = PNG_DEFAULT_sRGB;
|
||||
@@ -1432,9 +1792,10 @@ main(int argc, char **argv)
|
||||
|
||||
if (color_type == 8 || bit_depth == 32)
|
||||
{
|
||||
fprintf(stderr, "usage: makepng [--sRGB|--linear|--1.8] "
|
||||
fprintf(stderr, "usage: makepng [--small] [--sRGB|--linear|--1.8] "
|
||||
"[--color=...] color-type bit-depth [file-name]\n"
|
||||
" Make a test PNG file, by default writes to stdout.\n");
|
||||
" Make a test PNG file, by default writes to stdout.\n"
|
||||
" Other options are available, UTSL.\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
@@ -1453,10 +1814,19 @@ main(int argc, char **argv)
|
||||
}
|
||||
}
|
||||
|
||||
/* small and colors are incomparible (will probably crash if both are used at
|
||||
* the same time!)
|
||||
*/
|
||||
if (small && colors[0] != 0)
|
||||
{
|
||||
fprintf(stderr, "makepng: --color --small: only one at a time!\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
/* Restrict the filters for more speed to those we know are used for the
|
||||
* generated images.
|
||||
*/
|
||||
if (filters == PNG_ALL_FILTERS)
|
||||
if (filters == PNG_ALL_FILTERS && !small/*small provides defaults*/)
|
||||
{
|
||||
if ((color_type & PNG_COLOR_MASK_PALETTE) != 0 || bit_depth < 8)
|
||||
filters = PNG_FILTER_NONE;
|
||||
@@ -1474,9 +1844,39 @@ main(int argc, char **argv)
|
||||
filters &= ~PNG_FILTER_NONE;
|
||||
}
|
||||
|
||||
/* Insert standard copyright and licence text. */
|
||||
{
|
||||
static png_const_charp copyright[] =
|
||||
{
|
||||
COPYRIGHT, /* ISO-Latin-1 */
|
||||
NULL
|
||||
};
|
||||
static png_const_charp licensing[] =
|
||||
{
|
||||
IMAGE_LICENSING, /* UTF-8 */
|
||||
NULL
|
||||
};
|
||||
|
||||
chunk_insert *new_insert;
|
||||
|
||||
new_insert = add_tEXt("Copyright", copyright);
|
||||
if (new_insert != NULL)
|
||||
{
|
||||
*insert_ptr = new_insert;
|
||||
insert_ptr = &new_insert->next;
|
||||
}
|
||||
|
||||
new_insert = add_iTXt("Licensing", "en", NULL, licensing);
|
||||
if (new_insert != NULL)
|
||||
{
|
||||
*insert_ptr = new_insert;
|
||||
insert_ptr = &new_insert->next;
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
int ret = write_png(&file_name, fp, color_type, bit_depth, gamma,
|
||||
head_insert, filters, colors);
|
||||
head_insert, filters, colors, small, tRNS);
|
||||
|
||||
if (ret != 0 && file_name != NULL)
|
||||
remove(file_name);
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
*
|
||||
* Copyright (c) 2015 John Cunningham Bowler
|
||||
*
|
||||
* Last changed in libpng 1.6.18 [July 23, 2015]
|
||||
* Last changed in libpng 1.6.19 [November 12, 2015]
|
||||
*
|
||||
* This code is released under the libpng license.
|
||||
* For conditions of distribution and use, see the disclaimer
|
||||
@@ -236,10 +236,12 @@ static struct transform_info
|
||||
*/
|
||||
#endif
|
||||
#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
|
||||
T(SCALE_16, NONE, X, X, 16, R)
|
||||
T(SCALE_16, NONE, X, X, 16, R),
|
||||
/* scales 16-bit components to 8-bits. */
|
||||
#endif
|
||||
|
||||
{ NULL /*name*/, 0, 0, 0, 0, 0, 0, 0/*!tested*/ }
|
||||
|
||||
#undef T
|
||||
};
|
||||
|
||||
@@ -294,7 +296,7 @@ transform_name(int t)
|
||||
|
||||
t &= -t; /* first set bit */
|
||||
|
||||
for (i=0; i<TTABLE_SIZE; ++i)
|
||||
for (i=0; i<TTABLE_SIZE; ++i) if (transform_info[i].name != NULL)
|
||||
{
|
||||
if ((transform_info[i].transform & t) != 0)
|
||||
return transform_info[i].name;
|
||||
@@ -315,7 +317,7 @@ validate_T(void)
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
for (i=0; i<TTABLE_SIZE; ++i)
|
||||
for (i=0; i<TTABLE_SIZE; ++i) if (transform_info[i].name != NULL)
|
||||
{
|
||||
if (transform_info[i].when & TRANSFORM_R)
|
||||
read_transforms |= transform_info[i].transform;
|
||||
@@ -505,6 +507,7 @@ typedef enum
|
||||
#define SKIP_BUGS 0x100 /* Skip over known bugs */
|
||||
#define LOG_SKIPPED 0x200 /* Log skipped bugs */
|
||||
#define FIND_BAD_COMBOS 0x400 /* Attempt to deduce bad combos */
|
||||
#define LIST_COMBOS 0x800 /* List combos by name */
|
||||
|
||||
/* Result masks apply to the result bits in the 'results' field below; these
|
||||
* bits are simple 1U<<error_level. A pass requires either nothing worse than
|
||||
@@ -690,7 +693,35 @@ display_log(struct display *dp, error_level level, const char *fmt, ...)
|
||||
int tr = dp->transforms;
|
||||
|
||||
if (is_combo(tr))
|
||||
fprintf(stderr, "(0x%x)", tr);
|
||||
{
|
||||
if (dp->options & LIST_COMBOS)
|
||||
{
|
||||
int trx = tr;
|
||||
|
||||
fprintf(stderr, "(");
|
||||
if (trx)
|
||||
{
|
||||
int start = 0;
|
||||
|
||||
while (trx)
|
||||
{
|
||||
int trz = trx & -trx;
|
||||
|
||||
if (start) fprintf(stderr, "+");
|
||||
fprintf(stderr, "%s", transform_name(trz));
|
||||
start = 1;
|
||||
trx &= ~trz;
|
||||
}
|
||||
}
|
||||
|
||||
else
|
||||
fprintf(stderr, "-");
|
||||
fprintf(stderr, ")");
|
||||
}
|
||||
|
||||
else
|
||||
fprintf(stderr, "(0x%x)", tr);
|
||||
}
|
||||
|
||||
else
|
||||
fprintf(stderr, "(%s)", transform_name(tr));
|
||||
@@ -910,7 +941,7 @@ update_display(struct display *dp)
|
||||
int bd = dp->bit_depth;
|
||||
unsigned int i;
|
||||
|
||||
for (i=0; i<TTABLE_SIZE; ++i)
|
||||
for (i=0; i<TTABLE_SIZE; ++i) if (transform_info[i].name != NULL)
|
||||
{
|
||||
int transform = transform_info[i].transform;
|
||||
|
||||
@@ -935,9 +966,6 @@ update_display(struct display *dp)
|
||||
|
||||
dp->active_transforms = active;
|
||||
dp->ignored_transforms = inactive; /* excluding write-only transforms */
|
||||
|
||||
if (active == 0)
|
||||
display_log(dp, INTERNAL_ERROR, "bad transform table");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1588,6 +1616,12 @@ main(const int argc, const char * const * const argv)
|
||||
else if (strcmp(name, "--nofind-bad-combos") == 0)
|
||||
d.options &= ~FIND_BAD_COMBOS;
|
||||
|
||||
else if (strcmp(name, "--list-combos") == 0)
|
||||
d.options |= LIST_COMBOS;
|
||||
|
||||
else if (strcmp(name, "--nolist-combos") == 0)
|
||||
d.options &= ~LIST_COMBOS;
|
||||
|
||||
else if (name[0] == '-' && name[1] == '-')
|
||||
{
|
||||
fprintf(stderr, "pngimage: %s: unknown option\n", name);
|
||||
|
||||
165
contrib/libtests/pngstest-errors.h
Normal file
165
contrib/libtests/pngstest-errors.h
Normal file
@@ -0,0 +1,165 @@
|
||||
/* contrib/libtests/pngstest-errors.h
|
||||
*
|
||||
* BUILT USING: libpng version 1.6.19beta03 - September 25, 2015
|
||||
*
|
||||
* This code is released under the libpng license.
|
||||
* For conditions of distribution and use, see the disclaimer
|
||||
* and license in png.h
|
||||
*
|
||||
* THIS IS A MACHINE GENERATED FILE: do not edit it directly!
|
||||
* Instead run:
|
||||
*
|
||||
* pngstest --accumulate
|
||||
*
|
||||
* on as many PNG files as possible; at least PNGSuite and
|
||||
* contrib/libtests/testpngs.
|
||||
*/
|
||||
static png_uint_16 gpc_error[16/*in*/][16/*out*/][4/*a*/] =
|
||||
{
|
||||
{ /* input: sRGB-gray */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 372, 0 }, { 0, 0, 372, 0 }, { 0, 0, 372, 0 }, { 0, 0, 372, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: sRGB-gray+alpha */
|
||||
{ 0, 19, 0, 0 }, { 0, 0, 0, 0 }, { 0, 20, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 897, 788, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: sRGB-rgb */
|
||||
{ 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 893, 0 }, { 0, 0, 893, 0 }, { 0, 0, 811, 0 }, { 0, 0, 811, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: sRGB-rgb+alpha */
|
||||
{ 0, 16, 17, 0 }, { 0, 17, 17, 0 }, { 0, 19, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 850, 875, 0 }, { 0, 850, 875, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: linear-gray */
|
||||
{ 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: linear-gray+alpha */
|
||||
{ 0, 74, 9, 0 }, { 0, 20, 9, 0 }, { 0, 74, 9, 0 }, { 0, 20, 9, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 }, { 0, 1, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: linear-rgb */
|
||||
{ 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
|
||||
{ 0, 0, 4, 0 }, { 0, 0, 4, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: linear-rgb+alpha */
|
||||
{ 0, 126, 143, 0 }, { 0, 11, 7, 0 }, { 0, 74, 9, 0 }, { 0, 17, 9, 0 },
|
||||
{ 0, 4, 4, 0 }, { 0, 5, 4, 0 }, { 0, 0, 0, 0 }, { 0, 1, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-sRGB-gray */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-sRGB-gray+alpha */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-sRGB-rgb */
|
||||
{ 0, 0, 13, 0 }, { 0, 0, 13, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
|
||||
{ 0, 0, 673, 0 }, { 0, 0, 673, 0 }, { 0, 0, 674, 0 }, { 0, 0, 674, 0 },
|
||||
{ 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 460, 0 }, { 0, 0, 460, 0 }, { 0, 0, 263, 0 }, { 0, 0, 263, 0 }
|
||||
}, { /* input: color-mapped-sRGB-rgb+alpha */
|
||||
{ 0, 6, 8, 0 }, { 0, 7, 8, 0 }, { 0, 75, 9, 0 }, { 0, 9, 9, 0 },
|
||||
{ 0, 585, 427, 0 }, { 0, 585, 427, 0 }, { 0, 717, 514, 0 }, { 0, 717, 514, 0 },
|
||||
{ 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 13323, 460, 0 }, { 0, 427, 460, 0 }, { 0, 16480, 263, 0 }, { 0, 243, 263, 0 }
|
||||
}, { /* input: color-mapped-linear-gray */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 282, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-linear-gray+alpha */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 253, 282, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-linear-rgb */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 265, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-linear-rgb+alpha */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 243, 265, 0 }
|
||||
}
|
||||
};
|
||||
static png_uint_16 gpc_error_via_linear[16][4/*out*/][4] =
|
||||
{
|
||||
{ /* input: sRGB-gray */
|
||||
{ 0, 0, 7, 0 }, { 0, 0, 7, 0 }, { 0, 0, 7, 0 }, { 0, 0, 7, 0 }
|
||||
}, { /* input: sRGB-gray+alpha */
|
||||
{ 0, 15, 15, 0 }, { 0, 186, 15, 0 }, { 0, 15, 15, 0 }, { 0, 186, 15, 0 }
|
||||
}, { /* input: sRGB-rgb */
|
||||
{ 0, 0, 20, 0 }, { 0, 0, 20, 0 }, { 0, 0, 15, 0 }, { 0, 0, 15, 0 }
|
||||
}, { /* input: sRGB-rgb+alpha */
|
||||
{ 0, 16, 17, 0 }, { 0, 187, 17, 0 }, { 0, 15, 15, 0 }, { 0, 186, 15, 0 }
|
||||
}, { /* input: linear-gray */
|
||||
{ 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }
|
||||
}, { /* input: linear-gray+alpha */
|
||||
{ 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }
|
||||
}, { /* input: linear-rgb */
|
||||
{ 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }
|
||||
}, { /* input: linear-rgb+alpha */
|
||||
{ 0, 1, 1, 0 }, { 0, 9, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }
|
||||
}, { /* input: color-mapped-sRGB-gray */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-sRGB-gray+alpha */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-sRGB-rgb */
|
||||
{ 0, 0, 13, 0 }, { 0, 0, 13, 0 }, { 0, 0, 14, 0 }, { 0, 0, 14, 0 }
|
||||
}, { /* input: color-mapped-sRGB-rgb+alpha */
|
||||
{ 0, 4, 8, 0 }, { 0, 9, 8, 0 }, { 0, 9, 5, 0 }, { 0, 32, 5, 0 }
|
||||
}, { /* input: color-mapped-linear-gray */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-linear-gray+alpha */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-linear-rgb */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-linear-rgb+alpha */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}
|
||||
};
|
||||
static png_uint_16 gpc_error_to_colormap[8/*i*/][8/*o*/][4] =
|
||||
{
|
||||
{ /* input: sRGB-gray */
|
||||
{ 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
|
||||
{ 0, 0, 560, 0 }, { 0, 0, 560, 0 }, { 0, 0, 560, 0 }, { 0, 0, 560, 0 }
|
||||
}, { /* input: sRGB-gray+alpha */
|
||||
{ 0, 19, 9, 0 }, { 0, 255, 9, 25 }, { 0, 88, 9, 0 }, { 0, 255, 9, 25 },
|
||||
{ 0, 1012, 928, 0 }, { 0, 16026, 928, 6425 }, { 0, 1012, 928, 0 }, { 0, 16026, 928, 6425 }
|
||||
}, { /* input: sRGB-rgb */
|
||||
{ 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 25, 0 }, { 0, 0, 25, 0 },
|
||||
{ 0, 0, 962, 0 }, { 0, 0, 962, 0 }, { 0, 0, 13677, 0 }, { 0, 0, 13677, 0 }
|
||||
}, { /* input: sRGB-rgb+alpha */
|
||||
{ 0, 63, 77, 0 }, { 0, 255, 19, 25 }, { 0, 225, 25, 0 }, { 0, 255, 25, 67 },
|
||||
{ 0, 17534, 18491, 0 }, { 0, 15736, 2824, 6425 }, { 0, 14019, 13677, 0 }, { 0, 50115, 13677, 17219 }
|
||||
}, { /* input: linear-gray */
|
||||
{ 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 73, 0 },
|
||||
{ 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }
|
||||
}, { /* input: linear-gray+alpha */
|
||||
{ 0, 74, 74, 0 }, { 0, 255, 74, 25 }, { 0, 99, 74, 0 }, { 0, 255, 74, 25 },
|
||||
{ 0, 18919, 18907, 0 }, { 0, 24549, 18907, 6553 }, { 0, 18919, 18907, 0 }, { 0, 24549, 18907, 6553 }
|
||||
}, { /* input: linear-rgb */
|
||||
{ 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 98, 0 }, { 0, 0, 98, 0 },
|
||||
{ 0, 0, 18664, 0 }, { 0, 0, 18664, 0 }, { 0, 0, 24998, 0 }, { 0, 0, 24998, 0 }
|
||||
}, { /* input: linear-rgb+alpha */
|
||||
{ 0, 181, 196, 0 }, { 0, 255, 61, 25 }, { 206, 187, 98, 0 }, { 0, 255, 98, 67 },
|
||||
{ 0, 18141, 18137, 0 }, { 0, 17494, 17504, 6553 }, { 0, 24979, 24992, 0 }, { 0, 49172, 24992, 17347 }
|
||||
}
|
||||
};
|
||||
/* END MACHINE GENERATED */
|
||||
@@ -3,7 +3,7 @@
|
||||
*
|
||||
* Copyright (c) 2013-2015 John Cunningham Bowler
|
||||
*
|
||||
* Last changed in libpng 1.6.18 [July 23, 2015]
|
||||
* Last changed in libpng 1.6.19 [(PENDING RELEASE)]
|
||||
*
|
||||
* This code is released under the libpng license.
|
||||
* For conditions of distribution and use, see the disclaimer
|
||||
@@ -1984,156 +1984,7 @@ static void (* const gpc_fn_colormapped[8/*in*/][8/*out*/])
|
||||
* gpc_error_to_colormap.
|
||||
*/
|
||||
#if PNG_FORMAT_FLAG_COLORMAP == 8 /* extra check also required */
|
||||
/* START MACHINE GENERATED */
|
||||
static png_uint_16 gpc_error[16/*in*/][16/*out*/][4/*a*/] =
|
||||
{
|
||||
{ /* input: sRGB-gray */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 372, 0 }, { 0, 0, 372, 0 }, { 0, 0, 372, 0 }, { 0, 0, 372, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: sRGB-gray+alpha */
|
||||
{ 0, 18, 0, 0 }, { 0, 0, 0, 0 }, { 0, 20, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 897, 788, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: sRGB-rgb */
|
||||
{ 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 893, 0 }, { 0, 0, 893, 0 }, { 0, 0, 811, 0 }, { 0, 0, 811, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: sRGB-rgb+alpha */
|
||||
{ 0, 4, 13, 0 }, { 0, 14, 13, 0 }, { 0, 19, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 832, 764, 0 }, { 0, 832, 764, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: linear-gray */
|
||||
{ 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: linear-gray+alpha */
|
||||
{ 0, 74, 9, 0 }, { 0, 20, 9, 0 }, { 0, 74, 9, 0 }, { 0, 20, 9, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 }, { 0, 1, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: linear-rgb */
|
||||
{ 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
|
||||
{ 0, 0, 4, 0 }, { 0, 0, 4, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: linear-rgb+alpha */
|
||||
{ 0, 126, 143, 0 }, { 0, 9, 7, 0 }, { 0, 74, 9, 0 }, { 0, 16, 9, 0 },
|
||||
{ 0, 4, 4, 0 }, { 0, 5, 4, 0 }, { 0, 0, 0, 0 }, { 0, 1, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-sRGB-gray */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-sRGB-gray+alpha */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-sRGB-rgb */
|
||||
{ 0, 0, 13, 0 }, { 0, 0, 13, 0 }, { 0, 0, 8, 0 }, { 0, 0, 8, 0 },
|
||||
{ 0, 0, 673, 0 }, { 0, 0, 673, 0 }, { 0, 0, 674, 0 }, { 0, 0, 674, 0 },
|
||||
{ 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 460, 0 }, { 0, 0, 460, 0 }, { 0, 0, 263, 0 }, { 0, 0, 263, 0 }
|
||||
}, { /* input: color-mapped-sRGB-rgb+alpha */
|
||||
{ 0, 6, 8, 0 }, { 0, 7, 8, 0 }, { 0, 75, 8, 0 }, { 0, 9, 8, 0 },
|
||||
{ 0, 585, 427, 0 }, { 0, 585, 427, 0 }, { 0, 717, 409, 0 }, { 0, 717, 409, 0 },
|
||||
{ 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 13323, 460, 0 }, { 0, 334, 460, 0 }, { 0, 16480, 263, 0 }, { 0, 243, 263, 0 }
|
||||
}, { /* input: color-mapped-linear-gray */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 282, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-linear-gray+alpha */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 253, 282, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-linear-rgb */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 265, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-linear-rgb+alpha */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 243, 265, 0 }
|
||||
}
|
||||
};
|
||||
static png_uint_16 gpc_error_via_linear[16][4/*out*/][4] =
|
||||
{
|
||||
{ /* input: sRGB-gray */
|
||||
{ 0, 0, 7, 0 }, { 0, 0, 7, 0 }, { 0, 0, 7, 0 }, { 0, 0, 7, 0 }
|
||||
}, { /* input: sRGB-gray+alpha */
|
||||
{ 0, 15, 15, 0 }, { 0, 186, 15, 0 }, { 0, 15, 15, 0 }, { 0, 186, 15, 0 }
|
||||
}, { /* input: sRGB-rgb */
|
||||
{ 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 15, 0 }, { 0, 0, 15, 0 }
|
||||
}, { /* input: sRGB-rgb+alpha */
|
||||
{ 0, 12, 14, 0 }, { 0, 180, 14, 0 }, { 0, 14, 15, 0 }, { 0, 186, 15, 0 }
|
||||
}, { /* input: linear-gray */
|
||||
{ 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }
|
||||
}, { /* input: linear-gray+alpha */
|
||||
{ 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }
|
||||
}, { /* input: linear-rgb */
|
||||
{ 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }
|
||||
}, { /* input: linear-rgb+alpha */
|
||||
{ 0, 1, 1, 0 }, { 0, 8, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }
|
||||
}, { /* input: color-mapped-sRGB-gray */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-sRGB-gray+alpha */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-sRGB-rgb */
|
||||
{ 0, 0, 13, 0 }, { 0, 0, 13, 0 }, { 0, 0, 14, 0 }, { 0, 0, 14, 0 }
|
||||
}, { /* input: color-mapped-sRGB-rgb+alpha */
|
||||
{ 0, 4, 8, 0 }, { 0, 9, 8, 0 }, { 0, 8, 3, 0 }, { 0, 32, 3, 0 }
|
||||
}, { /* input: color-mapped-linear-gray */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-linear-gray+alpha */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-linear-rgb */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}, { /* input: color-mapped-linear-rgb+alpha */
|
||||
{ 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
|
||||
}
|
||||
};
|
||||
static png_uint_16 gpc_error_to_colormap[8/*i*/][8/*o*/][4] =
|
||||
{
|
||||
{ /* input: sRGB-gray */
|
||||
{ 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
|
||||
{ 0, 0, 560, 0 }, { 0, 0, 560, 0 }, { 0, 0, 560, 0 }, { 0, 0, 560, 0 }
|
||||
}, { /* input: sRGB-gray+alpha */
|
||||
{ 0, 19, 2, 0 }, { 0, 255, 2, 25 }, { 0, 88, 2, 0 }, { 0, 255, 2, 25 },
|
||||
{ 0, 1012, 745, 0 }, { 0, 16026, 745, 6425 }, { 0, 1012, 745, 0 }, { 0, 16026, 745, 6425 }
|
||||
}, { /* input: sRGB-rgb */
|
||||
{ 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 25, 0 }, { 0, 0, 25, 0 },
|
||||
{ 0, 0, 937, 0 }, { 0, 0, 937, 0 }, { 0, 0, 13677, 0 }, { 0, 0, 13677, 0 }
|
||||
}, { /* input: sRGB-rgb+alpha */
|
||||
{ 0, 63, 77, 0 }, { 0, 255, 19, 25 }, { 0, 220, 25, 0 }, { 0, 255, 25, 67 },
|
||||
{ 0, 17534, 18491, 0 }, { 0, 15614, 2824, 6425 }, { 0, 14019, 13677, 0 }, { 0, 48573, 13677, 17219 }
|
||||
}, { /* input: linear-gray */
|
||||
{ 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 73, 0 },
|
||||
{ 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }
|
||||
}, { /* input: linear-gray+alpha */
|
||||
{ 0, 74, 74, 0 }, { 0, 255, 74, 25 }, { 0, 97, 74, 0 }, { 0, 255, 74, 25 },
|
||||
{ 0, 18919, 18907, 0 }, { 0, 24549, 18907, 6552 }, { 0, 18919, 18907, 0 }, { 0, 24549, 18907, 6552 }
|
||||
}, { /* input: linear-rgb */
|
||||
{ 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 98, 0 }, { 0, 0, 98, 0 },
|
||||
{ 0, 0, 18664, 0 }, { 0, 0, 18664, 0 }, { 0, 0, 24998, 0 }, { 0, 0, 24998, 0 }
|
||||
}, { /* input: linear-rgb+alpha */
|
||||
{ 0, 181, 196, 0 }, { 0, 255, 61, 25 }, { 206, 187, 98, 0 }, { 0, 255, 98, 67 },
|
||||
{ 0, 18141, 18137, 0 }, { 0, 17494, 17504, 6553 }, { 0, 24979, 24992, 0 }, { 0, 46509, 24992, 17347 }
|
||||
}
|
||||
};
|
||||
/* END MACHINE GENERATED */
|
||||
# include "pngstest-errors.h" /* machine generated */
|
||||
#endif /* COLORMAP flag check */
|
||||
#endif /* flag checks */
|
||||
|
||||
@@ -2154,7 +2005,7 @@ typedef struct
|
||||
int in_opaque; /* Value of input alpha that is opaque */
|
||||
int is_palette; /* Sample values come from the palette */
|
||||
int accumulate; /* Accumlate component errors (don't log) */
|
||||
int output_8bit; /* Output is 8 bit (else 16 bit) */
|
||||
int output_8bit; /* Output is 8-bit (else 16-bit) */
|
||||
|
||||
void (*in_gp)(Pixel*, png_const_voidp);
|
||||
void (*out_gp)(Pixel*, png_const_voidp);
|
||||
@@ -3722,6 +3573,23 @@ main(int argc, char **argv)
|
||||
{
|
||||
unsigned int in;
|
||||
|
||||
printf("/* contrib/libtests/pngstest-errors.h\n");
|
||||
printf(" *\n");
|
||||
printf(" * BUILT USING:" PNG_HEADER_VERSION_STRING);
|
||||
printf(" *\n");
|
||||
printf(" * This code is released under the libpng license.\n");
|
||||
printf(" * For conditions of distribution and use, see the disclaimer\n");
|
||||
printf(" * and license in png.h\n");
|
||||
printf(" *\n");
|
||||
printf(" * THIS IS A MACHINE GENERATED FILE: do not edit it directly!\n");
|
||||
printf(" * Instead run:\n");
|
||||
printf(" *\n");
|
||||
printf(" * pngstest --accumulate\n");
|
||||
printf(" *\n");
|
||||
printf(" * on as many PNG files as possible; at least PNGSuite and\n");
|
||||
printf(" * contrib/libtests/testpngs.\n");
|
||||
printf(" */\n");
|
||||
|
||||
printf("static png_uint_16 gpc_error[16/*in*/][16/*out*/][4/*a*/] =\n");
|
||||
printf("{\n");
|
||||
for (in=0; in<16; ++in)
|
||||
@@ -3811,6 +3679,7 @@ main(int argc, char **argv)
|
||||
putchar('\n');
|
||||
}
|
||||
printf("};\n");
|
||||
printf("/* END MACHINE GENERATED */\n");
|
||||
}
|
||||
|
||||
if (retval == 0 && touch != NULL)
|
||||
|
||||
@@ -363,7 +363,7 @@ ancillary(const char *name)
|
||||
return PNG_CHUNK_ANCILLARY(PNG_U32(name[0], name[1], name[2], name[3]));
|
||||
}
|
||||
|
||||
#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
|
||||
#ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
|
||||
static int
|
||||
ancillaryb(const png_byte *name)
|
||||
{
|
||||
@@ -554,7 +554,7 @@ read_callback(png_structp pp, png_unknown_chunkp pc)
|
||||
/* However if there is no support to store unknown chunks don't ask libpng to
|
||||
* do it; there will be an png_error.
|
||||
*/
|
||||
# ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
|
||||
# ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
|
||||
return discard;
|
||||
# else
|
||||
return 1; /*handled; discard*/
|
||||
@@ -562,7 +562,7 @@ read_callback(png_structp pp, png_unknown_chunkp pc)
|
||||
}
|
||||
#endif /* READ_USER_CHUNKS_SUPPORTED */
|
||||
|
||||
#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
|
||||
#ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
|
||||
static png_uint_32
|
||||
get_unknown(display *d, png_infop info_ptr, int after_IDAT)
|
||||
{
|
||||
@@ -722,11 +722,17 @@ check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/,
|
||||
* in this case, so we just check the arguments! This could
|
||||
* be improved in the future by using the read callback.
|
||||
*/
|
||||
png_byte name[5];
|
||||
# if PNG_LIBPNG_VER >= 10700 &&\
|
||||
!defined(PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED)
|
||||
if (option < PNG_HANDLE_CHUNK_IF_SAFE)
|
||||
# endif /* 1.7+ SAVE_UNKNOWN_CHUNKS */
|
||||
{
|
||||
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;
|
||||
memcpy(name, chunk_info[chunk].name, 5);
|
||||
png_set_keep_unknown_chunks(d->png_ptr, option, name, 1);
|
||||
chunk_info[chunk].keep = option;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -735,7 +741,12 @@ check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/,
|
||||
case 7: /* default */
|
||||
if (memcmp(argv[i], "default", 7) == 0)
|
||||
{
|
||||
png_set_keep_unknown_chunks(d->png_ptr, option, NULL, 0);
|
||||
# if PNG_LIBPNG_VER >= 10700 &&\
|
||||
!defined(PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED)
|
||||
if (option < PNG_HANDLE_CHUNK_IF_SAFE)
|
||||
# endif /* 1.7+ SAVE_UNKNOWN_CHUNKS */
|
||||
png_set_keep_unknown_chunks(d->png_ptr, option, NULL, 0);
|
||||
|
||||
d->keep = option;
|
||||
continue;
|
||||
}
|
||||
@@ -745,7 +756,12 @@ check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/,
|
||||
case 3: /* all */
|
||||
if (memcmp(argv[i], "all", 3) == 0)
|
||||
{
|
||||
png_set_keep_unknown_chunks(d->png_ptr, option, NULL, -1);
|
||||
# if PNG_LIBPNG_VER >= 10700 &&\
|
||||
!defined(PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED)
|
||||
if (option < PNG_HANDLE_CHUNK_IF_SAFE)
|
||||
# endif /* 1.7+ SAVE_UNKNOWN_CHUNKS */
|
||||
png_set_keep_unknown_chunks(d->png_ptr, option, NULL, -1);
|
||||
|
||||
d->keep = option;
|
||||
|
||||
for (chunk = 0; chunk < NINFO; ++chunk)
|
||||
@@ -1242,4 +1258,4 @@ main(void)
|
||||
/* So the test is skipped: */
|
||||
return 77;
|
||||
}
|
||||
#endif /* SET_UNKNOWN_CHUNKS && READ */
|
||||
#endif /* SET_UNKNOWN_CHUNKS && READ*/
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -31,6 +31,13 @@
|
||||
# include "../../png.h"
|
||||
#endif
|
||||
|
||||
#if PNG_LIBPNG_VER < 10700
|
||||
/* READ_INTERLACING was used instead of READ_DEINTERLACE. */
|
||||
# ifdef PNG_READ_INTERLACING_SUPPORTED
|
||||
# define PNG_READ_DEINTERLACE_SUPPORTED
|
||||
# endif
|
||||
#endif
|
||||
|
||||
static int
|
||||
read_png(FILE *fp)
|
||||
{
|
||||
@@ -70,7 +77,12 @@ read_png(FILE *fp)
|
||||
|
||||
{
|
||||
png_uint_32 height = png_get_image_height(png_ptr, info_ptr);
|
||||
int passes = png_set_interlace_handling(png_ptr);
|
||||
# ifdef PNG_READ_DEINTERLACE_SUPPORTED
|
||||
int passes = png_set_interlace_handling(png_ptr);
|
||||
# else
|
||||
int passes = png_get_interlace_type(png_ptr, info_ptr) ==
|
||||
PNG_INTERLACE_ADAM7 ? PNG_INTERLACE_ADAM7_PASSES : 1;
|
||||
# endif
|
||||
int pass;
|
||||
|
||||
png_start_read_image(png_ptr);
|
||||
@@ -79,6 +91,11 @@ read_png(FILE *fp)
|
||||
{
|
||||
png_uint_32 y = height;
|
||||
|
||||
# ifndef PNG_READ_DEINTERLACE_SUPPORTED
|
||||
if (passes == PNG_INTERLACE_ADAM7_PASSES)
|
||||
y = PNG_PASS_ROWS(y, pass);
|
||||
# endif
|
||||
|
||||
/* NOTE: this trashes the row each time; interlace handling won't
|
||||
* work, but this avoids memory thrashing for speed testing.
|
||||
*/
|
||||
|
||||
@@ -634,7 +634,7 @@ int validation_muldiv(int count, int argc, char **argv)
|
||||
{
|
||||
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
|
||||
* hold 64 bits or more, if floating point is used a 64-bit or
|
||||
* better mantissa is required.
|
||||
*/
|
||||
long long int fp, fpround;
|
||||
@@ -721,7 +721,7 @@ int validation_muldiv(int count, int argc, char **argv)
|
||||
}
|
||||
while (--count > 0);
|
||||
|
||||
printf("%d tests including %d overflows, %d passed, %d failed (%d 64 bit "
|
||||
printf("%d tests including %d overflows, %d passed, %d failed (%d 64-bit "
|
||||
"errors)\n", tested, overflow, passed, error, error64);
|
||||
return 0;
|
||||
}
|
||||
@@ -799,13 +799,13 @@ int validation_gamma(int argc, char **argv)
|
||||
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",
|
||||
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);
|
||||
printf("maximum 8-bit log error = %f\n", maxerr);
|
||||
|
||||
maxerr = 0;
|
||||
for (i=0; i<65536; ++i)
|
||||
@@ -821,14 +821,14 @@ int validation_gamma(int argc, char **argv)
|
||||
{
|
||||
if (error > .68) /* By experiment error is less than .68 */
|
||||
{
|
||||
fprintf(stderr, "16 bit log error: %d: got %u, expected %f"
|
||||
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);
|
||||
printf("maximum 16-bit log error = %f\n", maxerr);
|
||||
|
||||
/* Now exponentiations. */
|
||||
maxerr = 0;
|
||||
@@ -841,13 +841,13 @@ int validation_gamma(int argc, char **argv)
|
||||
maxerr = fabs(error);
|
||||
if (fabs(error) > 1883) /* By experiment. */
|
||||
{
|
||||
fprintf(stderr, "32 bit exp error: %d: got %u, expected %f"
|
||||
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);
|
||||
printf("maximum 32-bit exp error = %f\n", maxerr);
|
||||
|
||||
maxerr = 0;
|
||||
for (i=0; i<=0xfffff; ++i)
|
||||
@@ -859,13 +859,13 @@ int validation_gamma(int argc, char **argv)
|
||||
maxerr = fabs(error);
|
||||
if (fabs(error) > .50002) /* By experiment */
|
||||
{
|
||||
fprintf(stderr, "8 bit exp error: %d: got %u, expected %f"
|
||||
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);
|
||||
printf("maximum 8-bit exp error = %f\n", maxerr);
|
||||
|
||||
maxerr = 0;
|
||||
for (i=0; i<=0xfffff; ++i)
|
||||
@@ -877,13 +877,13 @@ int validation_gamma(int argc, char **argv)
|
||||
maxerr = fabs(error);
|
||||
if (fabs(error) > .524) /* By experiment */
|
||||
{
|
||||
fprintf(stderr, "16 bit exp error: %d: got %u, expected %f"
|
||||
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);
|
||||
printf("maximum 16-bit exp error = %f\n", maxerr);
|
||||
} /* !onlygamma */
|
||||
|
||||
/* Test the overall gamma correction. */
|
||||
@@ -913,7 +913,7 @@ int validation_gamma(int argc, char **argv)
|
||||
}
|
||||
|
||||
if (!silent)
|
||||
printf("gamma %f: maximum 8 bit error %f\n", g, maxerr);
|
||||
printf("gamma %f: maximum 8-bit error %f\n", g, maxerr);
|
||||
|
||||
maxerr = 0;
|
||||
for (j=0; j<65536; ++j)
|
||||
@@ -932,7 +932,7 @@ int validation_gamma(int argc, char **argv)
|
||||
}
|
||||
|
||||
if (!silent)
|
||||
printf("gamma %f: maximum 16 bit error %f\n", g, maxerr);
|
||||
printf("gamma %f: maximum 16-bit error %f\n", g, maxerr);
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
Reference in New Issue
Block a user