diff --git a/ANNOUNCE b/ANNOUNCE index 38c42c9a4..004ea5187 100644 --- a/ANNOUNCE +++ b/ANNOUNCE @@ -1,5 +1,5 @@ -Libpng 1.6.8beta01 - November 19, 2013 +Libpng 1.6.8beta01 - November 22, 2013 This is not intended to be a public release. It will be replaced within a few weeks by a public version or by another test version. @@ -26,7 +26,7 @@ Other information: Changes since the last public release (1.6.7): -Version 1.6.8beta01 [November 19, 2013] +Version 1.6.8beta01 [November 22, 2013] Changed #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED in pngpread.c to #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED to be consistent with what is in pngpriv.h. @@ -34,6 +34,11 @@ Version 1.6.8beta01 [November 19, 2013] the #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED/#endif block. Added "-Wall" to CFLAGS in contrib/pngminim/*/makefile Conditionally compile some unused functions reported by -Wall in pngminim. + Fixed 'minimal' builds. Various obviously useful minimal configurations + don't build because of missing contrib/libtests test programs and overly + complex dependencies in scripts/pnglibconf.dfa. This change adds + contrib/conftest/*.dfa files that can be used in automatic build + scripts to ensure that these configurations continue to build. Send comments/corrections/commendations to png-mng-implement at lists.sf.net (subscription required; visit diff --git a/CHANGES b/CHANGES index c5486b3ee..5f6030663 100644 --- a/CHANGES +++ b/CHANGES @@ -4713,11 +4713,17 @@ Version 1.6.7rc02 [November 7, 2013] Version 1.6.7 [November 14, 2013] -Version 1.6.8beta01 [November 19, 2013] +Version 1.6.8beta01 [November 22, 2013] Moved prototype for png_handle_unknown() in pngpriv.h outside of the #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED/#endif block. Added "-Wall" to CFLAGS in contrib/pngminim/*/makefile - Conditionally compile some unused functions reported by -Wall in pngminim. + Conditionally compile some unused functions reported by -Wall in + pngminim. + Fixed 'minimal' builds. Various obviously useful minimal configurations + don't build because of missing contrib/libtests test programs and overly + complex dependencies in scripts/pnglibconf.dfa. This change adds + contrib/conftest/*.dfa files that can be used in automatic build + scripts to ensure that these configurations continue to build. Send comments/corrections/commendations to png-mng-implement at lists.sf.net (subscription required; visit diff --git a/contrib/conftest/README b/contrib/conftest/README new file mode 100644 index 000000000..0f472791f --- /dev/null +++ b/contrib/conftest/README @@ -0,0 +1,49 @@ +This directory contains test configuration files, currently always '.dfa' files +intended to be used in the build by setting the make macro DFA_XTRA to the name +of the file. + +These files are used in release validation of the 'configure' builds of libpng +by building 'make check', or 'make all-am' for cross-builds, with each .dfa +file. + +The files in this directory may change between minor releases, however +contributions describing specific builds of libpng are welcomed. There is no +guarantee that libpng will continue to build with such configurations; support +for given configurations can be, and has been, dropped between successive minor +releases. However if a .dfa file describing a configuration is not in this +directory it is very unlikely that it will be tested before a minor release! + +You can use these .dfa files as the basis of new configurations. Files in this +directory should not have any use restrictions or restrictive licenses. + +This directory is not included in the .zip and .7z distributions, which do +not contain 'configure' scripts. + +DOCUMENTATION +============= + +Examples: + ${srcdir}/pngusr.dfa + ${srcdir}/contrib/pngminim/*/pngusr.dfa + +Documentation of the options: + ${srcdir}/scripts/pnglibconf.dfa + +Documentation of the file format: + ${srcdir}/scripts/options.awk + +FILE NAMING +=========== + +File names in this directory may NOT contain any of the five characters: + + - , + * ? + +Neither may they contain any space character. + +While other characters may be used it is strongly suggested that file names be +limited to lower case Latiin alphabetic characters (a-z), digits (0-9) and, if +necessary the underscore (_) character. File names should be about 8 characters +long (excluding the .dfa extension). Submitted .dfa files should have names +between 7 and 16 characters long, shorter names (6 characters or less) are +reserved for standard tests. diff --git a/contrib/conftest/read.dfa b/contrib/conftest/read.dfa new file mode 100644 index 000000000..21e88d01a --- /dev/null +++ b/contrib/conftest/read.dfa @@ -0,0 +1,58 @@ +# read.dfa +# Build time configuration of libpng +# +# Author: John Bowler +# Copyright: (c) John Bowler, 2013 +# Usage rights: +# 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. +# +# Build libpng with basic read support. This enables the lowest level libpng +# read API - the one where the calling code has to use a loop to read each row. +# At present this is the API used by most programs. +# +# Support is enabled only for those chunks and transformations that are +# typically required - others can be added easily. +# + +everything = off + +# The sequential read code is enabled here; the progressive code can be used +# instead but there is no point enabling both. + +option SEQUENTIAL_READ on + +# Likewise it is pointless enabling both fixed and floating point APIs. Choose +# one or the other for both the API and the internal math. + +#Fixed point: +#option FIXED_POINT on +#option FLOATING_ARITHMETIC off + +#Floating point: +option FLOATING_POINT on +option FLOATING_ARITHMETIC on + +# Basic error handling, IO and user memory support. The latter allows the +# application program to provide its own implementations of 'malloc' and 'free'. +option SETJMP on +option STDIO on +option USER_MEM on + +# To read the full set of PNG images correctly interlace, transparency and +# 16-bit support is required. The application can implement interlace itself, +# but very few do and it's no longer possible to disable it when READ is +# enabled. +option READ_tRNS on +option READ_16BIT on + +# Everything else is application dependent. This file assumes the app handles +# all the native PNG bit layouts, so it doesn't need any of layout change +# transforms, but needs libpng to perform gamma correction. It doesn't do any +# colorspace stuff and ignores the 'significant bit' information. +# +# If your app always expands the image to a limited set of bit layouts you +# probably want to consider using the simplified API instead of the low level +# one - see png.h and s_read.dfa. +option READ_GAMMA on diff --git a/contrib/conftest/s_read.dfa b/contrib/conftest/s_read.dfa new file mode 100644 index 000000000..cb1ce0ba6 --- /dev/null +++ b/contrib/conftest/s_read.dfa @@ -0,0 +1,35 @@ +# s_read.dfa +# Build time configuration of libpng +# +# Author: John Bowler +# Copyright: (c) John Bowler, 2013 +# Usage rights: +# 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. +# +# Build libpng with simplified read support (only). This builds a minimal +# libpng able to read all PNG formats and convert them into a small number of +# well understood memory formats. +# + +everything = off + +option SIMPLIFIED_READ on + +# It isn't necessary to chose fixed or floating point for the APIs because the +# simplified API doesn't need fixed or floating point numbers. It is necessary +# to chose an internal math implementation. The default (because of 'everything +# = off') is fixed point - turn the floating point implementation on if you have +# hardware floating point or prefer your software floating point implementation. +option FLOATING_ARITHMETIC on + +# This is not strictly necessary, but without it the message strings in the API +# will not be filled in +option ERROR_TEXT on + +# Switching these options on enables the 'AFIRST' and 'BGR' formats - you don't +# need this if you don't use them, they just allow the in-memory layout to be +# changed to match common hardware formats. +option SIMPLIFIED_READ_AFIRST on +option SIMPLIFIED_READ_BGR on diff --git a/contrib/conftest/s_write.dfa b/contrib/conftest/s_write.dfa new file mode 100644 index 000000000..e540a46dc --- /dev/null +++ b/contrib/conftest/s_write.dfa @@ -0,0 +1,33 @@ +# s_write.dfa +# Build time configuration of libpng +# +# Author: John Bowler +# Copyright: (c) John Bowler, 2013 +# Usage rights: +# 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. +# +# Build libpng with (just) simplified write support +# + +everything = off + +option SIMPLIFIED_WRITE on + +# It isn't necessary to chose fixed or floating point for the APIs because the +# simplified API doesn't need fixed or floating point numbers. It is necessary +# to chose an internal math implementation. The default (because of 'everything +# = off') is fixed point - turn the floating point implementation on if you have +# hardware floating point or prefer your software floating point implementation. +option FLOATING_ARITHMETIC on + +# This is not strictly necessary, but without it the message strings in the API +# will not be filled in +option ERROR_TEXT on + +# Switching these options on enables the 'AFIRST' and 'BGR' formats - you don't +# need this if you don't use them, they just allow the in-memory layout to be +# changed to match common hardware formats. +option SIMPLIFIED_WRITE_AFIRST on +option SIMPLIFIED_WRITE_BGR on diff --git a/contrib/conftest/simple.dfa b/contrib/conftest/simple.dfa new file mode 100644 index 000000000..041933344 --- /dev/null +++ b/contrib/conftest/simple.dfa @@ -0,0 +1,36 @@ +# simple.dfa +# Build time configuration of libpng +# +# Author: John Bowler +# Copyright: (c) John Bowler, 2013 +# Usage rights: +# 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. +# +# Build libpng with just the simplified APIs (read and write). +# + +everything = off + +option SIMPLIFIED_WRITE on +option SIMPLIFIED_READ on + +# It isn't necessary to chose fixed or floating point for the APIs because the +# simplified API doesn't need fixed or floating point numbers. It is necessary +# to chose an internal math implementation. The default (because of 'everything +# = off') is fixed point - turn the floating point implementation on if you have +# hardware floating point or prefer your software floating point implementation. +option FLOATING_ARITHMETIC on + +# This is not strictly necessary, but without it the message strings in the API +# will not be filled in +option ERROR_TEXT on + +# Switching these options on enables the 'AFIRST' and 'BGR' formats - you don't +# need this if you don't use them, they just allow the in-memory layout to be +# changed to match common hardware formats. +option SIMPLIFIED_READ_AFIRST on +option SIMPLIFIED_READ_BGR on +option SIMPLIFIED_WRITE_AFIRST on +option SIMPLIFIED_WRITE_BGR on diff --git a/contrib/conftest/write.dfa b/contrib/conftest/write.dfa new file mode 100644 index 000000000..3319aabee --- /dev/null +++ b/contrib/conftest/write.dfa @@ -0,0 +1,45 @@ +# write.dfa +# Build time configuration of libpng +# +# Author: John Bowler +# Copyright: (c) John Bowler, 2013 +# Usage rights: +# 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. +# +# Build libpng with no read support and minimal write support. +# + +everything = off + +# Switch on the write code - this makes a minimalist encoder + +option WRITE on + +# Choose fixed or floating point APIs and arithmetic. The choices are +# independent but normally they will match. It is typically better to use the +# floating point if you have floating point hardware. If you don't know, or +# (perhaps) to make libpng smaller used fixed point throughout. + +#Fixed point: +#option FIXED_POINT on +#option FLOATING_ARITHMETIC off + +#Floating point: +option FLOATING_POINT on +option FLOATING_ARITHMETIC on + +# Basic error handling, IO and user memory support. The latter allows the +# application program to provide its own implementations of 'malloc' and 'free'. +option SETJMP on +option STDIO on +option USER_MEM on + +# Everything else is optional. Unlike the read code in libpng the write code +# does not need to deal with arbitrary formats, so only add support for things +# you really do write! For example you might only write sRGB images, sometimes +# with transparency and never write 16 bit images, so: +option WRITE_sRGB on +option WRITE_tRNS on +#option WRITE_16BIT off (this is the default with 'everything = off') diff --git a/contrib/libtests/pngstest.c b/contrib/libtests/pngstest.c index 35e7c8779..c70cd057c 100644 --- a/contrib/libtests/pngstest.c +++ b/contrib/libtests/pngstest.c @@ -517,14 +517,23 @@ static void format_default(format_list *pf, int redundant) for (f=0; fa = pp[1]; } +#ifdef PNG_FORMAT_AFIRST_SUPPORTED static void gp_ag8(Pixel *p, png_const_voidp pb) { @@ -794,6 +804,7 @@ gp_ag8(Pixel *p, png_const_voidp pb) p->r = p->g = p->b = pp[1]; p->a = pp[0]; } +#endif static void gp_rgb8(Pixel *p, png_const_voidp pb) @@ -806,6 +817,7 @@ gp_rgb8(Pixel *p, png_const_voidp pb) p->a = 255; } +#ifdef PNG_FORMAT_BGR_SUPPORTED static void gp_bgr8(Pixel *p, png_const_voidp pb) { @@ -816,6 +828,7 @@ gp_bgr8(Pixel *p, png_const_voidp pb) p->b = pp[0]; p->a = 255; } +#endif static void gp_rgba8(Pixel *p, png_const_voidp pb) @@ -828,6 +841,7 @@ gp_rgba8(Pixel *p, png_const_voidp pb) p->a = pp[3]; } +#ifdef PNG_FORMAT_BGR_SUPPORTED static void gp_bgra8(Pixel *p, png_const_voidp pb) { @@ -838,7 +852,9 @@ gp_bgra8(Pixel *p, png_const_voidp pb) p->b = pp[0]; p->a = pp[3]; } +#endif +#ifdef PNG_FORMAT_AFIRST_SUPPORTED static void gp_argb8(Pixel *p, png_const_voidp pb) { @@ -849,7 +865,9 @@ gp_argb8(Pixel *p, png_const_voidp pb) p->b = pp[3]; p->a = pp[0]; } +#endif +#if defined(PNG_FORMAT_AFIRST_SUPPORTED) && defined(PNG_FORMAT_BGR_SUPPORTED) static void gp_abgr8(Pixel *p, png_const_voidp pb) { @@ -860,6 +878,7 @@ gp_abgr8(Pixel *p, png_const_voidp pb) p->b = pp[1]; p->a = pp[0]; } +#endif static void gp_g16(Pixel *p, png_const_voidp pb) @@ -879,6 +898,7 @@ gp_ga16(Pixel *p, png_const_voidp pb) p->a = pp[1]; } +#ifdef PNG_FORMAT_AFIRST_SUPPORTED static void gp_ag16(Pixel *p, png_const_voidp pb) { @@ -887,6 +907,7 @@ gp_ag16(Pixel *p, png_const_voidp pb) p->r = p->g = p->b = pp[1]; p->a = pp[0]; } +#endif static void gp_rgb16(Pixel *p, png_const_voidp pb) @@ -899,6 +920,7 @@ gp_rgb16(Pixel *p, png_const_voidp pb) p->a = 65535; } +#ifdef PNG_FORMAT_BGR_SUPPORTED static void gp_bgr16(Pixel *p, png_const_voidp pb) { @@ -909,6 +931,7 @@ gp_bgr16(Pixel *p, png_const_voidp pb) p->b = pp[0]; p->a = 65535; } +#endif static void gp_rgba16(Pixel *p, png_const_voidp pb) @@ -921,6 +944,7 @@ gp_rgba16(Pixel *p, png_const_voidp pb) p->a = pp[3]; } +#ifdef PNG_FORMAT_BGR_SUPPORTED static void gp_bgra16(Pixel *p, png_const_voidp pb) { @@ -931,7 +955,9 @@ gp_bgra16(Pixel *p, png_const_voidp pb) p->b = pp[0]; p->a = pp[3]; } +#endif +#ifdef PNG_FORMAT_AFIRST_SUPPORTED static void gp_argb16(Pixel *p, png_const_voidp pb) { @@ -942,7 +968,9 @@ gp_argb16(Pixel *p, png_const_voidp pb) p->b = pp[3]; p->a = pp[0]; } +#endif +#if defined(PNG_FORMAT_AFIRST_SUPPORTED) && defined(PNG_FORMAT_BGR_SUPPORTED) static void gp_abgr16(Pixel *p, png_const_voidp pb) { @@ -953,6 +981,7 @@ gp_abgr16(Pixel *p, png_const_voidp pb) p->b = pp[1]; p->a = pp[0]; } +#endif /* Given a format, return the correct one of the above functions. */ static void (* @@ -966,29 +995,35 @@ get_pixel(png_uint_32 format))(Pixel *p, png_const_voidp pb) { if (format & PNG_FORMAT_FLAG_COLOR) { - if (format & PNG_FORMAT_FLAG_BGR) - { - if (format & PNG_FORMAT_FLAG_ALPHA) +# ifdef PNG_FORMAT_BGR_SUPPORTED + if (format & PNG_FORMAT_FLAG_BGR) { - if (format & PNG_FORMAT_FLAG_AFIRST) - return gp_abgr16; + if (format & PNG_FORMAT_FLAG_ALPHA) + { +# ifdef PNG_FORMAT_AFIRST_SUPPORTED + if (format & PNG_FORMAT_FLAG_AFIRST) + return gp_abgr16; + + else +# endif + return gp_bgra16; + } else - return gp_bgra16; + return gp_bgr16; } else - return gp_bgr16; - } - - else +# endif { if (format & PNG_FORMAT_FLAG_ALPHA) { - if (format & PNG_FORMAT_FLAG_AFIRST) - return gp_argb16; +# ifdef PNG_FORMAT_AFIRST_SUPPORTED + if (format & PNG_FORMAT_FLAG_AFIRST) + return gp_argb16; - else + else +# endif return gp_rgba16; } @@ -1001,10 +1036,12 @@ get_pixel(png_uint_32 format))(Pixel *p, png_const_voidp pb) { if (format & PNG_FORMAT_FLAG_ALPHA) { - if (format & PNG_FORMAT_FLAG_AFIRST) - return gp_ag16; +# ifdef PNG_FORMAT_AFIRST_SUPPORTED + if (format & PNG_FORMAT_FLAG_AFIRST) + return gp_ag16; - else + else +# endif return gp_ga16; } @@ -1017,29 +1054,35 @@ get_pixel(png_uint_32 format))(Pixel *p, png_const_voidp pb) { if (format & PNG_FORMAT_FLAG_COLOR) { - if (format & PNG_FORMAT_FLAG_BGR) - { - if (format & PNG_FORMAT_FLAG_ALPHA) +# ifdef PNG_FORMAT_BGR_SUPPORTED + if (format & PNG_FORMAT_FLAG_BGR) { - if (format & PNG_FORMAT_FLAG_AFIRST) - return gp_abgr8; + if (format & PNG_FORMAT_FLAG_ALPHA) + { +# ifdef PNG_FORMAT_AFIRST_SUPPORTED + if (format & PNG_FORMAT_FLAG_AFIRST) + return gp_abgr8; + + else +# endif + return gp_bgra8; + } else - return gp_bgra8; + return gp_bgr8; } else - return gp_bgr8; - } - - else +# endif { if (format & PNG_FORMAT_FLAG_ALPHA) { - if (format & PNG_FORMAT_FLAG_AFIRST) - return gp_argb8; +# ifdef PNG_FORMAT_AFIRST_SUPPORTED + if (format & PNG_FORMAT_FLAG_AFIRST) + return gp_argb8; - else + else +# endif return gp_rgba8; } @@ -1052,10 +1095,12 @@ get_pixel(png_uint_32 format))(Pixel *p, png_const_voidp pb) { if (format & PNG_FORMAT_FLAG_ALPHA) { - if (format & PNG_FORMAT_FLAG_AFIRST) - return gp_ag8; +# ifdef PNG_FORMAT_AFIRST_SUPPORTED + if (format & PNG_FORMAT_FLAG_AFIRST) + return gp_ag8; - else + else +# endif return gp_ga8; } @@ -2618,13 +2663,15 @@ component_loc(png_byte loc[4], png_uint_32 format) loc[2] = 1; - if (format & PNG_FORMAT_FLAG_BGR) - { - loc[1] = 2; - loc[3] = 0; - } +# ifdef PNG_FORMAT_BGR_SUPPORTED + if (format & PNG_FORMAT_FLAG_BGR) + { + loc[1] = 2; + loc[3] = 0; + } - else + else +# endif { loc[1] = 0; loc[3] = 2; @@ -2639,15 +2686,17 @@ component_loc(png_byte loc[4], png_uint_32 format) if (format & PNG_FORMAT_FLAG_ALPHA) { - if (format & PNG_FORMAT_FLAG_AFIRST) - { - loc[0] = 0; - ++loc[1]; - ++loc[2]; - ++loc[3]; - } +# ifdef PNG_FORMAT_AFIRST_SUPPORTED + if (format & PNG_FORMAT_FLAG_AFIRST) + { + loc[0] = 0; + ++loc[1]; + ++loc[2]; + ++loc[3]; + } - else + else +# endif loc[0] = channels; ++channels; @@ -3017,17 +3066,25 @@ read_file(Image *image, png_uint_32 format, png_const_colorp background) return logerror(image, "memory init: ", image->file_name, ""); } - else if (image->input_file != NULL) - { - if (!png_image_begin_read_from_stdio(&image->image, image->input_file)) - return logerror(image, "stdio init: ", image->file_name, ""); - } +# ifdef PNG_STDIO_SUPPORTED + else if (image->input_file != NULL) + { + if (!png_image_begin_read_from_stdio(&image->image, image->input_file)) + return logerror(image, "stdio init: ", image->file_name, ""); + } - else - { - if (!png_image_begin_read_from_file(&image->image, image->file_name)) - return logerror(image, "file init: ", image->file_name, ""); - } + else + { + if (!png_image_begin_read_from_file(&image->image, image->file_name)) + return logerror(image, "file init: ", image->file_name, ""); + } +# else + else + { + return logerror(image, "unsupported file/stdio init: ", + image->file_name, ""); + } +# endif /* This must be set after the begin_read call: */ if (image->opts & sRGB_16BIT) @@ -3466,11 +3523,19 @@ main(int argc, char **argv) memset(gpc_error_via_linear, 0, sizeof gpc_error_via_linear); } else if (strcmp(arg, "--file") == 0) - opts |= READ_FILE; +# ifdef PNG_STDIO_SUPPORTED + opts |= READ_FILE; +# else + return 77; /* skipped: no support */ +# endif else if (strcmp(arg, "--memory") == 0) opts &= ~READ_FILE; else if (strcmp(arg, "--stdio") == 0) - opts |= USE_STDIO; +# ifdef PNG_STDIO_SUPPORTED + opts |= USE_STDIO; +# else + return 77; /* skipped: no support */ +# endif else if (strcmp(arg, "--name") == 0) opts &= ~USE_STDIO; else if (strcmp(arg, "--verbose") == 0) diff --git a/contrib/libtests/pngvalid.c b/contrib/libtests/pngvalid.c index 55ec5af4f..3c45d0b13 100644 --- a/contrib/libtests/pngvalid.c +++ b/contrib/libtests/pngvalid.c @@ -43,7 +43,10 @@ # include "../../png.h" #endif -#ifdef PNG_WRITE_SUPPORTED /* else pngvalid can do nothing */ +/* pngvalid requires write support and one of the fixed or floating point APIs. + */ +#if defined(PNG_WRITE_SUPPORTED) &&\ + (defined(PNG_FIXED_POINT_SUPPORTED) || defined(PNG_FLOATING_POINT_SUPPORTED)) #if PNG_LIBPNG_VER < 10500 /* This deliberately lacks the PNG_CONST. */ @@ -106,6 +109,11 @@ typedef png_byte *png_const_bytep; # endif #endif +/* Fixups for various minimal builds */ +#ifndef PNG_ERROR_TEXT_SUPPORTED +# define png_error(a,b) png_err(a) +#endif + /***************************** EXCEPTION HANDLING *****************************/ #ifdef PNG_FREESTANDING_TESTS # include @@ -1263,6 +1271,7 @@ store_current_palette(png_store *ps, int *npalette) #endif /* PNG_READ_SUPPORTED */ /***************************** MEMORY MANAGEMENT*** ***************************/ +#ifdef PNG_USER_MEM_SUPPORTED /* A store_memory is simply the header for an allocated block of memory. The * pointer returned to libpng is just after the end of the header block, the * allocated memory is followed by a second copy of the 'mark'. @@ -1463,6 +1472,7 @@ store_free(png_structp ppIn, png_voidp memory) this->next = NULL; store_memory_free(pp, pool, this); } +#endif /* PNG_USER_MEM_SUPPORTED */ /* Setup functions. */ /* Cleanup when aborting a write or after storing the new file. */ @@ -1488,7 +1498,9 @@ store_write_reset(png_store *ps) /* And make sure that all the memory has been freed - this will output * spurious errors in the case of memory corruption above, but this is safe. */ - store_pool_delete(ps, &ps->write_memory_pool); +# ifdef PNG_USER_MEM_SUPPORTED + store_pool_delete(ps, &ps->write_memory_pool); +# endif store_freenew(ps); } @@ -1512,16 +1524,20 @@ set_store_for_write(png_store *ps, png_infopp ppi, store_write_reset(ps); safecat(ps->wname, sizeof ps->wname, 0, name); - /* Don't do the slow memory checks if doing a speed test. */ - if (ps->speed) + /* Don't do the slow memory checks if doing a speed test, also if user + * memory is not supported we can't do it anyway. + */ +# ifdef PNG_USER_MEM_SUPPORTED + if (!ps->speed) + ps->pwrite = png_create_write_struct_2(PNG_LIBPNG_VER_STRING, + ps, store_error, store_warning, &ps->write_memory_pool, + store_malloc, store_free); + + else +# endif ps->pwrite = png_create_write_struct(PNG_LIBPNG_VER_STRING, ps, store_error, store_warning); - else - ps->pwrite = png_create_write_struct_2(PNG_LIBPNG_VER_STRING, - ps, store_error, store_warning, &ps->write_memory_pool, - store_malloc, store_free); - png_set_write_fn(ps->pwrite, ps, store_write, store_flush); # ifdef PNG_SET_OPTION_SUPPORTED @@ -1569,8 +1585,10 @@ store_read_reset(png_store *ps) } # endif - /* Always do this to be safe. */ - store_pool_delete(ps, &ps->read_memory_pool); +# ifdef PNG_USER_MEM_SUPPORTED + /* Always do this to be safe. */ + store_pool_delete(ps, &ps->read_memory_pool); +# endif ps->current = NULL; ps->next = NULL; @@ -1630,14 +1648,16 @@ set_store_for_read(png_store *ps, png_infopp ppi, png_uint_32 id, * However, given that store_error works correctly in these circumstances * we don't ever expect NULL in this program. */ - if (ps->speed) - ps->pread = png_create_read_struct(PNG_LIBPNG_VER_STRING, ps, - store_error, store_warning); +# ifdef PNG_USER_MEM_SUPPORTED + if (!ps->speed) + ps->pread = png_create_read_struct_2(PNG_LIBPNG_VER_STRING, ps, + store_error, store_warning, &ps->read_memory_pool, store_malloc, + store_free); - else - ps->pread = png_create_read_struct_2(PNG_LIBPNG_VER_STRING, ps, - store_error, store_warning, &ps->read_memory_pool, store_malloc, - store_free); + else +# endif + ps->pread = png_create_read_struct(PNG_LIBPNG_VER_STRING, ps, store_error, + store_warning); if (ps->pread == NULL) { @@ -1933,9 +1953,11 @@ typedef struct png_modifier } png_modifier; /* This returns true if the test should be stopped now because it has already - * failed and it is running silently. + * failed and it is running silently. It is not static simply to avoid having + * to special case it on all the #ifdefs on which it depends. */ -static int fail(png_modifier *pm) +extern int fail(png_modifier *pm); +/*static*/ int fail(png_modifier *pm) { return !pm->log && !pm->this.verbose && (pm->this.nerrors > 0 || (pm->this.treat_warnings_as_errors && pm->this.nwarnings > 0)); @@ -3109,8 +3131,10 @@ init_standard_palette(png_store *ps, png_structp pp, png_infop pi, int npalette, for (; i<256; ++i) tRNS[i] = 24; - if (j > 0) - png_set_tRNS(pp, pi, tRNS, j, 0/*color*/); +# ifdef PNG_WRITE_tRNS_SUPPORTED + if (j > 0) + png_set_tRNS(pp, pi, tRNS, j, 0/*color*/); +# endif } } @@ -3356,6 +3380,13 @@ transform_row(png_const_structp pp, png_byte buffer[TRANSFORM_ROWMAX], */ #define DEPTH(bd) ((png_byte)(1U << (bd))) +/* This is just a helper for compiling on minimal systems with no write + * interlacing support. + */ +#ifndef PNG_WRITE_INTERLACING_SUPPORTED +# define png_set_interlace_handling(a) (1) +#endif + /* Make a standardized image given a an image colour type, bit depth and * interlace type. The standard images have a very restricted range of * rows and heights and are used for testing transforms rather than image @@ -3509,8 +3540,12 @@ make_transform_images(png_store *ps) { int interlace_type; - for (interlace_type = PNG_INTERLACE_NONE; - interlace_type < PNG_INTERLACE_LAST; ++interlace_type) +# ifdef PNG_WRITE_INTERLACING_SUPPORTED + for (interlace_type = PNG_INTERLACE_NONE; + interlace_type < PNG_INTERLACE_LAST; ++interlace_type) +# else + interlace_type = PNG_INTERLACE_NONE; +# endif { char name[FILE_NAME_SIZE]; @@ -3666,7 +3701,9 @@ make_size_image(png_store* PNG_CONST ps, png_byte PNG_CONST colour_type, int npasses = npasses_from_interlace_type(pp, interlace_type); png_uint_32 y; int pass; - int nfilter = PNG_FILTER_VALUE_LAST; +# ifdef PNG_WRITE_FILTER_SUPPORTED + int nfilter = PNG_FILTER_VALUE_LAST; +# endif png_byte image[16][SIZE_ROWMAX]; /* To help consistent error detection make the parts of this buffer @@ -3720,6 +3757,7 @@ make_size_image(png_store* PNG_CONST ps, png_byte PNG_CONST colour_type, continue; } +# ifdef PNG_WRITE_FILTER_SUPPORTED /* Only get to here if the row has some pixels in it, set the * filters to 'all' for the very first row and thereafter to a * single filter. It isn't well documented, but png_set_filter @@ -3735,6 +3773,7 @@ make_size_image(png_store* PNG_CONST ps, png_byte PNG_CONST colour_type, if (nfilter-- == 0) nfilter = PNG_FILTER_VALUE_LAST-1; +# endif png_write_row(pp, row); } @@ -3802,8 +3841,10 @@ make_size(png_store* PNG_CONST ps, png_byte PNG_CONST colour_type, int bdlo, width, height, 0); make_size_image(ps, colour_type, DEPTH(bdlo), PNG_INTERLACE_NONE, width, height, 1); +# ifdef PNG_WRITE_INTERLACING_SUPPORTED make_size_image(ps, colour_type, DEPTH(bdlo), PNG_INTERLACE_ADAM7, width, height, 0); +# endif make_size_image(ps, colour_type, DEPTH(bdlo), PNG_INTERLACE_ADAM7, width, height, 1); } @@ -3998,8 +4039,12 @@ make_errors(png_modifier* PNG_CONST pm, png_byte PNG_CONST colour_type, { int interlace_type; - for (interlace_type = PNG_INTERLACE_NONE; - interlace_type < PNG_INTERLACE_LAST; ++interlace_type) +# ifdef PNG_WRITE_INTERLACING_SUPPORTED + for (interlace_type = PNG_INTERLACE_NONE; + interlace_type < PNG_INTERLACE_LAST; ++interlace_type) +# else + interlace_type = PNG_INTERLACE_NONE; +# endif { unsigned int test; char name[FILE_NAME_SIZE]; @@ -4020,7 +4065,7 @@ make_errors(png_modifier* PNG_CONST pm, png_byte PNG_CONST colour_type, return 1; /* keep going */ } -#endif +#endif /* PNG_WARNINGS_SUPPORTED */ static void perform_error_test(png_modifier *pm) @@ -10224,10 +10269,11 @@ int main(int argc, char **argv) return 0; } -#else /* write not supported */ +#else /* write or low level APIs not supported */ int main(void) { - fprintf(stderr, "pngvalid: no write support in libpng, all tests skipped\n"); + fprintf(stderr, + "pngvalid: no low level write support in libpng, all tests skipped\n"); /* So the test is skipped: */ return 77; } diff --git a/png.c b/png.c index 21e22c59e..ca1ecc51c 100644 --- a/png.c +++ b/png.c @@ -259,6 +259,10 @@ png_create_png_struct,(png_const_charp user_png_ver, png_voidp error_ptr, */ # ifdef PNG_USER_MEM_SUPPORTED png_set_mem_fn(&create_struct, mem_ptr, malloc_fn, free_fn); +# else + PNG_UNUSED(mem_ptr) + PNG_UNUSED(malloc_fn) + PNG_UNUSED(free_fn) # endif /* (*error_fn) can return control to the caller after the error_ptr is set, @@ -768,13 +772,13 @@ png_get_copyright(png_const_structrp png_ptr) #else # ifdef __STDC__ return PNG_STRING_NEWLINE \ - "libpng version 1.6.8beta01 - November 19, 2013" PNG_STRING_NEWLINE \ + "libpng version 1.6.8beta01 - November 22, 2013" PNG_STRING_NEWLINE \ "Copyright (c) 1998-2013 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \ "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \ "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \ PNG_STRING_NEWLINE; # else - return "libpng version 1.6.8beta01 - November 19, 2013\ + return "libpng version 1.6.8beta01 - November 22, 2013\ Copyright (c) 1998-2013 Glenn Randers-Pehrson\ Copyright (c) 1996-1997 Andreas Dilger\ Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc."; @@ -3091,11 +3095,15 @@ png_fixed(png_const_structrp png_ptr, double fp, png_const_charp text) if (r > 2147483647. || r < -2147483648.) png_fixed_error(png_ptr, text); +# ifndef PNG_ERROR_TEXT_SUPPORTED + PNG_UNUSED(text) +# endif + return (png_fixed_point)r; } #endif -#if defined(PNG_READ_GAMMA_SUPPORTED) || \ +#if defined(PNG_GAMMA_SUPPORTED) || defined(PNG_COLORSPACE_SUPPORTED) ||\ defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG_READ_pHYs_SUPPORTED) /* muldiv functions */ /* This API takes signed arguments and rounds the result to the nearest diff --git a/pngerror.c b/pngerror.c index f469206ee..1895a2406 100644 --- a/pngerror.c +++ b/pngerror.c @@ -382,6 +382,10 @@ png_benign_error(png_const_structrp png_ptr, png_const_charp error_message) # endif png_error(png_ptr, error_message); } + +# ifndef PNG_ERROR_TEXT_SUPPORTED + PNG_UNUSED(error_message) +# endif } void /* PRIVATE */ @@ -391,6 +395,10 @@ png_app_warning(png_const_structrp png_ptr, png_const_charp error_message) png_warning(png_ptr, error_message); else png_error(png_ptr, error_message); + +# ifndef PNG_ERROR_TEXT_SUPPORTED + PNG_UNUSED(error_message) +# endif } void /* PRIVATE */ @@ -400,6 +408,10 @@ png_app_error(png_const_structrp png_ptr, png_const_charp error_message) png_warning(png_ptr, error_message); else png_error(png_ptr, error_message); + +# ifndef PNG_ERROR_TEXT_SUPPORTED + PNG_UNUSED(error_message) +# endif } #endif /* BENIGN_ERRORS */ @@ -416,7 +428,8 @@ static PNG_CONST char png_digit[16] = { }; #define PNG_MAX_ERROR_TEXT 196 /* Currently limited be profile_error in png.c */ -#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED) +#if defined(PNG_WARNINGS_SUPPORTED) || \ + (defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED)) static void /* PRIVATE */ png_format_buffer(png_const_structrp png_ptr, png_charp buffer, png_const_charp error_message) @@ -506,6 +519,10 @@ png_chunk_benign_error(png_const_structrp png_ptr, png_const_charp else png_chunk_error(png_ptr, error_message); + +# ifndef PNG_ERROR_TEXT_SUPPORTED + PNG_UNUSED(error_message) +# endif } #endif #endif /* PNG_READ_SUPPORTED */ @@ -513,6 +530,10 @@ png_chunk_benign_error(png_const_structrp png_ptr, png_const_charp void /* PRIVATE */ png_chunk_report(png_const_structrp png_ptr, png_const_charp message, int error) { +# ifndef PNG_WARNINGS_SUPPORTED + PNG_UNUSED(message) +# endif + /* This is always supported, but for just read or just write it * unconditionally does the right thing. */ diff --git a/pngmem.c b/pngmem.c index b9b3efb44..09c092a8a 100644 --- a/pngmem.c +++ b/pngmem.c @@ -73,9 +73,10 @@ png_malloc_base,(png_const_structrp png_ptr, png_alloc_size_t size), * to implement a user memory handler. This checks to be sure it isn't * called with big numbers. */ -#ifdef PNG_USER_MEM_SUPPORTED +#ifndef PNG_USER_MEM_SUPPORTED PNG_UNUSED(png_ptr) #endif + if (size > 0 && size <= PNG_SIZE_MAX # ifdef PNG_MAX_MALLOC_64K && size <= 65536U @@ -95,6 +96,8 @@ png_malloc_base,(png_const_structrp png_ptr, png_alloc_size_t size), return NULL; } +#if defined(PNG_TEXT_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) ||\ + defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED) /* This is really here only to work round a spurious warning in GCC 4.6 and 4.7 * that arises because of the checks in png_realloc_array that are repeated in * png_malloc_array. @@ -156,6 +159,7 @@ png_realloc_array,(png_const_structrp png_ptr, png_const_voidp old_array, return NULL; /* error */ } +#endif /* TEXT || sPLT || STORE_UNKNOWN_CHUNKS */ /* Various functions that have different error handling are derived from this. * png_malloc always exists, but if PNG_USER_MEM_SUPPORTED is defined a separate diff --git a/pngpriv.h b/pngpriv.h index 3f3ac313c..e3a1fe974 100644 --- a/pngpriv.h +++ b/pngpriv.h @@ -112,9 +112,15 @@ * typically the target FPU. If the FPU has been set to NEON (-mfpu=neon * with GCC) then the compiler will define __ARM_NEON__ and we can rely * unconditionally on NEON instructions not crashing, otherwise we must - * disable use of NEON instructions: + * disable use of NEON instructions. + * + * NOTE: at present these optimizations depend on 'ALIGNED_MEMORY', so they + * can only be turned on automatically if that is supported too. If + * PNG_ARM_NEON_OPT is set in CPPFLAGS (to >0) then arm/arm_init.c will fail + * to compile with an appropriate #error if ALIGNED_MEMORY has been turned + * off. */ -# ifdef __ARM_NEON__ +# if defined(__ARM_NEON__) && defined(PNG_ALIGNED_MEMORY_SUPPORTED) # define PNG_ARM_NEON_OPT 2 # else # define PNG_ARM_NEON_OPT 0 @@ -1898,7 +1904,7 @@ PNG_INTERNAL_FUNCTION(int,png_check_fp_string,(png_const_charp string, png_size_t size),PNG_EMPTY); #endif /* pCAL || sCAL */ -#if defined(PNG_READ_GAMMA_SUPPORTED) ||\ +#if defined(PNG_GAMMA_SUPPORTED) ||\ defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG_READ_pHYs_SUPPORTED) /* Added at libpng version 1.5.0 */ /* This is a utility to provide a*times/div (rounded) and indicate diff --git a/pngread.c b/pngread.c index 8f96ca23e..016704343 100644 --- a/pngread.c +++ b/pngread.c @@ -1125,12 +1125,11 @@ png_read_png(png_structrp png_ptr, png_inforp info_ptr, /* Arguments to png_image_finish_read: */ /* Encoding of PNG data (used by the color-map code) */ -/* TODO: change these, dang, ANSI-C reserves the 'E' namespace. */ -# define E_NOTSET 0 /* File encoding not yet known */ -# define E_sRGB 1 /* 8-bit encoded to sRGB gamma */ -# define E_LINEAR 2 /* 16-bit linear: not encoded, NOT pre-multiplied! */ -# define E_FILE 3 /* 8-bit encoded to file gamma, not sRGB or linear */ -# define E_LINEAR8 4 /* 8-bit linear: only from a file value */ +# define P_NOTSET 0 /* File encoding not yet known */ +# define P_sRGB 1 /* 8-bit encoded to sRGB gamma */ +# define P_LINEAR 2 /* 16-bit linear: not encoded, NOT pre-multiplied! */ +# define P_FILE 3 /* 8-bit encoded to file gamma, not sRGB or linear */ +# define P_LINEAR8 4 /* 8-bit linear: only from a file value */ /* Color-map processing: after libpng has run on the PNG image further * processing may be needed to conver the data to color-map indicies. @@ -1161,7 +1160,7 @@ typedef struct png_voidp first_row; ptrdiff_t row_bytes; /* step between rows */ int file_encoding; /* E_ values above */ - png_fixed_point gamma_to_linear; /* For E_FILE, reciprocal of gamma */ + png_fixed_point gamma_to_linear; /* For P_FILE, reciprocal of gamma */ int colormap_processing; /* PNG_CMAP_ values above */ } png_image_read_control; @@ -1293,7 +1292,7 @@ png_image_read_header(png_voidp argument) #ifdef PNG_COLORSPACE_SUPPORTED /* Does the colorspace match sRGB? If there is no color endpoint * (colorant) information assume yes, otherwise require the - * 'ENDPOINTS_MATCHE_sRGB' colorspace flag to have been set. If the + * 'ENDPOINTS_MATCHP_sRGB' colorspace flag to have been set. If the * colorspace has been determined to be invalid ignore it. */ if ((format & PNG_FORMAT_FLAG_COLOR) != 0 && ((png_ptr->colorspace.flags @@ -1482,17 +1481,24 @@ png_image_skip_unused_chunks(png_structrp png_ptr) * * Or image data handling: * - * tRNS, bKGD, gAMA, cHRM, sRGB, iCCP and sBIT. + * tRNS, bKGD, gAMA, cHRM, sRGB, [iCCP] and sBIT. * * This provides a small performance improvement and eliminates any * potential vulnerability to security problems in the unused chunks. + * + * At present the iCCP chunk data isn't used, so iCCP chunk can be ignored + * too. This allows the simplified API to be compiled without iCCP support, + * however if the support is there the chunk is still checked to detect + * errors (which are unfortunately quite common.) */ { static PNG_CONST png_byte chunks_to_process[] = { 98, 75, 71, 68, '\0', /* bKGD */ 99, 72, 82, 77, '\0', /* cHRM */ 103, 65, 77, 65, '\0', /* gAMA */ +# ifdef PNG_READ_iCCP_SUPPORTED 105, 67, 67, 80, '\0', /* iCCP */ +# endif 115, 66, 73, 84, '\0', /* sBIT */ 115, 82, 71, 66, '\0', /* sRGB */ }; @@ -1529,25 +1535,25 @@ set_file_encoding(png_image_read_control *display) { if (png_gamma_not_sRGB(g)) { - display->file_encoding = E_FILE; + display->file_encoding = P_FILE; display->gamma_to_linear = png_reciprocal(g); } else - display->file_encoding = E_sRGB; + display->file_encoding = P_sRGB; } else - display->file_encoding = E_LINEAR8; + display->file_encoding = P_LINEAR8; } static unsigned int decode_gamma(png_image_read_control *display, png_uint_32 value, int encoding) { - if (encoding == E_FILE) /* double check */ + if (encoding == P_FILE) /* double check */ encoding = display->file_encoding; - if (encoding == E_NOTSET) /* must be the file encoding */ + if (encoding == P_NOTSET) /* must be the file encoding */ { set_file_encoding(display); encoding = display->file_encoding; @@ -1555,18 +1561,18 @@ decode_gamma(png_image_read_control *display, png_uint_32 value, int encoding) switch (encoding) { - case E_FILE: + case P_FILE: value = png_gamma_16bit_correct(value*257, display->gamma_to_linear); break; - case E_sRGB: + case P_sRGB: value = png_sRGB_table[value]; break; - case E_LINEAR: + case P_LINEAR: break; - case E_LINEAR8: + case P_LINEAR8: value *= 257; break; @@ -1585,9 +1591,9 @@ png_colormap_compose(png_image_read_control *display, png_uint_32 background, int encoding) { /* The file value is composed on the background, the background has the given - * encoding and so does the result, the file is encoded with E_FILE and the + * encoding and so does the result, the file is encoded with P_FILE and the * file and alpha are 8-bit values. The (output) encoding will always be - * E_LINEAR or E_sRGB. + * P_LINEAR or P_sRGB. */ png_uint_32 f = decode_gamma(display, foreground, foreground_encoding); png_uint_32 b = decode_gamma(display, background, encoding); @@ -1597,7 +1603,7 @@ png_colormap_compose(png_image_read_control *display, */ f = f * alpha + b * (255-alpha); - if (encoding == E_LINEAR) + if (encoding == P_LINEAR) { /* Scale to 65535; divide by 255, approximately (in fact this is extremely * accurate, it divides by 255.00000005937181414556, with no overflow.) @@ -1607,13 +1613,13 @@ png_colormap_compose(png_image_read_control *display, f = (f+32768) >> 16; } - else /* E_sRGB */ + else /* P_sRGB */ f = PNG_sRGB_FROM_LINEAR(f); return f; } -/* NOTE: E_LINEAR values to this routine must be 16-bit, but E_FILE values must +/* NOTE: P_LINEAR values to this routine must be 16-bit, but P_FILE values must * be 8-bit. */ static void @@ -1623,7 +1629,7 @@ png_create_colormap_entry(png_image_read_control *display, { png_imagep image = display->image; const int output_encoding = (image->format & PNG_FORMAT_FLAG_LINEAR) ? - E_LINEAR : E_sRGB; + P_LINEAR : P_sRGB; const int convert_to_Y = (image->format & PNG_FORMAT_FLAG_COLOR) == 0 && (red != green || green != blue); @@ -1633,18 +1639,18 @@ png_create_colormap_entry(png_image_read_control *display, /* Update the cache with whether the file gamma is significantly different * from sRGB. */ - if (encoding == E_FILE) + if (encoding == P_FILE) { - if (display->file_encoding == E_NOTSET) + if (display->file_encoding == P_NOTSET) set_file_encoding(display); - /* Note that the cached value may be E_FILE too, but if it is then the + /* Note that the cached value may be P_FILE too, but if it is then the * gamma_to_linear member has been set. */ encoding = display->file_encoding; } - if (encoding == E_FILE) + if (encoding == P_FILE) { png_fixed_point g = display->gamma_to_linear; @@ -1652,10 +1658,10 @@ png_create_colormap_entry(png_image_read_control *display, green = png_gamma_16bit_correct(green*257, g); blue = png_gamma_16bit_correct(blue*257, g); - if (convert_to_Y || output_encoding == E_LINEAR) + if (convert_to_Y || output_encoding == P_LINEAR) { alpha *= 257; - encoding = E_LINEAR; + encoding = P_LINEAR; } else @@ -1663,11 +1669,11 @@ png_create_colormap_entry(png_image_read_control *display, red = PNG_sRGB_FROM_LINEAR(red * 255); green = PNG_sRGB_FROM_LINEAR(green * 255); blue = PNG_sRGB_FROM_LINEAR(blue * 255); - encoding = E_sRGB; + encoding = P_sRGB; } } - else if (encoding == E_LINEAR8) + else if (encoding == P_LINEAR8) { /* This encoding occurs quite frequently in test cases because PngSuite * includes a gAMA 1.0 chunk with most images. @@ -1676,10 +1682,10 @@ png_create_colormap_entry(png_image_read_control *display, green *= 257; blue *= 257; alpha *= 257; - encoding = E_LINEAR; + encoding = P_LINEAR; } - else if (encoding == E_sRGB && (convert_to_Y || output_encoding == E_LINEAR)) + else if (encoding == P_sRGB && (convert_to_Y || output_encoding == P_LINEAR)) { /* The values are 8-bit sRGB values, but must be converted to 16-bit * linear. @@ -1688,11 +1694,11 @@ png_create_colormap_entry(png_image_read_control *display, green = png_sRGB_table[green]; blue = png_sRGB_table[blue]; alpha *= 257; - encoding = E_LINEAR; + encoding = P_LINEAR; } /* This is set if the color isn't gray but the output is. */ - if (encoding == E_LINEAR) + if (encoding == P_LINEAR) { if (convert_to_Y) { @@ -1700,7 +1706,7 @@ png_create_colormap_entry(png_image_read_control *display, png_uint_32 y = (png_uint_32)6968 * red + (png_uint_32)23434 * green + (png_uint_32)2366 * blue; - if (output_encoding == E_LINEAR) + if (output_encoding == P_LINEAR) y = (y + 16384) >> 15; else @@ -1709,19 +1715,19 @@ png_create_colormap_entry(png_image_read_control *display, y = (y + 128) >> 8; y *= 255; y = PNG_sRGB_FROM_LINEAR((y + 64) >> 7); - encoding = E_sRGB; + encoding = P_sRGB; } blue = red = green = y; } - else if (output_encoding == E_sRGB) + else if (output_encoding == P_sRGB) { red = PNG_sRGB_FROM_LINEAR(red * 255); green = PNG_sRGB_FROM_LINEAR(green * 255); blue = PNG_sRGB_FROM_LINEAR(blue * 255); alpha = PNG_DIV257(alpha); - encoding = E_sRGB; + encoding = P_sRGB; } } @@ -1730,7 +1736,7 @@ png_create_colormap_entry(png_image_read_control *display, /* Store the value. */ { -# ifdef PNG_FORMAT_BGR_SUPPORTED +# ifdef PNG_FORMAT_AFIRST_SUPPORTED const int afirst = (image->format & PNG_FORMAT_FLAG_AFIRST) != 0 && (image->format & PNG_FORMAT_FLAG_ALPHA) != 0; # else @@ -1742,7 +1748,7 @@ png_create_colormap_entry(png_image_read_control *display, # define bgr 0 # endif - if (output_encoding == E_LINEAR) + if (output_encoding == P_LINEAR) { png_uint_16p entry = png_voidcast(png_uint_16p, display->colormap); @@ -1797,7 +1803,7 @@ png_create_colormap_entry(png_image_read_control *display, } } - else /* output encoding is E_sRGB */ + else /* output encoding is P_sRGB */ { png_bytep entry = png_voidcast(png_bytep, display->colormap); @@ -1839,7 +1845,7 @@ make_gray_file_colormap(png_image_read_control *display) unsigned int i; for (i=0; i<256; ++i) - png_create_colormap_entry(display, i, i, i, i, 255, E_FILE); + png_create_colormap_entry(display, i, i, i, i, 255, P_FILE); return i; } @@ -1850,7 +1856,7 @@ make_gray_colormap(png_image_read_control *display) unsigned int i; for (i=0; i<256; ++i) - png_create_colormap_entry(display, i, i, i, i, 255, E_sRGB); + png_create_colormap_entry(display, i, i, i, i, 255, P_sRGB); return i; } @@ -1889,13 +1895,13 @@ make_ga_colormap(png_image_read_control *display) while (i < 231) { unsigned int gray = (i * 256 + 115) / 231; - png_create_colormap_entry(display, i++, gray, gray, gray, 255, E_sRGB); + png_create_colormap_entry(display, i++, gray, gray, gray, 255, P_sRGB); } /* 255 is used here for the component values for consistency with the code * that undoes premultiplication in pngwrite.c. */ - png_create_colormap_entry(display, i++, 255, 255, 255, 0, E_sRGB); + png_create_colormap_entry(display, i++, 255, 255, 255, 0, P_sRGB); for (a=1; a<5; ++a) { @@ -1903,7 +1909,7 @@ make_ga_colormap(png_image_read_control *display) for (g=0; g<6; ++g) png_create_colormap_entry(display, i++, g*51, g*51, g*51, a*51, - E_sRGB); + P_sRGB); } return i; @@ -1927,7 +1933,7 @@ make_rgb_colormap(png_image_read_control *display) for (b=0; b<6; ++b) png_create_colormap_entry(display, i++, r*51, g*51, b*51, 255, - E_sRGB); + P_sRGB); } } @@ -1950,11 +1956,11 @@ png_image_read_colormap(png_voidp argument) const png_structrp png_ptr = image->opaque->png_ptr; const png_uint_32 output_format = image->format; const int output_encoding = (output_format & PNG_FORMAT_FLAG_LINEAR) ? - E_LINEAR : E_sRGB; + P_LINEAR : P_sRGB; unsigned int cmap_entries; unsigned int output_processing; /* Output processing option */ - unsigned int data_encoding = E_NOTSET; /* Encoding libpng must produce */ + unsigned int data_encoding = P_NOTSET; /* Encoding libpng must produce */ /* Background information; the background color and the index of this color * in the color-map if it exists (else 256). @@ -1974,7 +1980,7 @@ png_image_read_colormap(png_voidp argument) png_ptr->num_trans > 0) /* alpha in input */ && ((output_format & PNG_FORMAT_FLAG_ALPHA) == 0) /* no alpha in output */) { - if (output_encoding == E_LINEAR) /* compose on black */ + if (output_encoding == P_LINEAR) /* compose on black */ back_b = back_g = back_r = 0; else if (display->background == NULL /* no way to remove it */) @@ -1998,7 +2004,7 @@ png_image_read_colormap(png_voidp argument) } } - else if (output_encoding == E_LINEAR) + else if (output_encoding == P_LINEAR) back_b = back_r = back_g = 65535; else @@ -2056,7 +2062,7 @@ png_image_read_colormap(png_voidp argument) trans = png_ptr->trans_color.gray; if ((output_format & PNG_FORMAT_FLAG_ALPHA) == 0) - back_alpha = output_encoding == E_LINEAR ? 65535 : 255; + back_alpha = output_encoding == P_LINEAR ? 65535 : 255; } /* png_create_colormap_entry just takes an RGBA and writes the @@ -2074,7 +2080,7 @@ png_image_read_colormap(png_voidp argument) */ if (i != trans) png_create_colormap_entry(display, i, val, val, val, 255, - E_FILE/*8-bit with file gamma*/); + P_FILE/*8-bit with file gamma*/); /* Else this entry is transparent. The colors don't matter if * there is an alpha channel (back_alpha == 0), but it does no @@ -2090,7 +2096,7 @@ png_image_read_colormap(png_voidp argument) } /* We need libpng to preserve the original encoding. */ - data_encoding = E_FILE; + data_encoding = P_FILE; /* The rows from libpng, while technically gray values, are now also * color-map indicies; however, they may need to be expanded to 1 @@ -2119,7 +2125,7 @@ png_image_read_colormap(png_voidp argument) * ensuring that the corresponding gray level matches the background * color exactly. */ - data_encoding = E_sRGB; + data_encoding = P_sRGB; if (PNG_GRAY_COLORMAP_ENTRIES > image->colormap_entries) png_error(png_ptr, "gray[16] color-map: too few entries"); @@ -2143,7 +2149,7 @@ png_image_read_colormap(png_voidp argument) png_color_16 c; png_uint_32 gray = back_g; - if (output_encoding == E_LINEAR) + if (output_encoding == P_LINEAR) { gray = PNG_sRGB_FROM_LINEAR(gray * 255); @@ -2151,7 +2157,7 @@ png_image_read_colormap(png_voidp argument) * matches. */ png_create_colormap_entry(display, gray, back_g, back_g, - back_g, 65535, E_LINEAR); + back_g, 65535, P_LINEAR); } /* The background passed to libpng, however, must be the @@ -2172,7 +2178,7 @@ png_image_read_colormap(png_voidp argument) break; } - back_alpha = output_encoding == E_LINEAR ? 65535 : 255; + back_alpha = output_encoding == P_LINEAR ? 65535 : 255; } /* output_processing means that the libpng-processed row will be @@ -2209,7 +2215,7 @@ png_image_read_colormap(png_voidp argument) * worry about tRNS matching - tRNS is ignored if there is an alpha * channel. */ - data_encoding = E_sRGB; + data_encoding = P_sRGB; if (output_format & PNG_FORMAT_FLAG_ALPHA) { @@ -2252,13 +2258,13 @@ png_image_read_colormap(png_voidp argument) cmap_entries = make_gray_colormap(display); - if (output_encoding == E_LINEAR) + if (output_encoding == P_LINEAR) { gray = PNG_sRGB_FROM_LINEAR(gray * 255); /* And make sure the corresponding palette entry matches. */ png_create_colormap_entry(display, gray, back_g, back_g, - back_g, 65535, E_LINEAR); + back_g, 65535, P_LINEAR); } /* The background passed to libpng, however, must be the sRGB @@ -2289,7 +2295,7 @@ png_image_read_colormap(png_voidp argument) { png_uint_32 gray = (i * 256 + 115) / 231; png_create_colormap_entry(display, i++, gray, gray, gray, - 255, E_sRGB); + 255, P_sRGB); } /* NOTE: this preserves the full precision of the application @@ -2297,7 +2303,7 @@ png_image_read_colormap(png_voidp argument) */ background_index = i; png_create_colormap_entry(display, i++, back_r, back_g, back_b, - output_encoding == E_LINEAR ? 65535U : 255U, output_encoding); + output_encoding == P_LINEAR ? 65535U : 255U, output_encoding); /* For non-opaque input composite on the sRGB background - this * requires inverting the encoding for each component. The input @@ -2307,7 +2313,7 @@ png_image_read_colormap(png_voidp argument) * represents. Consequently 'G' is always sRGB encoded, while * 'A' is linear. We need the linear background colors. */ - if (output_encoding == E_sRGB) /* else already linear */ + if (output_encoding == P_sRGB) /* else already linear */ { /* This may produce a value not exactly matching the * background, but that's ok because these numbers are only @@ -2337,7 +2343,7 @@ png_image_read_colormap(png_voidp argument) png_create_colormap_entry(display, i++, PNG_sRGB_FROM_LINEAR(gray + back_rx), PNG_sRGB_FROM_LINEAR(gray + back_gx), - PNG_sRGB_FROM_LINEAR(gray + back_bx), 255, E_sRGB); + PNG_sRGB_FROM_LINEAR(gray + back_bx), 255, P_sRGB); } } @@ -2364,7 +2370,7 @@ png_image_read_colormap(png_voidp argument) */ png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE, -1, -1); - data_encoding = E_sRGB; + data_encoding = P_sRGB; /* The output will now be one or two 8-bit gray or gray+alpha * channels. The more complex case arises when the input has alpha. @@ -2409,7 +2415,7 @@ png_image_read_colormap(png_voidp argument) png_gamma_not_sRGB(png_ptr->colorspace.gamma)) { cmap_entries = make_gray_file_colormap(display); - data_encoding = E_FILE; + data_encoding = P_FILE; } else @@ -2428,18 +2434,18 @@ png_image_read_colormap(png_voidp argument) * it. Achieve this simply by ensuring that the entry * selected for the background really is the background color. */ - if (data_encoding == E_FILE) /* from the fixup above */ + if (data_encoding == P_FILE) /* from the fixup above */ { /* The app supplied a gray which is in output_encoding, we - * need to convert it to a value of the input (E_FILE) + * need to convert it to a value of the input (P_FILE) * encoding then set this palette entry to the required * output encoding. */ - if (output_encoding == E_sRGB) - gray = png_sRGB_table[gray]; /* now E_LINEAR */ + if (output_encoding == P_sRGB) + gray = png_sRGB_table[gray]; /* now P_LINEAR */ gray = PNG_DIV257(png_gamma_16bit_correct(gray, - png_ptr->colorspace.gamma)); /* now E_FILE */ + png_ptr->colorspace.gamma)); /* now P_FILE */ /* And make sure the corresponding palette entry contains * exactly the required sRGB value. @@ -2448,14 +2454,14 @@ png_image_read_colormap(png_voidp argument) back_g, 0/*unused*/, output_encoding); } - else if (output_encoding == E_LINEAR) + else if (output_encoding == P_LINEAR) { gray = PNG_sRGB_FROM_LINEAR(gray * 255); /* And make sure the corresponding palette entry matches. */ png_create_colormap_entry(display, gray, back_g, back_g, - back_g, 0/*unused*/, E_LINEAR); + back_g, 0/*unused*/, P_LINEAR); } /* The background passed to libpng, however, must be the @@ -2485,7 +2491,7 @@ png_image_read_colormap(png_voidp argument) * to do it once and using PNG_DIV51 on the 6x6x6 reduced RGB cube. * Consequently we always want libpng to produce sRGB data. */ - data_encoding = E_sRGB; + data_encoding = P_sRGB; /* Is there any transparency or alpha? */ if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA || @@ -2505,7 +2511,7 @@ png_image_read_colormap(png_voidp argument) /* Add a transparent entry. */ png_create_colormap_entry(display, cmap_entries, 255, 255, - 255, 0, E_sRGB); + 255, 0, P_sRGB); /* This is stored as the background index for the processing * algorithm. @@ -2526,7 +2532,7 @@ png_image_read_colormap(png_voidp argument) */ for (b=0; b<256; b = (b << 1) | 0x7f) png_create_colormap_entry(display, cmap_entries++, - r, g, b, 128, E_sRGB); + r, g, b, 128, P_sRGB); } } @@ -2555,7 +2561,7 @@ png_image_read_colormap(png_voidp argument) png_create_colormap_entry(display, cmap_entries, back_r, back_g, back_b, 0/*unused*/, output_encoding); - if (output_encoding == E_LINEAR) + if (output_encoding == P_LINEAR) { r = PNG_sRGB_FROM_LINEAR(back_r * 255); g = PNG_sRGB_FROM_LINEAR(back_g * 255); @@ -2595,11 +2601,11 @@ png_image_read_colormap(png_voidp argument) */ for (b=0; b<256; b = (b << 1) | 0x7f) png_create_colormap_entry(display, cmap_entries++, - png_colormap_compose(display, r, E_sRGB, 128, + png_colormap_compose(display, r, P_sRGB, 128, back_r, output_encoding), - png_colormap_compose(display, g, E_sRGB, 128, + png_colormap_compose(display, g, P_sRGB, 128, back_g, output_encoding), - png_colormap_compose(display, b, E_sRGB, 128, + png_colormap_compose(display, b, P_sRGB, 128, back_b, output_encoding), 0/*unused*/, output_encoding); } @@ -2658,7 +2664,7 @@ png_image_read_colormap(png_voidp argument) num_trans = 0; output_processing = PNG_CMAP_NONE; - data_encoding = E_FILE; /* Don't change from color-map indicies */ + data_encoding = P_FILE; /* Don't change from color-map indicies */ cmap_entries = png_ptr->num_palette; if (cmap_entries > 256) cmap_entries = 256; @@ -2680,13 +2686,13 @@ png_image_read_colormap(png_voidp argument) * on the sRGB color in 'back'. */ png_create_colormap_entry(display, i, - png_colormap_compose(display, colormap[i].red, E_FILE, + png_colormap_compose(display, colormap[i].red, P_FILE, trans[i], back_r, output_encoding), - png_colormap_compose(display, colormap[i].green, E_FILE, + png_colormap_compose(display, colormap[i].green, P_FILE, trans[i], back_g, output_encoding), - png_colormap_compose(display, colormap[i].blue, E_FILE, + png_colormap_compose(display, colormap[i].blue, P_FILE, trans[i], back_b, output_encoding), - output_encoding == E_LINEAR ? trans[i] * 257U : + output_encoding == P_LINEAR ? trans[i] * 257U : trans[i], output_encoding); } @@ -2695,7 +2701,7 @@ png_image_read_colormap(png_voidp argument) else png_create_colormap_entry(display, i, colormap[i].red, colormap[i].green, colormap[i].blue, - i < num_trans ? trans[i] : 255U, E_FILE/*8-bit*/); + i < num_trans ? trans[i] : 255U, P_FILE/*8-bit*/); } /* The PNG data may have indicies packed in fewer than 8 bits, it @@ -2723,12 +2729,12 @@ png_image_read_colormap(png_voidp argument) png_error(png_ptr, "bad data option (internal error)"); break; - case E_sRGB: + case P_sRGB: /* Change to 8-bit sRGB */ png_set_alpha_mode_fixed(png_ptr, PNG_ALPHA_PNG, PNG_GAMMA_sRGB); /* FALL THROUGH */ - case E_FILE: + case P_FILE: if (png_ptr->bit_depth > 8) png_set_scale_16(png_ptr); break; @@ -3277,7 +3283,12 @@ png_image_read_background(png_voidp argument) png_error(png_ptr, "unknown interlace type"); } - switch (png_get_bit_depth(png_ptr, info_ptr)) + /* Use direct access to info_ptr here because otherwise the simplified API + * would require PNG_EASY_ACCESS_SUPPORTED (just for this.) Note this is + * checking the value after libpng expansions, not the original value in the + * PNG. + */ + switch (info_ptr->bit_depth) { default: png_error(png_ptr, "unexpected bit depth"); @@ -3425,8 +3436,10 @@ png_image_read_background(png_voidp argument) unsigned int outchannels = 1+preserve_alpha; int swap_alpha = 0; - if (preserve_alpha && (image->format & PNG_FORMAT_FLAG_AFIRST)) - swap_alpha = 1; +# ifdef PNG_SIMPLIFIED_READ_AFIRST_SUPPORTED + if (preserve_alpha && (image->format & PNG_FORMAT_FLAG_AFIRST)) + swap_alpha = 1; +# endif for (pass = 0; pass < passes; ++pass) { diff --git a/pngwio.c b/pngwio.c index e3289dfe4..ee1d06f18 100644 --- a/pngwio.c +++ b/pngwio.c @@ -149,6 +149,8 @@ png_set_write_fn(png_structrp png_ptr, png_voidp io_ptr, # else png_ptr->output_flush_fn = output_flush_fn; # endif +#else + PNG_UNUSED(output_flush_fn) #endif /* PNG_WRITE_FLUSH_SUPPORTED */ /* It is an error to read while writing a png file */ diff --git a/pngwrite.c b/pngwrite.c index b71a3d345..7ad8ea078 100644 --- a/pngwrite.c +++ b/pngwrite.c @@ -1638,14 +1638,16 @@ png_write_image_16bit(png_voidp argument) if (image->format & PNG_FORMAT_FLAG_ALPHA) { - if (image->format & PNG_FORMAT_FLAG_AFIRST) - { - aindex = -1; - ++input_row; /* To point to the first component */ - ++output_row; - } +# ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED + if (image->format & PNG_FORMAT_FLAG_AFIRST) + { + aindex = -1; + ++input_row; /* To point to the first component */ + ++output_row; + } - else + else +# endif aindex = channels; } @@ -1794,14 +1796,16 @@ png_write_image_8bit(png_voidp argument) png_bytep row_end; int aindex; - if (image->format & PNG_FORMAT_FLAG_AFIRST) - { - aindex = -1; - ++input_row; /* To point to the first component */ - ++output_row; - } +# ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED + if (image->format & PNG_FORMAT_FLAG_AFIRST) + { + aindex = -1; + ++input_row; /* To point to the first component */ + ++output_row; + } - else + else +# endif aindex = channels; /* Use row_end in place of a loop counter: */ @@ -1881,7 +1885,8 @@ png_image_set_PLTE(png_image_write_control *display) const png_uint_32 format = image->format; const int channels = PNG_IMAGE_SAMPLE_CHANNELS(format); -# ifdef PNG_FORMAT_BGR_SUPPORTED +# if defined(PNG_FORMAT_BGR_SUPPORTED) &&\ + defined(PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED) const int afirst = (format & PNG_FORMAT_FLAG_AFIRST) != 0 && (format & PNG_FORMAT_FLAG_ALPHA) != 0; # else diff --git a/scripts/options.awk b/scripts/options.awk index c3a850173..9aff15db2 100755 --- a/scripts/options.awk +++ b/scripts/options.awk @@ -282,7 +282,7 @@ $1 == "option" && NF >= 2{ for (i=istart; i<=NF; ++i) { val=$(i) sub(/,$/,"",val) - if (val == "on" || val == "off" || val == "disabled") { + if (val == "on" || val == "off" || val == "disabled" || val =="enabled") { key = "" if (onoff != val) { # on or off can zap disabled or enabled: @@ -687,9 +687,11 @@ END{ } # if + have_ifs = 0 nreqs = split(iffs[i], r) print "#undef PNG_no_if" >out if (nreqs > 0) { + have_ifs = 1 print "/* if" iffs[i], "*/" >out print "#define PNG_no_if 1" >out for (j=1; j<=nreqs; ++j) { @@ -727,7 +729,10 @@ END{ print "# ifndef PNG_" i "_SUPPORTED /*!command line*/" >out print "# ifdef PNG_not_enabled /*!enabled*/" >out - if (option[i] == "off" || option[i] == "disabled" && everything != "on" || option[i] == "enabled" && everything == "off") { + # 'have_ifs' here means that everything = "off" still allows an 'if' on + # an otherwise enabled option to turn it on; otherwise the 'if' + # handling is effectively disabled by 'everything = off' + if (option[i] == "off" || option[i] == "disabled" && everything != "on" || option[i] == "enabled" && everything == "off" && !have_ifs) { print "# undef PNG_on /*default off*/" >out } else { print "# ifdef PNG_NO_" i >out diff --git a/scripts/pnglibconf.dfa b/scripts/pnglibconf.dfa index 2482e14ed..0e98058fa 100755 --- a/scripts/pnglibconf.dfa +++ b/scripts/pnglibconf.dfa @@ -294,12 +294,16 @@ option BENIGN_READ_ERRORS requires BENIGN_ERRORS option MNG_FEATURES # Arithmetic options, the first is the big switch that chooses between internal -# floating and fixed point arithmetic implementations - it does not affect any +# floating and fixed point arithmetic implementations - it does not affect an # APIs. The second two (the _POINT settings) switch off individual APIs. +# +# Prior to libpng 1.6.8 one of the API (_POINT) variants had to be selected. At +# 1.6.8 this restriction has been removed; the simplified API can be used +# without enabling any of the low level fixed/floating APIs. option FLOATING_ARITHMETIC -option FLOATING_POINT enables ok_math -option FIXED_POINT enables ok_math +option FLOATING_POINT +option FIXED_POINT # The following is always on (defined empty) @@ -435,7 +439,7 @@ option READ_TRANSFORMS requires READ # If you handle gamma issues outside libpng then you do not need the libpng # gamma processing; and it is an enormous waste of space. You just need to # remove the use of libpng APIs that depend on it. -option READ_GAMMA requires READ_TRANSFORMS, READ_gAMA +option READ_GAMMA requires READ_TRANSFORMS, READ_gAMA, READ_sRGB option READ_ALPHA_MODE requires READ_TRANSFORMS, READ_GAMMA option READ_BACKGROUND requires READ_TRANSFORMS, READ_STRIP_ALPHA, READ_GAMMA @@ -448,7 +452,7 @@ option READ_INVERT_ALPHA requires READ_TRANSFORMS option READ_INVERT requires READ_TRANSFORMS option READ_PACK requires READ_TRANSFORMS option READ_PACKSWAP requires READ_TRANSFORMS -option READ_RGB_TO_GRAY requires READ_TRANSFORMS, READ_GAMMA +option READ_RGB_TO_GRAY requires READ_TRANSFORMS, READ_GAMMA enables COLORSPACE option READ_SCALE_16_TO_8 requires READ_TRANSFORMS option READ_SHIFT requires READ_TRANSFORMS option READ_STRIP_16_TO_8 requires READ_TRANSFORMS @@ -805,13 +809,13 @@ option SAVE_INT_32 disabled option WRITE_OPTIMIZE_CMF requires WRITE option READ_COMPRESSED_TEXT disabled -option READ_iCCP enables READ_COMPRESSED_TEXT option READ_iTXt enables READ_COMPRESSED_TEXT option READ_zTXt enables READ_COMPRESSED_TEXT option READ_COMPRESSED_TEXT enables READ_TEXT option WRITE_oFFs enables SAVE_INT_32 option WRITE_pCAL enables SAVE_INT_32 +option WRITE_cHRM enables SAVE_INT_32 option WRITE_COMPRESSED_TEXT disabled option WRITE_iCCP enables WRITE_COMPRESSED_TEXT @@ -839,30 +843,44 @@ option READ_GET_PALETTE_MAX requires READ_CHECK_FOR_INVALID_INDEX disabled option WRITE_GET_PALETTE_MAX requires WRITE_CHECK_FOR_INVALID_INDEX disabled # Simplified API options (added at libpng-1.6.0) +# In libpng 1.6.8 the handling of these options was changed to used 'requires' +# throughout, so that disabling some of the low level support always disables +# the base simplified read/write API. This much simplifies the handling and +# makes 'everything = off' work in a more intuitive way. It eliminates a +# previously reported feature that APIs previously enabled by the simplified +# API couldn't be turned off without explicitly turning off the simplified +# APIs. +# # Read: option SIMPLIFIED_READ, - requires SEQUENTIAL_READ, READ_TRANSFORMS, SETJMP, BENIGN_ERRORS READ_GAMMA, - enables READ_EXPAND, READ_16BIT READ_EXPAND_16, READ_SCALE_16_TO_8, - READ_RGB_TO_GRAY, READ_ALPHA_MODE READ_BACKGROUND READ_STRIP_ALPHA, - READ_FILLER, READ_SWAP + requires SEQUENTIAL_READ, READ_TRANSFORMS, SETJMP, BENIGN_ERRORS, + READ_EXPAND, READ_16BIT, READ_EXPAND_16, READ_SCALE_16_TO_8, + READ_RGB_TO_GRAY, READ_ALPHA_MODE, READ_BACKGROUND, READ_STRIP_ALPHA, + READ_FILLER, READ_SWAP, READ_PACK, READ_GRAY_TO_RGB, READ_GAMMA, + READ_tRNS, READ_bKGD, READ_gAMA, READ_cHRM, READ_sRGB, READ_sBIT -option SIMPLIFIED_READ_AFIRST requires SIMPLIFIED_READ disabled -option READ_SWAP_ALPHA enables SIMPLIFIED_READ_AFIRST +# AFIRST and BGR read options: +# Prior to libpng 1.6.8 these were disabled but switched on if the low level +# libpng routines that do the swaps were enabled. This worked but was +# confusing. In libpng 1.6.8 the options were changed to simple 'requires' +# and are enabled by default. This should work the same way in practice. +option SIMPLIFIED_READ_AFIRST enables FORMAT_AFIRST, + requires SIMPLIFIED_READ READ_SWAP_ALPHA -option SIMPLIFIED_READ_BGR requires SIMPLIFIED_READ disabled -option READ_BGR enables SIMPLIFIED_READ_BGR +option SIMPLIFIED_READ_BGR enables FORMAT_BGR, + requires SIMPLIFIED_READ READ_BGR # Write: option SIMPLIFIED_WRITE, - requires WRITE STDIO, SETJMP, - enables WRITE_SWAP WRITE_gAMA, WRITE_sRGB WRITE_cHRM + requires WRITE STDIO, SETJMP, WRITE_SWAP, WRITE_PACK, + WRITE_tRNS, WRITE_gAMA, WRITE_sRGB, WRITE_cHRM -option SIMPLIFIED_WRITE_AFIRST requires SIMPLIFIED_WRITE disabled -option WRITE_SWAP_ALPHA enables SIMPLIFIED_WRITE_AFIRST +option SIMPLIFIED_WRITE_AFIRST enables FORMAT_AFIRST, + requires SIMPLIFIED_WRITE WRITE_SWAP_ALPHA -option SIMPLIFIED_WRITE_BGR requires SIMPLIFIED_WRITE disabled -option WRITE_BGR enables SIMPLIFIED_WRITE_BGR +option SIMPLIFIED_WRITE_BGR enables FORMAT_BGR, + requires SIMPLIFIED_WRITE WRITE_BGR # Formats: -option FORMAT_AFIRST if SIMPLIFIED_READ_AFIRST, SIMPLIFIED_WRITE_AFIRST -option FORMAT_BGR if SIMPLIFIED_READ_BGR, SIMPLIFIED_WRITE_BGR +option FORMAT_AFIRST disabled +option FORMAT_BGR disabled