shithub: rgbds

--- /dev/null

+++ b/src/gfx/libpng/ANNOUNCE

@@ -1,0 +1,32 @@

+Libpng 1.2.8 - December 3, 2004

+This is a public release of libpng, intended for use in production codes.

+Changes since the last public release (1.2.7):

+  Fixed bug in png_text_compress() that would fail to complete a large block.

+  Fixed bug, introduced in libpng-1.2.7, that overruns a buffer during

+    strip alpha operation in png_do_strip_filler().

+  Added PNG_1_2_X definition in pngconf.h

+  #ifdef out png_info_init in png.c and png_read_init in pngread.c (as of 1.3.0)

+  Reduce color_type to a nonalpha type after strip alpha operation in

+    png_do_strip_filler().

+  Revised definitions of PNG_MAX_UINT_32, PNG_MAX_SIZE, and PNG_MAXSUM

+  Fixed (again) definition of PNG_LIBPNG_VER_DLLNUM in png.h (Cosmin).

+  Added PNG_LIBPNG_BUILD_PRIVATE in png.h (Cosmin).

+  Set png_ptr->zstream.data_type to Z_BINARY, to avoid unnecessary detection

+    of data type in deflate (Cosmin).

+  Deprecated but continue to support SPECIALBUILD and PRIVATEBUILD in favor of

+    PNG_LIBPNG_BUILD_SPECIAL_STRING and PNG_LIBPNG_BUILD_PRIVATE_STRING.

+  Despammed mailing addresses by masking "@" with "at".

+  Added scripts/makefile.elf with supporting code in pngconf.h for symbol

+    versioning (John Bowler).

+  Added projects/visualc71 (Simon-pierre).

+Send comments/corrections/commendations to

+png-implement at ccrc.wustl.edu (subscription required; write to

+majordomo at ccrc.wustl.edu with "subscribe png-implement" in the message)

+or to glennrp at users.sourceforge.net

+Glenn R-P

--- /dev/null

+++ b/src/gfx/libpng/CHANGES

@@ -1,0 +1,1419 @@

+CHANGES - changes for libpng

+version 0.2

+  added reader into png.h

+  fixed small problems in stub file

+version 0.3

+  added pull reader

+  split up pngwrite.c to several files

+  added pnglib.txt

+  added example.c

+  cleaned up writer, adding a few new tranformations

+  fixed some bugs in writer

+  interfaced with zlib 0.5

+  added K&R support

+  added check for 64 KB blocks for 16 bit machines

+version 0.4

+  cleaned up code and commented code

+  simplified time handling into png_time

+  created png_color_16 and png_color_8 to handle color needs

+  cleaned up color type defines

+  fixed various bugs

+  made various names more consistant

+  interfaced with zlib 0.71

+  cleaned up zTXt reader and writer (using zlib's Reset functions)

+  split transformations into pngrtran.c and pngwtran.c

+version 0.5

+  interfaced with zlib 0.8

+  fixed many reading and writing bugs

+  saved using 3 spaces instead of tabs

+version 0.6

+  added png_large_malloc() and png_large_free()

+  added png_size_t

+  cleaned up some compiler warnings

+  added png_start_read_image()

+version 0.7

+  cleaned up lots of bugs

+  finished dithering and other stuff

+  added test program

+  changed name from pnglib to libpng

+version 0.71 [June, 1995]

+  changed pngtest.png for zlib 0.93

+  fixed error in libpng.txt and example.c

+version 0.8

+  cleaned up some bugs

+  added png_set_filler()

+  split up pngstub.c into pngmem.c, pngio.c, and pngerror.c

+  added #define's to remove unwanted code

+  moved png_info_init() to png.c

+  added old_size into png_realloc()

+  added functions to manually set filtering and compression info

+  changed compression parameters based on image type

+  optimized filter selection code

+  added version info

+  changed external functions passing floats to doubles (k&r problems?)

+  put all the configurable stuff in pngconf.h

+  enabled png_set_shift to work with paletted images on read

+  added png_read_update_info() - updates info structure with

+     transformations

+version 0.81 [August, 1995]

+  incorporated Tim Wegner's medium model code (thanks, Tim)

+version 0.82 [September, 1995]

+  [unspecified changes]

+version 0.85 [December, 1995]

+  added more medium model code (almost everything's a far)

+  added i/o, error, and memory callback functions

+  fixed some bugs (16 bit, 4 bit interlaced, etc.)

+  added first run progressive reader (barely tested)

+version 0.86 [January, 1996]

+  fixed bugs

+  improved documentation

+version 0.87 [January, 1996]

+  fixed medium model bugs

+  fixed other bugs introduced in 0.85 and 0.86

+  added some minor documentation

+version 0.88 [January, 1996]

+  fixed progressive bugs

+  replaced tabs with spaces

+  cleaned up documentation

+  added callbacks for read/write and warning/error functions

+version 0.89 [July, 1996]

+  added new initialization API to make libpng work better with shared libs

+     we now have png_create_read_struct(), png_create_write_struct(),

+     png_create_info_struct(), png_destroy_read_struct(), and

+     png_destroy_write_struct() instead of the separate calls to

+     malloc and png_read_init(), png_info_init(), and png_write_init()

+  changed warning/error callback functions to fix bug - this means you

+     should use the new initialization API if you were using the old

+     png_set_message_fn() calls, and that the old API no longer exists

+     so that people are aware that they need to change their code

+  changed filter selection API to allow selection of multiple filters

+     since it didn't work in previous versions of libpng anyways

+  optimized filter selection code

+  fixed png_set_background() to allow using an arbitrary RGB color for

+     paletted images

+  fixed gamma and background correction for paletted images, so

+     png_correct_palette is not needed unless you are correcting an

+     external palette (you will need to #define PNG_CORRECT_PALETTE_SUPPORTED

+     in pngconf.h) - if nobody uses this, it may disappear in the future.

+  fixed bug with Borland 64K memory allocation (Alexander Lehmann)

+  fixed bug in interlace handling (Smarasderagd, I think)

+  added more error checking for writing and image to reduce invalid files

+  separated read and write functions so that they won't both be linked

+     into a binary when only reading or writing functionality is used

+  new pngtest image also has interlacing and zTXt

+  updated documentation to reflect new API

+version 0.90 [January, 1997]

+  made CRC errors/warnings on critical and ancillary chunks configurable

+  libpng will use the zlib CRC routines by (compile-time) default

+  changed DOS small/medium model memory support - needs zlib 1.04 (Tim Wegner)

+  added external C++ wrapper statements to png.h (Gilles Dauphin)

+  allow PNG file to be read when some or all of file signature has already

+     been read from the beginning of the stream.  ****This affects the size

+     of info_struct and invalidates all programs that use a shared libpng****

+  fixed png_filler() declarations

+  fixed? background color conversions

+  fixed order of error function pointers to match documentation

+  current chunk name is now available in png_struct to reduce the number

+     of nearly identical error messages (will simplify multi-lingual

+     support when available)

+  try to get ready for unknown-chunk callback functions:

+     - previously read critical chunks are flagged, so the chunk handling

+       routines can determine if the chunk is in the right place

+     - all chunk handling routines have the same prototypes, so we will

+       be able to handle all chunks via a callback mechanism

+  try to fix Linux "setjmp" buffer size problems

+  removed png_large_malloc, png_large_free, and png_realloc functions.

+version 0.95 [March, 1997]

+  fixed bug in pngwutil.c allocating "up_row" twice and "avg_row" never

+  fixed bug in PNG file signature compares when start != 0

+  changed parameter type of png_set_filler(...filler...) from png_byte

+     to png_uint_32

+  added test for MACOS to ensure that both math.h and fp.h are not #included

+  added macros for libpng to be compiled as a Windows DLL (Andreas Kupries)

+  added "packswap" transformation, which changes the endianness of

+     packed-pixel bytes (Kevin Bracey)

+  added "strip_alpha" transformation, which removes the alpha channel of

+     input images without using it (not neccesarily a good idea)

+  added "swap_alpha" transformation, which puts the alpha channel in front

+     of the color bytes instead of after

+  removed all implicit variable tests which assume NULL == 0 (I think)

+  changed several variables to "png_size_t" to show 16/32-bit limitations

+  added new pCAL chunk read/write support

+  added experimental filter selection weighting (Greg Roelofs)

+  removed old png_set_rgbx() and png_set_xrgb() functions that have been

+     obsolete for about 2 years now (use png_set_filler() instead)

+  added macros to read 16- and 32-bit ints directly from buffer, to be

+     used only on those systems that support it (namely PowerPC and 680x0)

+     With some testing, this may become the default for MACOS/PPC systems.

+  only calculate CRC on data if we are going to use it

+  added macros for zTXt compression type PNG_zTXt_COMPRESSION_???

+  added macros for simple libpng debugging output selectable at compile time

+  removed PNG_READ_END_MODE in progressive reader (Smarasderagd)

+  more description of info_struct in libpng.txt and png.h

+  more instructions in example.c

+  more chunk types tested in pngtest.c

+  renamed pngrcb.c to pngset.c, and all png_read_<chunk> functions to be

+     png_set_<chunk>.  We now have corresponding png_get_<chunk>

+     functions in pngget.c to get infomation in info_ptr.  This isolates

+     the application from the internal organization of png_info_struct

+     (good for shared library implementations).

+version 0.96 [May, 1997]

+  fixed serious bug with < 8bpp images introduced in 0.95

+  fixed 256-color transparency bug (Greg Roelofs)

+  fixed up documentation (Greg Roelofs, Laszlo Nyul)

+  fixed "error" in pngconf.h for Linux setjmp() behaviour

+  fixed DOS medium model support (Tim Wegner)

+  fixed png_check_keyword() for case with error in static string text

+  added read of CRC after IEND chunk for embedded PNGs (Laszlo Nyul)

+  added typecasts to quiet compiler errors

+  added more debugging info

+version 0.97 [January, 1998]

+  removed PNG_USE_OWN_CRC capability

+  relocated png_set_crc_action from pngrutil.c to pngrtran.c

+  fixed typecasts of "new_key", etc. (Andreas Dilger)

+  added RFC 1152 [sic] date support

+  fixed bug in gamma handling of 4-bit grayscale

+  added 2-bit grayscale gamma handling (Glenn R-P)

+  added more typecasts. 65536L becomes (png_uint_32)65536L, etc. (Glenn R-P)

+  minor corrections in libpng.txt

+  added simple sRGB support (Glenn R-P)

+  easier conditional compiling, e.g. define PNG_READ/WRITE_NOT_FULLY_SUPPORTED;

+     all configurable options can be selected from command-line instead

+     of having to edit pngconf.h (Glenn R-P)

+  fixed memory leak in pngwrite.c (free info_ptr->text) (Glenn R-P)

+  added more conditions for png_do_background, to avoid changing

+     black pixels to background when a background is supplied and

+     no pixels are transparent

+  repaired PNG_NO_STDIO behaviour

+  tested NODIV support and made it default behaviour (Greg Roelofs)

+  added "-m" option and PNGTEST_DEBUG_MEMORY to pngtest (John Bowler)

+  regularized version numbering scheme and bumped shared-library major

+     version number to 2 to avoid problems with libpng 0.89 apps (Greg Roelofs)

+version 0.98 [January, 1998]

+  cleaned up some typos in libpng.txt and in code documentation

+  fixed memory leaks in pCAL chunk processing (Glenn R-P and John Bowler)

+  cosmetic change "display_gamma" to "screen_gamma" in pngrtran.c

+  changed recommendation about file_gamma for PC images to .51 from .45,

+     in example.c and libpng.txt, added comments to distinguish between

+     screen_gamma, viewing_gamma, and display_gamma.

+  changed all references to RFC1152 to read RFC1123 and changed the

+     PNG_TIME_RFC1152_SUPPORTED macro to PNG_TIME_RFC1123_SUPPORTED

+  added png_invert_alpha capability (Glenn R-P -- suggestion by Jon Vincent)

+  changed srgb_intent from png_byte to int to avoid compiler bugs

+version 0.99 [January 30, 1998]

+  free info_ptr->text instead of end_info_ptr->text in pngread.c (John Bowler)

+  fixed a longstanding "packswap" bug in pngtrans.c

+  fixed some inconsistencies in pngconf.h that prevented compiling with

+     PNG_READ_GAMMA_SUPPORTED and PNG_READ_hIST_SUPPORTED undefined

+  fixed some typos and made other minor rearrangement of libpng.txt (Andreas)

+  changed recommendation about file_gamma for PC images to .50 from .51 in

+     example.c and libpng.txt, and changed file_gamma for sRGB images to .45

+  added a number of functions to access information from the png structure

+     png_get_image_height(), etc. (Glenn R-P, suggestion by Brad Pettit)

+  added TARGET_MACOS similar to zlib-1.0.8

+  define PNG_ALWAYS_EXTERN when __MWERKS__ && WIN32 are defined

+  added type casting to all png_malloc() function calls

+version 0.99a [January 31, 1998]

+  Added type casts and parentheses to all returns that return a value.(Tim W.)

+version 0.99b [February 4, 1998]

+  Added type cast png_uint_32 on malloc function calls where needed.

+  Changed type of num_hist from png_uint_32 to int (same as num_palette).

+  Added checks for rowbytes overflow, in case png_size_t is less than 32 bits.

+  Renamed makefile.elf to makefile.lnx.

+version 0.99c [February 7, 1998]

+  More type casting.  Removed erroneous overflow test in pngmem.c.

+  Added png_buffered_memcpy() and png_buffered_memset(), apply them to rowbytes.

+  Added UNIX manual pages libpng.3 (incorporating libpng.txt) and  png.5.

+version 0.99d [February 11, 1998]

+  Renamed "far_to_near()" "png_far_to_near()"

+  Revised libpng.3

+  Version 99c "buffered" operations didn't work as intended.  Replaced them

+    with png_memcpy_check() and png_memset_check().

+  Added many "if (png_ptr == NULL) return" to quell compiler warnings about

+    unused png_ptr, mostly in pngget.c and pngset.c.

+  Check for overlength tRNS chunk present when indexed-color PLTE is read.

+  Cleaned up spelling errors in libpng.3/libpng.txt

+  Corrected a problem with png_get_tRNS() which returned undefined trans array

+version 0.99e [February 28, 1998]

+  Corrected png_get_tRNS() again.

+  Add parentheses for easier reading of pngget.c, fixed "||" should be "&&".

+  Touched up example.c to make more of it compileable, although the entire

+    file still can't be compiled (Willem van Schaik)

+  Fixed a bug in png_do_shift() (Bryan Tsai)

+  Added a space in png.h prototype for png_write_chunk_start()

+  Replaced pngtest.png with one created with zlib 1.1.1

+  Changed pngtest to report PASS even when file size is different (Jean-loup G.)

+  Corrected some logic errors in png_do_invert_alpha() (Chris Patterson)

+version 0.99f [March 5, 1998]

+  Corrected a bug in pngpread() introduced in version 99c (Kevin Bracey)

+  Moved makefiles into a "scripts" directory, and added INSTALL instruction file

+  Added makefile.os2 and pngos2.def (A. Zabolotny) and makefile.s2x (W. Sebok)

+  Added pointers to "note on libpng versions" in makefile.lnx and README

+  Added row callback feature when reading and writing nonprogressive rows

+     and added a test of this feature in pngtest.c

+  Added user transform callbacks, with test of the feature in pngtest.c

+version 0.99g [March 6, 1998, morning]

+  Minor changes to pngtest.c to suppress compiler warnings.

+  Removed "beta" language from documentation.

+version 0.99h [March 6, 1998, evening]

+  Minor changes to previous minor changes to pngtest.c

+  Changed PNG_READ_NOT_FULLY_SUPPORTED to PNG_READ_TRANSFORMS_NOT_SUPPORTED

+  and added PNG_PROGRESSIVE_READ_NOT_SUPPORTED macro

+  Added user transform capability

+version 1.00 [March 7, 1998]

+  Changed several typedefs in pngrutil.c

+  Added makefile.wat (Pawel Mrochen), updated makefile.tc3 (Willem van Schaik)

+  replaced "while(1)" with "for(;;)"

+  added PNGARG() to prototypes in pngtest.c and removed some prototypes

+  updated some of the makefiles (Tom Lane)

+  changed some typedefs (s_start, etc.) in pngrutil.c

+  fixed dimensions of "short_months" array in pngwrite.c

+  Replaced ansi2knr.c with the one from jpeg-v6

+version 1.0.0 [March 8, 1998]

+  Changed name from 1.00 to 1.0.0 (Adam Costello)

+  Added smakefile.ppc (with SCOPTIONS.ppc) for Amiga PPC (Andreas Kleinert)

+version 1.0.0a [March 9, 1998]

+  Fixed three bugs in pngrtran.c to make gamma+background handling consistent

+  (Greg Roelofs)

+  Changed format of the PNG_LIBPNG_VER integer to xyyzz instead of xyz

+  for major, minor, and bugfix releases.  This is 10001. (Adam Costello,

+  Tom Lane)

+  Make months range from 1-12 in png_convert_to_rfc1123

+version 1.0.0b [March 13, 1998]

+  Quieted compiler complaints about two empty "for" loops in pngrutil.c

+  Minor changes to makefile.s2x

+  Removed #ifdef/#endif around a png_free() in pngread.c

+version 1.0.1 [March 14, 1998]

+  Changed makefile.s2x to reduce security risk of using a relative pathname

+  Fixed some typos in the documentation (Greg).

+  Fixed a problem with value of "channels" returned by png_read_update_info()

+version 1.0.1a [April 21, 1998]

+  Optimized Paeth calculations by replacing abs() function calls with intrinsics

+  plus other loop optimizations. Improves avg decoding speed by about 20%.

+  Commented out i386istic "align" compiler flags in makefile.lnx.

+  Reduced the default warning level in some makefiles, to make them consistent.

+  Removed references to IJG and JPEG in the ansi2knr.c copyright statement.

+  Fixed a bug in png_do_strip_filler with XXRRGGBB => RRGGBB transformation.

+  Added grayscale and 16-bit capability to png_do_read_filler().

+  Fixed a bug in pngset.c, introduced in version 0.99c, that sets rowbytes

+    too large when writing an image with bit_depth < 8 (Bob Dellaca).

+  Corrected some bugs in the experimental weighted filtering heuristics.

+  Moved a misplaced pngrutil code block that truncates tRNS if it has more

+    than num_palette entries -- test was done before num_palette was defined.

+  Fixed a png_convert_to_rfc1123() bug that converts day 31 to 0 (Steve Eddins).

+  Changed compiler flags in makefile.wat for better optimization (Pawel Mrochen).

+version 1.0.1b [May 2, 1998]

+  Relocated png_do_gray_to_rgb() within png_do_read_transformations() (Greg).

+  Relocated the png_composite macros from pngrtran.c to png.h (Greg).

+  Added makefile.sco (contributed by Mike Hopkirk).

+  Fixed two bugs (missing definitions of "istop") introduced in libpng-1.0.1a.

+  Fixed a bug in pngrtran.c that would set channels=5 under some circumstances.

+  More work on the Paeth-filtering, achieving imperceptible speedup (A Kleinert).

+  More work on loop optimization which may help when compiled with C++ compilers.

+  Added warnings when people try to use transforms they've defined out.

+  Collapsed 4 "i" and "c" loops into single "i" loops in pngrtran and pngwtran.

+  Revised paragraph about png_set_expand() in libpng.txt and libpng.3 (Greg)

+version 1.0.1c [May 11, 1998]

+  Fixed a bug in pngrtran.c (introduced in libpng-1.0.1a) where the masks for

+    filler bytes should have been 0xff instead of 0xf.

+  Added max_pixel_depth=32 in pngrutil.c when using FILLER with palette images.

+  Moved PNG_WRITE_WEIGHTED_FILTER_SUPPORTED and PNG_WRITE_FLUSH_SUPPORTED

+    out of the PNG_WRITE_TRANSFORMS_NOT_SUPPORTED block of pngconf.h

+  Added "PNG_NO_WRITE_TRANSFORMS" etc., as alternatives for *_NOT_SUPPORTED,

+    for consistency, in pngconf.h

+  Added individual "ifndef PNG_NO_[CAPABILITY]" in pngconf.h to make it easier

+    to remove unwanted capabilities via the compile line

+  Made some corrections to grammar (which, it's) in documentation (Greg).

+  Corrected example.c, use of row_pointers in png_write_image().

+version 1.0.1d [May 24, 1998]

+  Corrected several statements that used side effects illegally in pngrutil.c

+    and pngtrans.c, that were introduced in version 1.0.1b

+  Revised png_read_rows() to avoid repeated if-testing for NULL (A Kleinert)

+  More corrections to example.c, use of row_pointers in png_write_image()

+    and png_read_rows().

+  Added pngdll.mak and pngdef.pas to scripts directory, contributed by

+    Bob Dellaca, to make a png32bd.dll with Borland C++ 4.5

+  Fixed error in example.c with png_set_text: num_text is 3, not 2 (Guido V.)

+  Changed several loops from count-down to count-up, for consistency.

+version 1.0.1e [June 6, 1998]

+  Revised libpng.txt and libpng.3 description of png_set_read|write_fn(), and

+    added warnings when people try to set png_read_fn and png_write_fn in

+    the same structure.

+  Added a test such that png_do_gamma will be done when num_trans==0

+    for truecolor images that have defined a background.  This corrects an

+    error that was introduced in libpng-0.90 that can cause gamma processing

+    to be skipped.

+  Added tests in png.h to include "trans" and "trans_values" in structures

+    when PNG_READ_BACKGROUND_SUPPORTED or PNG_READ_EXPAND_SUPPORTED is defined.

+  Add png_free(png_ptr->time_buffer) in png_destroy_read_struct()

+  Moved png_convert_to_rfc_1123() from pngwrite.c to png.c

+  Added capability for user-provided malloc_fn() and free_fn() functions,

+    and revised pngtest.c to demonstrate their use, replacing the

+    PNGTEST_DEBUG_MEM feature.

+  Added makefile.w32, for Microsoft C++ 4.0 and later (Tim Wegner).

+version 1.0.2 [June 14, 1998]

+  Fixed two bugs in makefile.bor .

+version 1.0.2a [December 30, 1998]

+  Replaced and extended code that was removed from png_set_filler() in 1.0.1a.

+  Fixed a bug in png_do_filler() that made it fail to write filler bytes in

+    the left-most pixel of each row (Kevin Bracey).

+  Changed "static pngcharp tIME_string" to "static char tIME_string[30]"

+    in pngtest.c (Duncan Simpson).

+  Fixed a bug in pngtest.c that caused pngtest to try to write a tIME chunk

+    even when no tIME chunk was present in the source file.

+  Fixed a problem in pngrutil.c: gray_to_rgb didn't always work with 16-bit.

+  Fixed a problem in png_read_push_finish_row(), which would not skip some

+    passes that it should skip, for images that are less than 3 pixels high.

+  Interchanged the order of calls to png_do_swap() and png_do_shift()

+    in pngwtran.c (John Cromer).

+  Added #ifdef PNG_DEBUG/#endif surrounding use of PNG_DEBUG in png.h .

+  Changed "bad adaptive filter type" from error to warning in pngrutil.c .

+  Fixed a documentation error about default filtering with 8-bit indexed-color.

+  Separated the PNG_NO_STDIO macro into PNG_NO_STDIO and PNG_NO_CONSOLE_IO

+    (L. Peter Deutsch).

+  Added png_set_rgb_to_gray() and png_get_rgb_to_gray_status() functions.

+  Added png_get_copyright() and png_get_header_version() functions.

+  Revised comments on png_set_progressive_read_fn() in libpng.txt and example.c

+  Added information about debugging in libpng.txt and libpng.3 .

+  Changed "ln -sf" to "ln -s -f" in makefile.s2x, makefile.lnx, and makefile.sco.

+  Removed lines after Dynamic Dependencies" in makefile.aco .

+  Revised makefile.dec to make a shared library (Jeremie Petit).

+  Removed trailing blanks from all files.

+version 1.0.2a [January 6, 1999]

+  Removed misplaced #endif and #ifdef PNG_NO_EXTERN near the end of png.h

+  Added "if" tests to silence complaints about unused png_ptr in png.h and png.c

+  Changed "check_if_png" function in example.c to return true (nonzero) if PNG.

+  Changed libpng.txt to demonstrate png_sig_cmp() instead of png_check_sig()

+    which is obsolete.

+version 1.0.3 [January 14, 1999]

+  Added makefile.hux, for Hewlett Packard HPUX 10.20 and 11.00 (Jim Rice)

+  Added a statement of Y2K compliance in png.h, libpng.3, and Y2KINFO.

+version 1.0.3a [August 12, 1999]

+  Added check for PNG_READ_INTERLACE_SUPPORTED in pngread.c; issue a warning

+     if an attempt is made to read an interlaced image when it's not supported.

+  Added check if png_ptr->trans is defined before freeing it in pngread.c

+  Modified the Y2K statement to include versions back to version 0.71

+  Fixed a bug in the check for valid IHDR bit_depth/color_types in pngrutil.c

+  Modified makefile.wat (added -zp8 flag, ".symbolic", changed some comments)

+  Replaced leading blanks with tab characters in makefile.hux

+  Changed "dworkin.wustl.edu" to "ccrc.wustl.edu" in various documents.

+  Changed (float)red and (float)green to (double)red, (double)green

+     in png_set_rgb_to_gray() to avoid "promotion" problems in AIX.

+  Fixed a bug in pngconf.h that omitted <stdio.h> when PNG_DEBUG==0 (K Bracey).

+  Reformatted libpng.3 and libpngpf.3 with proper fonts (script by J. vanZandt).

+  Updated documentation to refer to the PNG-1.2 specification.

+  Removed ansi2knr.c and left pointers to the latest source for ansi2knr.c

+    in makefile.knr, INSTALL, and README (L. Peter Deutsch)

+  Fixed bugs in calculation of the length of rowbytes when adding alpha

+    channels to 16-bit images, in pngrtran.c (Chris Nokleberg)

+  Added function png_set_user_transform_info() to store user_transform_ptr,

+    user_depth, and user_channels into the png_struct, and a function

+    png_get_user_transform_ptr() to retrieve the pointer (Chris Nokleberg)

+  Added function png_set_empty_plte_permitted() to make libpng useable

+    in MNG applications.

+  Corrected the typedef for png_free_ptr in png.h (Jesse Jones).

+  Correct gamma with srgb is 45455 instead of 45000 in pngrutil.c, to be

+    consistent with PNG-1.2, and allow variance of 500 before complaining.

+  Added assembler code contributed by Intel in file pngvcrd.c and modified

+    makefile.w32 to use it (Nirav Chhatrapati, INTEL Corporation, Gilles Vollant)

+  Changed "ln -s -f" to "ln -f -s" in the makefiles to make Solaris happy.

+  Added some aliases for png_set_expand() in pngrtran.c, namely

+    png_set_expand_PLTE(), png_set_expand_depth(), and png_set_expand_tRNS()

+    (Greg Roelofs, in "PNG: The Definitive Guide").

+  Added makefile.beo for BEOS on X86, contributed by Sander Stok.

+version 1.0.3b [August 26, 1999]

+  Replaced 2147483647L several places with PNG_MAX_UINT macro, defined in png.h

+  Changed leading blanks to tabs in all makefiles.

+  Define PNG_USE_PNGVCRD in makefile.w32, to get MMX assembler code.

+  Made alternate versions of  png_set_expand() in pngrtran.c, namely

+    png_set_gray_1_2_4_to_8, png_set_palette_to_rgb, and png_set_tRNS_to_alpha

+    (Greg Roelofs, in "PNG: The Definitive Guide").  Deleted the 1.0.3a aliases.

+  Relocated start of 'extern "C"' block in png.h so it doesn't include pngconf.h

+  Revised calculation of num_blocks in pngmem.c to avoid a potentially

+    negative shift distance, whose results are undefined in the C language.

+  Added a check in pngset.c to prevent writing multiple tIME chunks.

+  Added a check in pngwrite.c to detect invalid small window_bits sizes.

+version 1.0.3d [September 4, 1999]

+  Fixed type casting of igamma in pngrutil.c

+  Added new png_expand functions to scripts/pngdef.pas and pngos2.def

+  Added a demo read_user_transform_fn that examines the row filters in pngtest.c

+version 1.0.4 [September 24, 1999]

+  Define PNG_ALWAYS_EXTERN in pngconf.h if __STDC__ is defined

+  Delete #define PNG_INTERNAL and include "png.h" from pngasmrd.h

+  Made several minor corrections to pngtest.c

+  Renamed the makefiles with longer but more user friendly extensions.

+  Copied the PNG copyright and license to a separate LICENSE file.

+  Revised documentation, png.h, and example.c to remove reference to

+    "viewing_gamma" which no longer appears in the PNG specification.

+  Revised pngvcrd.c to use MMX code for interlacing only on the final pass.

+  Updated pngvcrd.c to use the faster C filter algorithms from libpng-1.0.1a

+  Split makefile.win32vc into two versions, makefile.vcawin32 (uses MMX

+    assembler code) and makefile.vcwin32 (doesn't).

+  Added a CPU timing report to pngtest.c (enabled by defining PNGTEST_TIMING)

+  Added a copy of pngnow.png to the distribution.

+version 1.0.4a [September 25, 1999]

+  Increase max_pixel_depth in pngrutil.c if a user transform needs it.

+  Changed several division operations to right-shifts in pngvcrd.c

+version 1.0.4b [September 30, 1999]

+  Added parentheses in line 3732 of pngvcrd.c

+  Added a comment in makefile.linux warning about buggy -O3 in pgcc 2.95.1

+version 1.0.4c [October 1, 1999]

+  Added a "png_check_version" function in png.c and pngtest.c that will generate

+    a helpful compiler error if an old png.h is found in the search path.

+  Changed type of png_user_transform_depth|channels from int to png_byte.

+version 1.0.4d [October 6, 1999]

+  Changed 0.45 to 0.45455 in png_set_sRGB()

+  Removed unused PLTE entries from pngnow.png

+  Re-enabled some parts of pngvcrd.c (png_combine_row) that work properly.

+version 1.0.4e [October 10, 1999]

+  Fixed sign error in pngvcrd.c (Greg Roelofs)

+  Replaced some instances of memcpy with simple assignments in pngvcrd (GR-P)

+version 1.0.4f [October 15, 1999]

+  Surrounded example.c code with #if 0 .. #endif to prevent people from

+    inadvertently trying to compile it.

+  Changed png_get_header_version() from a function to a macro in png.h

+  Added type casting mostly in pngrtran.c and pngwtran.c

+  Removed some pointless "ptr = NULL" in pngmem.c

+  Added a "contrib" directory containing the source code from Greg's book.

+version 1.0.5 [October 15, 1999]

+  Minor editing of the INSTALL and README files.

+version 1.0.5a [October 23, 1999]

+  Added contrib/pngsuite and contrib/pngminus (Willem van Schaik)

+  Fixed a typo in the png_set_sRGB() function call in example.c (Jan Nijtmans)

+  Further optimization and bugfix of pngvcrd.c

+  Revised pngset.c so that it does not allocate or free memory in the user's

+    text_ptr structure.  Instead, it makes its own copy.

+  Created separate write_end_info_struct in pngtest.c for a more severe test.

+  Added code in pngwrite.c to free info_ptr->text[i].key to stop a memory leak.

+version 1.0.5b [November 23, 1999]

+  Moved PNG_FLAG_HAVE_CHUNK_HEADER, PNG_FLAG_BACKGROUND_IS_GRAY and

+    PNG_FLAG_WROTE_tIME from flags to mode.

+  Added png_write_info_before_PLTE() function.

+  Fixed some typecasting in contrib/gregbook/*.c

+  Updated scripts/makevms.com and added makevms.com to contrib/gregbook

+    and contrib/pngminus (Martin Zinser)

+version 1.0.5c [November 26, 1999]

+  Moved png_get_header_version from png.h to png.c, to accomodate ansi2knr.

+  Removed all global arrays (according to PNG_NO_GLOBAL_ARRAYS macro), to

+    accomodate making DLL's: Moved usr_png_ver from global variable to function

+    png_get_header_ver() in png.c.  Moved png_sig to png_sig_bytes in png.c and

+    eliminated use of png_sig in pngwutil.c.  Moved the various png_CHNK arrays

+    into pngtypes.h.  Eliminated use of global png_pass arrays.  Declared the

+    png_CHNK and png_pass arrays to be "const".  Made the global arrays

+    available to applications (although none are used in libpng itself) when

+    PNG_NO_GLOBAL_ARRAYS is not defined or when PNG_GLOBAL_ARRAYS is defined.

+  Removed some extraneous "-I" from contrib/pngminus/makefile.std

+  Changed the PNG_sRGB_INTENT macros in png.h to be consistent with PNG-1.2.

+  Change PNG_SRGB_INTENT to PNG_sRGB_INTENT in libpng.txt and libpng.3

+version 1.0.5d [November 29, 1999]

+  Add type cast (png_const_charp) two places in png.c

+  Eliminated pngtypes.h; use macros instead to declare PNG_CHNK arrays.

+  Renamed "PNG_GLOBAL_ARRAYS" to "PNG_USE_GLOBAL_ARRAYS" and made available

+    to applications a macro "PNG_USE_LOCAL_ARRAYS".

+  #ifdef out all the new declarations when PNG_USE_GLOBAL_ARRAYS is defined.

+  Added PNG_EXPORT_VAR macro to accommodate making DLL's.

+version 1.0.5e [November 30, 1999]

+  Added iCCP, iTXt, and sPLT support; added "lang" member to the png_text

+    structure; refactored the inflate/deflate support to make adding new chunks

+    with trailing compressed parts easier in the future, and added new functions

+    png_free_iCCP, png_free_pCAL, png_free_sPLT, png_free_text, png_get_iCCP,

+    png_get_spalettes, png_set_iCCP, png_set_spalettes (Eric S. Raymond).

+  NOTE: Applications that write text chunks MUST define png_text->lang

+    before calling png_set_text(). It must be set to NULL if you want to

+    write tEXt or zTXt chunks.  If you want your application to be able to

+    run with older versions of libpng, use

+      #ifdef PNG_iTXt_SUPPORTED

+         png_text[i].lang = NULL;

+      #endif

+  Changed png_get_oFFs() and png_set_oFFs() to use signed rather than unsigned

+    offsets (Eric S. Raymond).

+  Combined PNG_READ_cHNK_SUPPORTED and PNG_WRITE_cHNK_SUPPORTED macros into

+    PNG_cHNK_SUPPORTED and combined the three types of PNG_text_SUPPORTED

+    macros, leaving the separate macros also available.

+  Removed comments on #endifs at the end of many short, non-nested #if-blocks.

+version 1.0.5f [December 6, 1999]

+  Changed makefile.solaris to issue a warning about potential problems when

+    the ucb "ld" is in the path ahead of the ccs "ld".

+  Removed "- [date]" from the "synopsis" line in libpng.3 and libpngpf.3.

+  Added sCAL chunk support (Eric S. Raymond).

+version 1.0.5g [December 7, 1999]

+  Fixed "png_free_spallettes" typo in png.h

+  Added code to handle new chunks in pngpread.c

+  Moved PNG_CHNK string macro definitions outside of PNG_NO_EXTERN block

+  Added "translated_key" to png_text structure and png_write_iTXt().

+  Added code in pngwrite.c to work around a newly discovered zlib bug.

+version 1.0.5h [December 10, 1999]

+  NOTE: regarding the note for version 1.0.5e, the following must also

+    be included in your code:

+        png_text[i].translated_key = NULL;

+  Unknown chunk handling is now supported.

+  Option to eliminate all floating point support was added.  Some new

+    fixed-point functions such as png_set_gAMA_fixed() were added.

+  Expanded tabs and removed trailing blanks in source files.

+version 1.0.5i [December 13, 1999]

+  Added some type casts to silence compiler warnings.

+  Renamed "png_free_spalette" to "png_free_spalettes" for consistency.

+  Removed leading blanks from a #define in pngvcrd.c

+  Added some parameters to the new png_set_keep_unknown_chunks() function.

+  Added a test for up->location != 0 in the first instance of writing

+    unknown chunks in pngwrite.c

+  Changed "num" to "i" in png_free_spalettes() and png_free_unknowns() to

+    prevent recursion.

+  Added png_free_hIST() function.

+  Various patches to fix bugs in the sCAL and integer cHRM processing,

+    and to add some convenience macros for use with sCAL.

+version 1.0.5j [December 21, 1999]

+  Changed "unit" parameter of png_write_sCAL from png_byte to int, to work

+    around buggy compilers.

+  Added new type "png_fixed_point" for integers that hold float*100000 values

+  Restored backward compatibility of tEXt/zTXt chunk processing:

+    Restored the first four members of png_text to the same order as v.1.0.5d.

+    Added members "lang_key" and "itxt_length" to png_text struct.  Set

+    text_length=0 when "text" contains iTXt data.  Use the "compression"

+    member to distinguish among tEXt/zTXt/iTXt types.  Added

+    PNG_ITXT_COMPRESSION_NONE (1) and PNG_ITXT_COMPRESSION_zTXt(2) macros.

+    The "Note" above, about backward incompatibility of libpng-1.0.5e, no

+    longer applies.

+  Fixed png_read|write_iTXt() to read|write parameters in the right order,

+    and to write the iTXt chunk after IDAT if it appears in the end_ptr.

+  Added pnggccrd.c, version of pngvcrd.c Intel assembler for gcc (Greg Roelofs)

+  Reversed the order of trying to write floating-point and fixed-point gAMA.

+version 1.0.5k [December 27, 1999]

+  Added many parentheses, e.g., "if (a && b & c)" becomes "if (a && (b & c))"

+  Added png_handle_as_unknown() function (Glenn)

+  Added png_free_chunk_list() function and chunk_list and num_chunk_list members

+    of png_ptr.

+  Eliminated erroneous warnings about multiple sPLT chunks and sPLT-after-PLTE.

+  Fixed a libpng-1.0.5h bug in pngrutil.c that was issuing erroneous warnings

+    about ignoring incorrect gAMA with sRGB (gAMA was in fact not ignored)

+  Added png_free_tRNS(); png_set_tRNS() now malloc's its own trans array (ESR).

+  Define png_get_int_32 when oFFs chunk is supported as well as when pCAL is.

+  Changed type of proflen from png_int_32 to png_uint_32 in png_get_iCCP().

+version 1.0.5l [January 1, 2000]

+  Added functions png_set_read_user_chunk_fn() and png_get_user_chunk_ptr()

+    for setting a callback function to handle unknown chunks and for

+    retrieving the associated user pointer (Glenn).

+version 1.0.5m [January 7, 2000]

+  Added high-level functions png_read_png(), png_write_png(), png_free_pixels().

+version 1.0.5n [January 9, 2000]

+  Added png_free_PLTE() function, and modified png_set_PLTE() to malloc its

+    own memory for info_ptr->palette.  This makes it safe for the calling

+    application to free its copy of the palette any time after it calls

+    png_set_PLTE().

+version 1.0.5o [January 20, 2000]

+  Cosmetic changes only (removed some trailing blanks and TABs)

+version 1.0.5p [January 31, 2000]

+  Renamed pngdll.mak to makefile.bd32

+  Cosmetic changes in pngtest.c

+version 1.0.5q [February 5, 2000]

+  Relocated the makefile.solaris warning about PATH problems.

+  Fixed pngvcrd.c bug by pushing/popping registers in mmxsupport (Bruce Oberg)

+  Revised makefile.gcmmx

+  Added PNG_SETJMP_SUPPORTED, PNG_SETJMP_NOT_SUPPORTED, and PNG_ABORT() macros

+version 1.0.5r [February 7, 2000]

+  Removed superfluous prototype for png_get_itxt from png.h

+  Fixed a bug in pngrtran.c that improperly expanded the background color.

+  Return *num_text=0 from png_get_text() when appropriate, and fix documentation

+    of png_get_text() in libpng.txt/libpng.3.

+version 1.0.5s [February 18, 2000]

+  Added "png_jmp_env()" macro to pngconf.h, to help people migrate to the

+    new error handler that's planned for the next libpng release, and changed

+    example.c, pngtest.c, and contrib programs to use this macro.

+  Revised some of the DLL-export macros in pngconf.h (Greg Roelofs)

+  Fixed a bug in png_read_png() that caused it to fail to expand some images

+    that it should have expanded.

+  Fixed some mistakes in the unused and undocumented INCH_CONVERSIONS functions

+    in pngget.c

+  Changed the allocation of palette, history, and trans arrays back to

+    the version 1.0.5 method (linking instead of copying) which restores

+    backward compatibility with version 1.0.5.  Added some remarks about

+    that in example.c.  Added "free_me" member to info_ptr and png_ptr

+    and added png_free_data() function.

+  Updated makefile.linux and makefile.gccmmx to make directories conditionally.

+  Made cosmetic changes to pngasmrd.h

+  Added png_set_rows() and png_get_rows(), for use with png_read|write_png().

+  Modified png_read_png() to allocate info_ptr->row_pointers only if it

+    hasn't already been allocated.

+version 1.0.5t [March 4, 2000]

+  Changed png_jmp_env() migration aiding macro to png_jmpbuf().

+  Fixed "interlace" typo (should be "interlaced") in contrib/gregbook/read2-x.c

+  Fixed bug with use of PNG_BEFORE_IHDR bit in png_ptr->mode, introduced when

+    PNG_FLAG_HAVE_CHUNK_HEADER was moved into png_ptr->mode in version 1.0.5b

+  Files in contrib/gregbook were revised to use png_jmpbuf() and to select

+    a 24-bit visual if one is available, and to allow abbreviated options.

+  Files in contrib/pngminus were revised to use the png_jmpbuf() macro.

+  Removed spaces in makefile.linux and makefile.gcmmx, introduced in 1.0.5s

+version 1.0.5u [March 5, 2000]

+  Simplified the code that detects old png.h in png.c and pngtest.c

+  Renamed png_spalette (_p, _pp) to png_sPLT_t (_tp, _tpp)

+  Increased precision of rgb_to_gray calculations from 8 to 15 bits and

+    added png_set_rgb_to_gray_fixed() function.

+  Added makefile.bc32 (32-bit Borland C++, C mode)

+version 1.0.5v [March 11, 2000]

+  Added some parentheses to the png_jmpbuf macro definition.

+  Updated references to the zlib home page, which has moved to freesoftware.com.

+  Corrected bugs in documentation regarding png_read_row() and png_write_row().

+  Updated documentation of png_rgb_to_gray calculations in libpng.3/libpng.txt.

+  Renamed makefile.borland,turboc3 back to makefile.bor,tc3 as in version 1.0.3,

+    revised borland makefiles; added makefile.ibmvac3 and makefile.gcc (Cosmin)

+version 1.0.6 [March 20, 2000]

+  Minor revisions of makefile.bor, libpng.txt, and gregbook/rpng2-win.c

+  Added makefile.sggcc (SGI IRIX with gcc)

+version 1.0.6d [April 7, 2000]

+  Changed sprintf() to strcpy() in png_write_sCAL_s() to work without STDIO

+  Added data_length parameter to png_decompress_chunk() function

+  Revised documentation to remove reference to abandoned png_free_chnk functions

+  Fixed an error in png_rgb_to_gray_fixed()

+  Revised example.c, usage of png_destroy_write_struct().

+  Renamed makefile.ibmvac3 to makefile.ibmc, added libpng.icc IBM project file

+  Added a check for info_ptr->free_me&PNG_FREE_TEXT when freeing text in png.c

+  Simplify png_sig_bytes() function to remove use of non-ISO-C strdup().

+version 1.0.6e [April 9, 2000]

+  Added png_data_freer() function.

+  In the code that checks for over-length tRNS chunks, added check of

+    info_ptr->num_trans as well as png_ptr->num_trans (Matthias Benckmann)

+  Minor revisions of libpng.txt/libpng.3.

+  Check for existing data and free it if the free_me flag is set, in png_set_*()

+    and png_handle_*().

+  Only define PNG_WEIGHTED_FILTERS_SUPPORTED when PNG_FLOATING_POINT_SUPPORTED

+    is defined.

+  Changed several instances of PNG_NO_CONSOLE_ID to PNG_NO_STDIO in pngrutil.c

+    and mentioned the purposes of the two macros in libpng.txt/libpng.3.

+version 1.0.6f [April 14, 2000]

+  Revised png_set_iCCP() and png_set_rows() to avoid prematurely freeing data.

+  Add checks in png_set_text() for NULL members of the input text structure.

+  Revised libpng.txt/libpng.3.

+  Removed superfluous prototype for png_set_itxt from png.h

+  Removed "else" from pngread.c, after png_error(), and changed "0" to "length".

+  Changed several png_errors about malformed ancillary chunks to png_warnings.

+version 1.0.6g [April 24, 2000]

+  Added png_pass-* arrays to pnggccrd.c when PNG_USE_LOCAL_ARRAYS is defined.

+  Relocated paragraph about png_set_background() in libpng.3/libpng.txt

+    and other revisions (Matthias Benckmann)

+  Relocated info_ptr->free_me, png_ptr->free_me, and other info_ptr and

+    png_ptr members to restore binary compatibility with libpng-1.0.5

+    (breaks compatibility with libpng-1.0.6).

+version 1.0.6h [April 24, 2000]

+  Changed shared library so-number pattern from 2.x.y.z to xy.z (this builds

+    libpng.so.10 & libpng.so.10.6h instead of libpng.so.2 & libpng.so.2.1.0.6h)

+    This is a temporary change for test purposes.

+version 1.0.6i [May 2, 2000]

+  Rearranged some members at the end of png_info and png_struct, to put

+    unknown_chunks_num and free_me within the original size of the png_structs

+    and free_me, png_read_user_fn, and png_free_fn within the original png_info,

+    because some old applications allocate the structs directly instead of

+    using png_create_*().

+  Added documentation of user memory functions in libpng.txt/libpng.3

+  Modified png_read_png so that it will use user_allocated row_pointers

+    if present, unless free_me directs that it be freed, and added description

+    of the use of png_set_rows() and png_get_rows() in libpng.txt/libpng.3.

+  Added PNG_LEGACY_SUPPORTED macro, and #ifdef out all new (since version

+    1.00) members of png_struct and png_info, to regain binary compatibility

+    when you define this macro.  Capabilities lost in this event

+    are user transforms (new in version 1.0.0),the user transform pointer

+    (new in version 1.0.2), rgb_to_gray (new in 1.0.5), iCCP, sCAL, sPLT,

+    the high-level interface, and unknown chunks support (all new in 1.0.6).

+    This was necessary because of old applications that allocate the structs

+    directly as authors were instructed to do in libpng-0.88 and earlier,

+    instead of using png_create_*().

+  Added modes PNG_CREATED_READ_STRUCT and PNG_CREATED_WRITE_STRUCT which

+    can be used to detect codes that directly allocate the structs, and

+    code to check these modes in png_read_init() and png_write_init() and

+    generate a libpng error if the modes aren't set and PNG_LEGACY_SUPPORTED

+    was not defined.

+  Added makefile.intel and updated makefile.watcom (Pawel Mrochen)

+version 1.0.6j [May 3, 2000]

+  Overloaded png_read_init() and png_write_init() with macros that convert

+    calls to png_read_init_2() or png_write_init_2() that check the version

+    and structure sizes.

+version 1.0.7beta11 [May 7, 2000]

+  Removed the new PNG_CREATED_READ_STRUCT and PNG_CREATED_WRITE_STRUCT modes

+    which are no longer used.

+  Eliminated the three new members of png_text when PNG_LEGACY_SUPPORTED is

+    defined or when neither PNG_READ_iTXt_SUPPORTED nor PNG_WRITE_iTXT_SUPPORTED

+    is defined.

+  Made PNG_NO_READ|WRITE_iTXt the default setting, to avoid memory

+    overrun when old applications fill the info_ptr->text structure directly.

+  Added PNGAPI macro, and added it to the definitions of all exported functions.

+  Relocated version macro definitions ahead of the includes of zlib.h and

+    pngconf.h in png.h.

+version 1.0.7beta12 [May 12, 2000]

+  Revised pngset.c to avoid a problem with expanding the png_debug macro.

+  Deleted some extraneous defines from pngconf.h

+  Made PNG_NO_CONSOLE_IO the default condition when PNG_BUILD_DLL is defined.

+  Use MSC _RPTn debugging instead of fprintf if _MSC_VER is defined.

+  Added png_access_version_number() function.

+  Check for mask&PNG_FREE_CHNK (for TEXT, SCAL, PCAL) in png_free_data().

+  Expanded libpng.3/libpng.txt information about png_data_freer().

+version 1.0.7beta14 [May 17, 2000] (beta13 was not published)

+  Changed pnggccrd.c and pngvcrd.c to handle bad adaptive filter types as

+    warnings instead of errors, as pngrutil.c does.

+  Set the PNG_INFO_IDAT valid flag in png_set_rows() so png_write_png()

+    will actually write IDATs.

+  Made the default PNG_USE_LOCAL_ARRAYS depend on PNG_DLL instead of WIN32.

+  Make png_free_data() ignore its final parameter except when freeing data

+    that can have multiple instances (text, sPLT, unknowns).

+  Fixed a new bug in png_set_rows().

+  Removed info_ptr->valid tests from png_free_data(), as in version 1.0.5.

+  Added png_set_invalid() function.

+  Fixed incorrect illustrations of png_destroy_write_struct() in example.c.

+version 1.0.7beta15 [May 30, 2000]

+  Revised the deliberately erroneous Linux setjmp code in pngconf.h to produce

+    fewer error messages.

+  Rearranged checks for Z_OK to check the most likely path first in pngpread.c

+    and pngwutil.c.

+  Added checks in pngtest.c for png_create_*() returning NULL, and mentioned

+    in libpng.txt/libpng.3 the need for applications to check this.

+  Changed names of png_default_*() functions in pngtest to pngtest_*().

+  Changed return type of png_get_x|y_offset_*() from png_uint_32 to png_int_32.

+  Fixed some bugs in the unused PNG_INCH_CONVERSIONS functions in pngget.c

+  Set each pointer to NULL after freeing it in png_free_data().

+  Worked around a problem in pngconf.h; AIX's strings.h defines an "index"

+    macro that conflicts with libpng's png_color_16.index. (Dimitri Papadapoulos)

+  Added "msvc" directory with MSVC++ project files (Simon-Pierre Cadieux).

+version 1.0.7beta16 [June 4, 2000]

+  Revised the workaround of AIX string.h "index" bug.

+  Added a check for overlength PLTE chunk in pngrutil.c.

+  Added PNG_NO_POINTER_INDEXING macro to use array-indexing instead of pointer

+    indexing in pngrutil.c and pngwutil.c to accommodate a buggy compiler.

+  Added a warning in png_decompress_chunk() when it runs out of data, e.g.

+    when it tries to read an erroneous PhotoShop iCCP chunk.

+  Added PNG_USE_DLL macro.

+  Revised the copyright/disclaimer/license notice.

+  Added contrib/msvctest directory

+version 1.0.7rc1 [June 9, 2000]

+  Corrected the definition of PNG_TRANSFORM_INVERT_ALPHA  (0x0400 not 0x0200)

+  Added contrib/visupng directory (Willem van Schaik)

+version 1.0.7beta18 [June 23, 2000]

+  Revised PNGAPI definition, and pngvcrd.c to work with __GCC__

+    and do not redefine PNGAPI if it is passed in via a compiler directive.

+  Revised visupng/PngFile.c to remove returns from within the Try block.

+  Removed leading underscores from "_PNG_H" and "_PNG_SAVE_BSD_SOURCE" macros.

+  Updated contrib/visupng/cexcept.h to version 1.0.0.

+  Fixed bugs in pngwrite.c and pngwutil.c that prevented writing iCCP chunks.

+version 1.0.7rc2 [June 28, 2000]

+  Updated license to include disclaimers required by UCITA.

+  Fixed "DJBPP" typo in pnggccrd.c introduced in beta18.

+version 1.0.7 [July 1, 2000]

+  Revised the definition of "trans_values" in libpng.3/libpng.txt

+version 1.0.8beta1 [July 8, 2000]

+  Added png_free(png_ptr, key) two places in pngpread.c to stop memory leaks.

+  Changed PNG_NO_STDIO to PNG_NO_CONSOLE_IO, several places in pngrutil.c and

+     pngwutil.c.

+  Changed PNG_EXPORT_VAR to use PNG_IMPEXP, in pngconf.h.

+  Removed unused "#include <assert.h>" from png.c

+  Added WindowsCE support.

+  Revised pnggccrd.c to work with gcc-2.95.2 and in the Cygwin environment.

+version 1.0.8beta2 [July 10, 2000]

+  Added project files to the wince directory and made further revisions

+     of pngtest.c, pngrio.c, and pngwio.c in support of WindowsCE.

+version 1.0.8beta3 [July 11, 2000]

+  Only set the PNG_FLAG_FREE_TRNS or PNG_FREE_TRNS flag in png_handle_tRNS()

+     for indexed-color input files to avoid potential double-freeing trans array

+     under some unusual conditions; problem was introduced in version 1.0.6f.

+  Further revisions to pngtest.c and files in the wince subdirectory.

+version 1.0.8beta4 [July 14, 2000]

+  Added the files pngbar.png and pngbar.jpg to the distribution.

+  Added makefile.cygwin, and cygwin support in pngconf.h

+  Added PNG_NO_ZALLOC_ZERO macro (makes png_zalloc skip zeroing memory)

+version 1.0.8rc1 [July 16, 2000]

+  Revised png_debug() macros and statements to eliminate compiler warnings.

+version 1.0.8 [July 24, 2000]

+  Added png_flush() in pngwrite.c, after png_write_IEND().

+  Updated makefile.hpux to build a shared library.

+version 1.0.9beta1 [November 10, 2000]

+  Fixed typo in scripts/makefile.hpux

+  Updated makevms.com in scripts and contrib/* and contrib/* (Martin Zinser)

+  Fixed seqence-point bug in contrib/pngminus/png2pnm (Martin Zinser)

+  Changed "cdrom.com" in documentation to "libpng.org"

+  Revised pnggccrd.c to get it all working, and updated makefile.gcmmx (Greg).

+  Changed type of "params" from voidp to png_voidp in png_read|write_png().

+  Make sure PNGAPI and PNG_IMPEXP are defined in pngconf.h.

+  Revised the 3 instances of WRITEFILE in pngtest.c.

+  Relocated "msvc" and "wince" project subdirectories into "dll" subdirectory.

+  Updated png.rc in dll/msvc project

+  Revised makefile.dec to define and use LIBPATH and INCPATH

+  Increased size of global png_libpng_ver[] array from 12 to 18 chars.

+  Made global png_libpng_ver[], png_sig[] and png_pass_*[] arrays const.

+  Removed duplicate png_crc_finish() from png_handle_bKGD() function.

+  Added a warning when application calls png_read_update_info() multiple times.

+  Revised makefile.cygwin

+  Fixed bugs in iCCP support in pngrutil.c and pngwutil.c.

+  Replaced png_set_empty_plte_permitted() with png_permit_mng_features().

+version 1.0.9beta2 [November 19, 2000]

+  Renamed the "dll" subdirectory "projects".

+  Added borland project files to "projects" subdirectory.

+  Set VS_FF_PRERELEASE and VS_FF_PATCHED flags in msvc/png.rc when appropriate.

+  Add error message in png_set_compression_buffer_size() when malloc fails.

+version 1.0.9beta3 [November 23, 2000]

+  Revised PNG_LIBPNG_BUILD_TYPE macro in png.h, used in the msvc project.

+  Removed the png_flush() in pngwrite.c that crashes some applications

+    that don't set png_output_flush_fn.

+  Added makefile.macosx and makefile.aix to scripts directory.

+version 1.0.9beta4 [December 1, 2000]

+  Change png_chunk_warning to png_warning in png_check_keyword().

+  Increased the first part of msg buffer from 16 to 18 in png_chunk_error().

+version 1.0.9beta5 [December 15, 2000]

+  Added support for filter method 64 (for PNG datastreams embedded in MNG).

+version 1.0.9beta6 [December 18, 2000]

+  Revised png_set_filter() to accept filter method 64 when appropriate.

+  Added new PNG_HAVE_PNG_SIGNATURE bit to png_ptr->mode and use it to

+    help prevent applications from using MNG features in PNG datastreams.

+  Added png_permit_mng_features() function.

+  Revised libpng.3/libpng.txt.  Changed "filter type" to "filter method".

+version 1.0.9rc1 [December 23, 2000]

+  Revised test for PNG_HAVE_PNG_SIGNATURE in pngrutil.c

+  Fixed error handling of unknown compression type in png_decompress_chunk().

+  In pngconf.h, define __cdecl when _MSC_VER is defined.

+version 1.0.9beta7 [December 28, 2000]

+  Changed PNG_TEXT_COMPRESSION_zTXt to PNG_COMPRESSION_TYPE_BASE several places.

+  Revised memory management in png_set_hIST and png_handle_hIST in a backward

+    compatible manner.  PLTE and tRNS were revised similarly.

+  Revised the iCCP chunk reader to ignore trailing garbage.

+version 1.0.9beta8 [January 12, 2001]

+  Moved pngasmrd.h into pngconf.h.

+  Improved handling of out-of-spec garbage iCCP chunks generated by PhotoShop.

+version 1.0.9beta9 [January 15, 2001]

+  Added png_set_invalid, png_permit_mng_features, and png_mmx_supported to

+    wince and msvc project module definition files.

+  Minor revision of makefile.cygwin.

+  Fixed bug with progressive reading of narrow interlaced images in pngpread.c

+version 1.0.9beta10 [January 16, 2001]

+  Do not typedef png_FILE_p in pngconf.h when PNG_NO_STDIO is defined.

+  Fixed "png_mmx_supported" typo in project definition files.

+version 1.0.9beta11 [January 19, 2001]

+  Updated makefile.sgi to make shared library.

+  Removed png_mmx_support() function and disabled PNG_MNG_FEATURES_SUPPORTED

+    by default, for the benefit of DLL forward compatibility.  These will

+    be re-enabled in version 1.2.0.

+version 1.0.9rc2 [January 22, 2001]

+  Revised cygwin support.

+version 1.0.9 [January 31, 2001]

+  Added check of cygwin's ALL_STATIC in pngconf.h

+  Added "-nommx" parameter to contrib/gregbook/rpng2-win and rpng2-x demos.

+version 1.0.10beta1 [March 14, 2001]

+  Revised makefile.dec, makefile.sgi, and makefile.sggcc; added makefile.hpgcc.

+  Reformatted libpng.3 to eliminate bad line breaks.

+  Added checks for _mmx_supported in the read_filter_row function of pnggccrd.c

+  Added prototype for png_mmx_support() near the top of pnggccrd.c

+  Moved some error checking from png_handle_IHDR to png_set_IHDR.

+  Added PNG_NO_READ_SUPPORTED and PNG_NO_WRITE_SUPPORTED macros.

+  Revised png_mmx_support() function in pnggccrd.c

+  Restored version 1.0.8 PNG_WRITE_EMPTY_PLTE_SUPPORTED behavior in pngwutil.c

+  Fixed memory leak in contrib/visupng/PngFile.c

+  Fixed bugs in png_combine_row() in pnggccrd.c and pngvcrd.c (C version)

+  Added warnings when retrieving or setting gamma=0.

+  Increased the first part of msg buffer from 16 to 18 in png_chunk_warning().

+version 1.0.10rc1 [March 23, 2001]

+  Changed all instances of memcpy, strcpy, and strlen to png_memcpy, png_strcpy,

+    and png_strlen.

+  Revised png_mmx_supported() function in pnggccrd.c to return proper value.

+  Fixed bug in progressive reading (pngpread.c) with small images (height < 8).

+version 1.0.10 [March 30, 2001]

+  Deleted extraneous space (introduced in 1.0.9) from line 42 of makefile.cygwin

+  Added beos project files (Chris Herborth)

+version 1.0.11beta1 [April 3, 2001]

+  Added type casts on several png_malloc() calls (Dimitri Papadapoulos).

+  Removed a no-longer needed AIX work-around from pngconf.h

+  Changed several "//" single-line comments to C-style in pnggccrd.c

+version 1.0.11beta2 [April 11, 2001]

+  Removed PNGAPI from several functions whose prototypes did not have PNGAPI.

+  Updated scripts/pngos2.def

+version 1.0.11beta3 [April 14, 2001]

+  Added checking the results of many instances of png_malloc() for NULL

+version 1.0.11beta4 [April 20, 2001]

+  Undid the changes from version 1.0.11beta3.  Added a check for NULL return

+    from user's malloc_fn().

+  Removed some useless type casts of the NULL pointer.

+  Added makefile.netbsd

+version 1.0.11 [April 27, 2001]

+  Revised makefile.netbsd

+version 1.0.12beta1 [May 14, 2001]

+  Test for Windows platform in pngconf.h when including malloc.h (Emmanuel Blot)

+  Updated makefile.cygwin and handling of Cygwin's ALL_STATIC in pngconf.h

+  Added some never-to-be-executed code in pnggccrd.c to quiet compiler warnings.

+  Eliminated the png_error about apps using png_read|write_init().  Instead,

+    libpng will reallocate the png_struct and info_struct if they are too small.

+    This retains future binary compatibility for old applications written for

+    libpng-0.88 and earlier.

+version 1.2.0beta1 [May 6, 2001]

+  Bumped DLLNUM to 2.

+  Re-enabled PNG_MNG_FEATURES_SUPPORTED and enabled PNG_ASSEMBLER_CODE_SUPPORTED

+    by default.

+  Added runtime selection of MMX features.

+  Added png_set_strip_error_numbers function and related macros.

+version 1.2.0beta2 [May 7, 2001]

+  Finished merging 1.2.0beta1 with version 1.0.11

+  Added a check for attempts to read or write PLTE in grayscale PNG datastreams.

+version 1.2.0beta3 [May 17, 2001]

+  Enabled user memory function by default.

+  Modified png_create_struct so it passes user mem_ptr to user memory allocator.

+  Increased png_mng_features flag from png_byte to png_uint_32.

+  Bumped shared-library (so-number) and dll-number to 3.

+version 1.2.0beta4 [June 23, 2001]

+  Check for missing profile length field in iCCP chunk and free chunk_data

+     in case of truncated iCCP chunk.

+  Bumped shared-library number to 3 in makefile.sgi and makefile.sggcc

+  Bumped dll-number from 2 to 3 in makefile.cygwin

+  Revised contrib/gregbook/rpng*-x.c to avoid a memory leak and to exit cleanly

+     if user attempts to run it on an 8-bit display.

+  Updated contrib/gregbook

+  Use png_malloc instead of png_zalloc to allocate palette in pngset.c

+  Updated makefile.ibmc

+  Added some typecasts to eliminate gcc 3.0 warnings.  Changed prototypes

+     of png_write_oFFS width and height from png_uint_32 to png_int_32.

+  Updated example.c

+  Revised prototypes for png_debug_malloc and png_debug_free in pngtest.c

+version 1.2.0beta5 [August 8, 2001]

+  Revised contrib/gregbook

+  Revised makefile.gcmmx

+  Revised pnggccrd.c to conditionally compile some thread-unsafe code only

+     when PNG_THREAD_UNSAFE_OK is defined.

+  Added tests to prevent pngwutil.c from writing a bKGD or tRNS chunk with

+     value exceeding 2^bit_depth-1

+  Revised makefile.sgi and makefile.sggcc

+  Replaced calls to fprintf(stderr,...) with png_warning() in pnggccrd.c

+  Removed restriction that do_invert_mono only operate on 1-bit opaque files

+version 1.2.0 [September 1, 2001]

+  Changed a png_warning() to png_debug() in pnggccrd.c

+  Fixed contrib/gregbook/rpng-x.c, rpng2-x.c to avoid crash with XFreeGC().

+version 1.2.1beta1 [October 19, 2001]

+  Revised makefile.std in contrib/pngminus

+  Include background_1 in png_struct regardless of gamma support.

+  Revised makefile.netbsd and makefile.macosx, added makefile.darwin.

+  Revised example.c to provide more details about using row_callback().

+version 1.2.1beta2 [October 25, 2001]

+  Added type cast to each NULL appearing in a function call, except for

+    WINCE functions.

+  Added makefile.so9.

+version 1.2.1beta3 [October 27, 2001]

+  Removed type casts from all NULLs.

+  Simplified png_create_struct_2().

+version 1.2.1beta4 [November 7, 2001]

+  Revised png_create_info_struct() and png_creat_struct_2().

+  Added error message if png_write_info() was omitted.

+  Type cast NULLs appearing in function calls when _NO_PROTO or

+    PNG_TYPECAST_NULL is defined.

+version 1.2.1rc1 [November 24, 2001]

+  Type cast NULLs appearing in function calls except when PNG_NO_TYPECAST_NULL

+    is defined.

+  Changed typecast of "size" argument to png_size_t in pngmem.c calls to

+    the user malloc_fn, to agree with the prototype in png.h

+  Added a pop/push operation to pnggccrd.c, to preserve Eflag (Maxim Sobolev)

+  Updated makefile.sgi to recognize LIBPATH and INCPATH.

+  Updated various makefiles so "make clean" does not remove previous major

+    version of the shared library.

+version 1.2.1rc2 [December 4, 2001]

+  Always allocate 256-entry internal palette, hist, and trans arrays, to

+    avoid out-of-bounds memory reference caused by invalid PNG datastreams.

+  Added a check for prefix_length > data_length in iCCP chunk handler.

+version 1.2.1 [December 7, 2001]

+  None.

+version 1.2.2beta1 [February 22, 2002]

+  Fixed a bug with reading the length of iCCP profiles (Larry Reeves).

+  Revised makefile.linux, makefile.gcmmx, and makefile.sgi to generate

+    libpng.a, libpng12.so (not libpng.so.3), and libpng12/png.h

+  Revised makefile.darwin to remove "-undefined suppress" option.

+  Added checks for gamma and chromaticity values over 21474.83, which exceed

+    the limit for PNG unsigned 32-bit integers when encoded.

+  Revised calls to png_create_read_struct() and png_create_write_struct()

+    for simpler debugging.

+  Revised png_zalloc() so zlib handles errors (uses PNG_FLAG_MALLOC_NULL_MEM_OK)

+version 1.2.2beta2 [February 23, 2002]

+  Check chunk_length and idat_size for invalid (over PNG_MAX_UINT) lengths.

+  Check for invalid image dimensions in png_get_IHDR.

+  Added missing "fi;" in the install target of the SGI makefiles.

+  Added install-static to all makefiles that make shared libraries.

+  Always do gamma compensation when image is partially transparent.

+version 1.2.2beta3 [March 7, 2002]

+  Compute background.gray and background_1.gray even when color_type is RGB

+    in case image gets reduced to gray later.

+  Modified shared-library makefiles to install pkgconfig/libpngNN.pc.

+  Export (with PNGAPI) png_zalloc, png_zfree, and png_handle_as_unknown

+  Removed unused png_write_destroy_info prototype from png.h

+  Eliminated incorrect use of width_mmx from pnggccrd.c in pixel_bytes == 8 case

+  Added install-shared target to all makefiles that make shared libraries.

+  Stopped a double free of palette, hist, and trans when not using free_me.

+  Added makefile.32sunu for Sun Ultra 32 and makefile.64sunu for Sun Ultra 64.

+version 1.2.2beta4 [March 8, 2002]

+  Compute background.gray and background_1.gray even when color_type is RGB

+    in case image gets reduced to gray later (Jason Summers).

+  Relocated a misplaced /bin/rm in the "install-shared" makefile targets

+  Added PNG_1_0_X macro which can be used to build a 1.0.x-compatible library.

+version 1.2.2beta5 [March 26, 2002]

+  Added missing PNGAPI to several function definitions.

+  Check for invalid bit_depth or color_type in png_get_IHDR(), and

+    check for missing PLTE or IHDR in png_push_read_chunk() (Matthias Clasen).

+  Revised iTXt support to accept NULL for lang and lang_key.

+  Compute gamma for color components of background even when color_type is gray.

+  Changed "()" to "{}" in scripts/libpng.pc.in.

+  Revised makefiles to put png.h and pngconf.h only in $prefix/include/libpngNN

+  Revised makefiles to make symlink to libpng.so.NN in addition to libpngNN.so

+version 1.2.2beta6 [March 31, 2002]

+version 1.0.13beta1 [March 31, 2002]

+  Prevent png_zalloc() from trying to memset memory that it failed to acquire.

+  Add typecasts of PNG_MAX_UINT in pngset_cHRM_fixed() (Matt Holgate).

+  Ensure that the right function (user or default) is used to free the

+    png_struct after an error in png_create_read_struct_2().

+version 1.2.2rc1 [April 7, 2002]

+version 1.0.13rc1 [April 7, 2002]

+  Save the ebx register in pnggccrd.c (Sami Farin)

+  Add "mem_ptr = png_ptr->mem_ptr" in png_destroy_write_struct() (Paul Gardner).

+  Updated makefiles to put headers in include/libpng and remove old include/*.h.

+version 1.2.2 [April 15, 2002]

+version 1.0.13 [April 15, 2002]

+  Revised description of png_set_filter() in libpng.3/libpng.txt.

+  Revised makefile.netbsd and added makefile.neNNbsd and makefile.freebsd

+version 1.0.13patch01 [April 17, 2002]

+version 1.2.2patch01 [April 17, 2002]

+  Changed ${PNGMAJ}.${PNGVER} bug to ${PNGVER} in makefile.sgi and makefile.sggcc

+  Fixed VER -> PNGVER typo in makefile.macosx and added install-static to install

+  Added install: target to makefile.32sunu and makefile.64sunu

+version 1.0.13patch03 [April 18, 2002]

+version 1.2.2patch03 [April 18, 2002]

+  Revised 15 makefiles to link libpng.a to libpngNN.a and the include libpng

+  subdirectory to libpngNN subdirectory without the full pathname.

+  Moved generation of libpng.pc from "install" to "all" in 15 makefiles.

+version 1.2.3rc1 [April 28, 2002]

+  Added install-man target to 15 makefiles (Dimitri Papadopolous-Orfanos).

+  Added $(DESTDIR) feature to 24 makefiles (Tim Mooney)

+  Fixed bug with $prefix, should be $(prefix) in makefile.hpux.

+  Updated cygwin-specific portion of pngconf.h and revised makefile.cygwin

+  Added a link from libpngNN.pc to libpng.pc in 15 makefiles.

+  Added links from include/libpngNN/*.h to include/*.h in 24 makefiles.

+  Revised makefile.darwin to make relative links without full pathname.

+  Added setjmp() at the end of png_create_*_struct_2() in case user forgets

+    to put one in their application.

+  Restored png_zalloc() and png_zfree() prototypes to version 1.2.1 and

+    removed them from module definition files.

+version 1.2.3rc2 [May 1, 2002]

+  Fixed bug in reporting number of channels in pngget.c and pngset.c,

+    that was introduced in version 1.2.2beta5.

+  Exported png_zalloc(), png_zfree(), png_default_read(), png_default_write(),

+    png_default_flush(), and png_push_fill_buffer() and included them in

+    module definition files.

+  Added "libpng.pc" dependency to the "install-shared" target in 15 makefiles.

+version 1.2.3rc3 [May 1, 2002]

+  Revised prototype for png_default_flush()

+  Remove old libpng.pc and libpngNN.pc before installing new ones.

+version 1.2.3rc4 [May 2, 2002]

+  Typos in *.def files (png_default_read|write -> png_default_read|write_data)

+  In makefiles, changed rm libpng.NN.pc to rm libpngNN.pc

+  Added libpng-config and libpngNN-config and modified makefiles to install them.

+  Changed $(MANPATH) to $(DESTDIR)$(MANPATH) in makefiles

+  Added "Win32 DLL VB" configuration to projects/msvc/libpng.dsp

+version 1.2.3rc5 [May 11, 2002]

+  Changed "error" and "message" in prototypes to "error_message" and

+    "warning_message" to avoid namespace conflict.

+  Revised 15 makefiles to build libpng-config from libpng-config-*.in

+  Once more restored png_zalloc and png_zfree to regular nonexported form.

+  Restored png_default_read|write_data, png_default_flush, png_read_fill_buffer

+    to nonexported form, but with PNGAPI, and removed them from module def files.

+version 1.2.3rc6 [May 14, 2002]

+  Removed "PNGAPI" from png_zalloc() and png_zfree() in png.c

+  Changed "Gz" to "Gd" in projects/msvc/libpng.dsp and zlib.dsp.

+  Removed leftover libpng-config "sed" script from four makefiles.

+  Revised libpng-config creating script in 16 makefiles.

+version 1.2.3 [May 22, 2002]

+  Revised libpng-config target in makefile.cygwin.

+  Removed description of png_set_mem_fn() from documentation.

+  Revised makefile.freebsd.

+  Minor cosmetic changes to 15 makefiles, e.g., $(DI) = $(DESTDIR)/$(INCDIR).

+  Revised projects/msvc/README.txt

+  Changed -lpng to -lpngNN in LDFLAGS in several makefiles.

+version 1.2.4beta1 [May 24, 2002]

+  Added libpng.pc and libpng-config to "all:" target in 16 makefiles.

+  Fixed bug in 16 makefiles: $(DESTDIR)/$(LIBPATH) to $(DESTDIR)$(LIBPATH)

+  Added missing "\" before closing double quote in makefile.gcmmx.

+  Plugged various memory leaks; added png_malloc_warn() and png_set_text_2()

+    functions.

+version 1.2.4beta2 [June 25, 2002]

+  Plugged memory leak of png_ptr->current_text (Matt Holgate).

+  Check for buffer overflow before reading CRC in pngpread.c (Warwick Allison)

+  Added -soname to the loader flags in makefile.dec, makefile.sgi, and

+    makefile.sggcc.

+  Added "test-installed" target to makefile.linux, makefile.gcmmx,

+    makefile.sgi, and makefile.sggcc.

+version 1.2.4beta3 [June 28, 2002]

+  Plugged memory leak of row_buf in pngtest.c when there is a png_error().

+  Detect buffer overflow in pngpread.c when IDAT is corrupted with extra data.

+  Added "test-installed" target to makefile.32sunu, makefile.64sunu,

+    makefile.beos, makefile.darwin, makefile.dec, makefile.macosx,

+    makefile.solaris, makefile.hpux, makefile.hpgcc, and makefile.so9.

+version 1.2.4rc1 and 1.0.14rc1 [July 2, 2002]

+  Added "test-installed" target to makefile.cygwin and makefile.sco.

+  Revised pnggccrd.c to be able to back out version 1.0.x via PNG_1_0_X macro.

+version 1.2.4 and 1.0.14 [July 8, 2002]

+  Changed png_warning() to png_error() when width is too large to process.

+version 1.2.4patch01 [July 20, 2002]

+  Revised makefile.cygwin to use DLL number 12 instead of 13.

+version 1.2.5beta1 [August 6, 2002]

+  Added code to contrib/gregbook/readpng2.c to ignore unused chunks.

+  Replaced toucan.png in contrib/gregbook (it has been corrupt since 1.0.11)

+  Removed some stray *.o files from contrib/gregbook.

+  Changed png_error() to png_warning() about "Too much data" in pngpread.c

+    and about "Extra compressed data" in pngrutil.c.

+  Prevent png_ptr->pass from exceeding 7 in png_push_finish_row().

+  Updated makefile.hpgcc

+  Updated png.c and pnggccrd.c handling of return from png_mmx_support()

+version 1.2.5beta2 [August 15, 2002]

+  Only issue png_warning() about "Too much data" in pngpread.c when avail_in

+    is nonzero.

+  Updated makefiles to install a separate libpng.so.3 with its own rpath.

+version 1.2.5rc1 and 1.0.15rc1 [August 24, 2002]

+  Revised makefiles to not remove previous minor versions of shared libraries.

+version 1.2.5rc2 and 1.0.15rc2 [September 16, 2002]

+  Revised 13 makefiles to remove "-lz" and "-L$(ZLIBLIB)", etc., from shared

+    library loader directive.

+  Added missing "$OBJSDLL" line to makefile.gcmmx.

+  Added missing "; fi" to makefile.32sunu.

+version 1.2.5rc3 and 1.0.15rc3 [September 18, 2002]

+  Revised libpng-config script.

+version 1.2.5 and 1.0.15 [October 3, 2002]

+  Revised makefile.macosx, makefile.darwin, makefile.hpgcc, and makefile.hpux,

+    and makefile.aix.

+  Relocated two misplaced PNGAPI lines in pngtest.c

+version 1.2.6beta1 [October 22, 2002]

+  Commented out warning about uninitialized mmx_support in pnggccrd.c.

+  Changed "IBMCPP__" flag to "__IBMCPP__" in pngconf.h.

+  Relocated two more misplaced PNGAPI lines in pngtest.c

+  Fixed memory overrun bug in png_do_read_filler() with 16-bit datastreams,

+    introduced in version 1.0.2.

+  Revised makefile.macosx, makefile.dec, makefile.aix, and makefile.32sunu.

+version 1.2.6beta2 [November 1, 2002]

+  Added libpng-config "--ldopts" output.

+  Added "AR=ar" and "ARFLAGS=rc" and changed "ar rc" to "$(AR) $(ARFLAGS)"

+    in makefiles.

+version 1.2.6beta3 [July 18, 2004]

+  Reverted makefile changes from version 1.2.6beta2 and some of the changes

+    from version 1.2.6beta1; these will be postponed until version 1.2.7.

+    Version 1.2.6 is going to be a simple bugfix release.

+  Changed the one instance of "ln -sf" to "ln -f -s" in each Sun makefile.

+  Fixed potential overrun in pngerror.c by using strncpy instead of memcpy.

+  Added "#!/bin/sh" at the top of configure, for recognition of the

+    'x' flag under Cygwin (Cosmin).

+  Optimized vacuous tests that silence compiler warnings, in png.c (Cosmin).

+  Added support for PNG_USER_CONFIG, in pngconf.h (Cosmin).

+  Fixed the special memory handler for Borland C under DOS, in pngmem.c

+    (Cosmin).

+  Removed some spurious assignments in pngrutil.c (Cosmin).

+  Replaced 65536 with 65536L, and 0xffff with 0xffffL, to silence warnings

+    on 16-bit platforms (Cosmin).

+  Enclosed shift op expressions in parentheses, to silence warnings (Cosmin).

+  Used proper type png_fixed_point, to avoid problems on 16-bit platforms,

+    in png_handle_sRGB() (Cosmin).

+  Added compression_type to png_struct, and optimized the window size

+    inside the deflate stream (Cosmin).

+  Fixed definition of isnonalpha(), in pngerror.c and pngrutil.c (Cosmin).

+  Fixed handling of unknown chunks that come after IDAT (Cosmin).

+  Allowed png_error() and png_warning() to work even if png_ptr == NULL

+    (Cosmin).

+  Replaced row_info->rowbytes with row_bytes in png_write_find_filter()

+    (Cosmin).

+  Fixed definition of PNG_LIBPNG_VER_DLLNUM (Simon-Pierre).

+  Used PNG_LIBPNG_VER and PNG_LIBPNG_VER_STRING instead of the hardcoded

+    values in png.c (Simon-Pierre, Cosmin).

+  Initialized png_libpng_ver[] with PNG_LIBPNG_VER_STRING (Simon-Pierre).

+  Replaced PNG_LIBPNG_VER_MAJOR with PNG_LIBPNG_VER_DLLNUM in png.rc

+    (Simon-Pierre).

+  Moved the definition of PNG_HEADER_VERSION_STRING near the definitions

+    of the other PNG_LIBPNG_VER_... symbols in png.h (Cosmin).

+  Relocated #ifndef PNGAPI guards in pngconf.h (Simon-Pierre, Cosmin).

+  Updated scripts/makefile.vc(a)win32 (Cosmin).

+  Updated the MSVC project (Simon-Pierre, Cosmin).

+  Updated the Borland C++ Builder project (Cosmin).

+  Avoided access to asm_flags in pngvcrd.c, if PNG_1_0_X is defined (Cosmin).

+  Commented out warning about uninitialized mmx_support in pngvcrd.c (Cosmin).

+  Removed scripts/makefile.bd32 and scripts/pngdef.pas (Cosmin).

+  Added extra guard around inclusion of Turbo C memory headers, in pngconf.h

+    (Cosmin).

+  Renamed projects/msvc/ to projects/visualc6/, and projects/borland/ to

+    projects/cbuilder5/ (Cosmin).

+  Moved projects/visualc6/png32ms.def to scripts/pngw32.def,

+    and projects/visualc6/png.rc to scripts/pngw32.rc (Cosmin).

+  Added projects/visualc6/pngtest.dsp; removed contrib/msvctest/ (Cosmin).

+  Changed line endings to DOS style in cbuilder5 and visualc6 files, even

+    in the tar.* distributions (Cosmin).

+  Updated contrib/visupng/VisualPng.dsp (Cosmin).

+  Updated contrib/visupng/cexcept.h to version 2.0.0 (Cosmin).

+  Added a separate distribution with "configure" and supporting files (Junichi).

+version 1.2.6beta4 [July 28, 2004]

+  Added user ability to change png_size_t via a PNG_SIZE_T macro.

+  Added png_sizeof() and png_convert_size() functions.

+  Added PNG_SIZE_MAX (maximum value of a png_size_t variable.

+  Added check in png_malloc_default() for (size_t)size != (png_uint_32)size

+    which would indicate an overflow.

+  Changed sPLT failure action from png_error to png_warning and abandon chunk.

+  Changed sCAL and iCCP failures from png_error to png_warning and abandon.

+  Added png_get_uint_31(png_ptr, buf) function.

+  Added PNG_UINT_32_MAX macro.

+  Renamed PNG_MAX_UINT to PNG_UINT_31_MAX.

+  Made png_zalloc() issue a png_warning and return NULL on potential

+    overflow.

+  Turn on PNG_NO_ZALLOC_ZERO by default in version 1.2.x

+  Revised "clobber list" in pnggccrd.c so it will compile under gcc-3.4.

+  Revised Borland portion of png_malloc() to return NULL or issue

+    png_error() according to setting of PNG_FLAG_MALLOC_NULL_MEM_OK.

+  Added PNG_NO_SEQUENTIAL_READ_SUPPORTED macro to conditionally remove

+    sequential read support.

+  Added some "#if PNG_WRITE_SUPPORTED" blocks.

+  #ifdef'ed out some redundancy in png_malloc_default().

+  Use png_malloc instead of png_zalloc to allocate the pallete.

+version 1.0.16rc1 and 1.2.6rc1 [August 4, 2004]

+  Fixed buffer overflow vulnerability in png_handle_tRNS()

+  Fixed integer arithmetic overflow vulnerability in png_read_png().

+  Fixed some harmless bugs in png_handle_sBIT, etc, that would cause

+    duplicate chunk types to go undetected.

+  Fixed some timestamps in the -config version

+  Rearranged order of processing of color types in png_handle_tRNS().

+  Added ROWBYTES macro to calculate rowbytes without integer overflow.

+  Updated makefile.darwin and removed makefile.macosx from scripts directory.

+  Imposed default one million column, one-million row limits on the image

+    dimensions, and added png_set_user_limits() function to override them.

+  Revised use of PNG_SET_USER_LIMITS_SUPPORTED macro.

+  Fixed wrong cast of returns from png_get_user_width|height_max().

+  Changed some "keep the compiler happy" from empty statements to returns,

+  Revised libpng.txt to remove 1.2.x stuff from the 1.0.x distribution

+version 1.0.16rc2 and 1.2.6rc2 [August 7, 2004]

+  Revised makefile.darwin and makefile.solaris.  Removed makefile.macosx.

+  Revised pngtest's png_debug_malloc() to use png_malloc() instead of

+    png_malloc_default() which is not supposed to be exported.

+  Fixed off-by-one error in one of the conversions to PNG_ROWBYTES() in

+    pngpread.c.  Bug was introduced in 1.2.6rc1.

+  Fixed bug in RGB to RGBX transformation introduced in 1.2.6rc1.

+  Fixed old bug in RGB to Gray transformation.

+  Fixed problem with 64-bit compilers by casting arguments to abs()

+    to png_int_32.

+  Changed "ln -sf" to "ln -f -s" in three makefiles (solaris, sco, so9).

+  Changed "HANDLE_CHUNK_*" to "PNG_HANDLE_CHUNK_*" (Cosmin)

+  Added "-@/bin/rm -f $(DL)/$(LIBNAME).so.$(PNGMAJ)" to 15 *NIX makefiles.

+  Added code to update the row_info->colortype in png_do_read_filler() (MSB).

+version 1.0.16rc3 and 1.2.6rc3 [August 9, 2004]

+  Eliminated use of "abs()" in testing cHRM and gAMA values, to avoid

+    trouble with some 64-bit compilers.  Created PNG_OUT_OF_RANGE() macro.

+  Revised documentation of png_set_keep_unknown_chunks().

+  Check handle_as_unknown status in pngpread.c, as in pngread.c previously.

+  Moved  "PNG_HANDLE_CHUNK_*" macros out of PNG_INTERNAL section of png.h

+  Added "rim" definitions for CONST4 and CONST6 in pnggccrd.c

+version 1.0.16rc4 and 1.2.6rc4 [August 10, 2004]

+  Fixed mistake in pngtest.c introduced in 1.2.6rc2 (declaration of

+    "pinfo" was out of place).

+version 1.0.16rc5 and 1.2.6rc5 [August 10, 2004]

+  Moved  "PNG_HANDLE_CHUNK_*" macros out of PNG_ASSEMBLER_CODE_SUPPORTED

+     section of png.h where they were inadvertently placed in version rc3.

+version 1.0.16 and 1.2.6 [August 15, 2004]

+  Revised pngtest so memory allocation testing is only done when PNG_DEBUG==1.

+version 1.2.7beta1 [August 26, 2004]

+  Removed unused pngasmrd.h file.

+  Removed references to uu.net for archived files.  Added references to

+    PNG Spec (second edition) and the PNG ISO/IEC Standard.

+  Added "test-dd" target in 15 makefiles, to run pngtest in DESTDIR.

+  Fixed bug with "optimized window size" in the IDAT datastream, that

+    causes libpng to write PNG files with incorrect zlib header bytes.

+version 1.2.7beta2 [August 28, 2004]

+  Fixed bug with sCAL chunk and big-endian machines (David Munro).

+  Undid new code added in 1.2.6rc2 to update the color_type in

+    png_set_filler().

+  Added png_set_add_alpha() that updates color type.

+version 1.0.17rc1 and 1.2.7rc1 [September 4, 2004]

+  Revised png_set_strip_filler() to not remove alpha if color_type has alpha.

+version 1.0.17 and 1.2.7 [September 12, 2004]

+  Added makefile.hp64

+  Changed projects/msvc/png32ms.def to scripts/png32ms.def in makefile.cygwin

+version 1.2.8beta1 [November 1, 2004]

+  Fixed bug in png_text_compress() that would fail to complete a large block.

+  Fixed bug, introduced in libpng-1.2.7, that overruns a buffer during

+    strip alpha operation in png_do_strip_filler().

+  Added PNG_1_2_X definition in pngconf.h

+  #ifdef out png_info_init in png.c and png_read_init in pngread.c (as of 1.3.0)

+version 1.2.8beta2 [November 2, 2004]

+  Reduce color_type to a nonalpha type after strip alpha operation in

+    png_do_strip_filler().

+version 1.2.8beta3 [November 3, 2004]

+  Revised definitions of PNG_MAX_UINT_32, PNG_MAX_SIZE, and PNG_MAXSUM

+version 1.2.8beta4 [November 12, 2004]

+  Fixed (again) definition of PNG_LIBPNG_VER_DLLNUM in png.h (Cosmin).

+  Added PNG_LIBPNG_BUILD_PRIVATE in png.h (Cosmin).

+  Set png_ptr->zstream.data_type to Z_BINARY, to avoid unnecessary detection

+    of data type in deflate (Cosmin).

+  Deprecated but continue to support SPECIALBUILD and PRIVATEBUILD in favor of

+    PNG_LIBPNG_BUILD_SPECIAL_STRING and PNG_LIBPNG_BUILD_PRIVATE_STRING.

+version 1.2.8beta5 [November 20, 2004]

+  Use png_ptr->flags instead of png_ptr->transformations to pass

+    PNG_STRIP_ALPHA info to png_do_strip_filler(), to preserve ABI

+    compatibility.

+  Revised handling of SPECIALBUILD, PRIVATEBUILD,

+    PNG_LIBPNG_BUILD_SPECIAL_STRING and PNG_LIBPNG_BUILD_PRIVATE_STRING.

+version 1.2.8rc1 [November 24, 2004]

+  Moved handling of BUILD macros from pngconf.h to png.h

+  Added definition of PNG_LIBPNG_BASE_TYPE in png.h, inadvertently

+    omitted from beta5.

+  Revised scripts/pngw32.rc

+  Despammed mailing addresses by masking "@" with "at".

+  Inadvertently installed a supposedly faster test version of pngrutil.c

+version 1.2.8rc2 [November 26, 2004]

+  Added two missing "\" in png.h

+  Change tests in pngread.c and pngpread.c to

+    if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))

+       png_do_read_transformations(png_ptr);

+version 1.2.8rc3 [November 28, 2004]

+  Reverted pngrutil.c to version libpng-1.2.8beta5.

+  Added scripts/makefile.elf with supporting code in pngconf.h for symbol

+    versioning (John Bowler).

+version 1.2.8rc4 [November 29, 2004]

+  Added projects/visualc7 (Simon-pierre).

+version 1.2.8rc5 [November 29, 2004]

+  Fixed new typo in scripts/pngw32.rc

+version 1.2.8 [December 3, 2004]

+  Removed projects/visualc7, added projects/visualc71.

+Send comments/corrections/commendations to

+png-implement at ccrc.wustl.edu (subscription required; write to

+majordomo at ccrc.wustl.edu with "subscribe png-implement" in the message)

+or to glennrp at users.sourceforge.net

+Glenn R-P

--- /dev/null

+++ b/src/gfx/libpng/INSTALL

@@ -1,0 +1,169 @@

+Installing libpng version 1.2.8 - December 3, 2004

+Before installing libpng, you must first install zlib.  zlib

+can usually be found wherever you got libpng.  zlib can be

+placed in another directory, at the same level as libpng.

+Note that your system might already have a preinstalled

+zlib, but you will still need to have access to the

+zlib.h and zconf.h include files that correspond to the

+version of zlib that's installed.

+You can rename the directories that you downloaded (they

+might be called "libpng-1.2.8" or "lpng109" and "zlib-1.2.1"

+or "zlib121") so that you have directories called "zlib" and "libpng".

+Your directory structure should look like this:

+   ..       (the parent directory)

+      libpng  (this directory)

+          INSTALL (this file)

+          README

+          *.h

+          *.c

+          contrib

+             gregbook

+             pngminus

+             pngsuite

+             visupng

+          projects

+             beos

+             c5builder (Borland)

+             visualc6 (msvc)

+             netware.txt

+             wince.txt

+          scripts

+             makefile.*

+          pngtest.png

+          etc.

+      zlib

+          README

+          *.h

+          *.c

+          contrib

+          etc.

+If the line endings in the files look funny, you may wish to get the other

+distribution of libpng.  It is available in both tar.gz (UNIX style line

+endings) and zip (DOS style line endings) formats.

+If you are building libpng with MSVC, you can enter the

+libpng projects\visualc6 directory and follow the instructions in

+projects\visualc6\README.txt.

+You can build libpng for WindowsCE by downloading and installing

+the projects\wince directory as instructed in the projects\wince.txt file, and

+then following the instructions in the README* files.  Similarly, you can

+build libpng for Netware or Beos as instructed in projects\netware.txt

+or projects\beos.

+Else enter the zlib directory and follow the instructions in zlib/README,

+then come back here and choose the appropriate makefile.sys in the scripts

+directory.

+The files that are presently available in the scripts directory

+include

+ makefile.std      =>  Generic UNIX makefile (cc, creates static libpng.a)

+ makefile.elf      =>  Linux/ELF makefile symbol versioning,

+                       gcc, creates libpng12.so.0.1.2.8)

+ makefile.linux    =>  Linux/ELF makefile

+                       (gcc, creates libpng12.so.0.1.2.8)

+ makefile.gcmmx    =>  Linux/ELF makefile

+                       (gcc, creates libpng12.so.0.1.2.8,

+                       uses assembler code tuned for Intel MMX platform)

+ makefile.gcc      =>  Generic makefile (gcc, creates static libpng.a)

+ makefile.knr      =>  Archaic UNIX Makefile that converts files with

+                       ansi2knr (Requires ansi2knr.c from

+                       ftp://ftp.cs.wisc.edu/ghost)

+ makefile.aix      =>  AIX/gcc makefile

+ makefile.cygwin   =>  Cygwin/gcc makefile

+ makefile.darwin   =>  Darwin makefile, can use on MacosX

+ makefile.dec      =>  DEC Alpha UNIX makefile

+ makefile.freebsd  =>  FreeBSD makefile

+ makefile.hpgcc    =>  HPUX makefile using gcc

+ makefile.hpux     =>  HPUX (10.20 and 11.00) makefile

+ makefile.hp64     =>  HPUX (10.20 and 11.00) makefile, 64-bit

+ makefile.ibmc     =>  IBM C/C++ version 3.x for Win32 and OS/2 (static)

+ makefile.intel    =>  Intel C/C++ version 4.0 and later

+ libpng.icc        =>  Project file for IBM VisualAge/C++ version 4.0 or later

+ makefile.netbsd   =>  NetBSD/cc makefile, uses PNGGCCRD, makes libpng.so.

+ makefile.ne12bsd  =>  NetBSD/cc makefile, uses PNGGCCRD,

+                       makes libpng12.so

+ makefile.openbsd  =>  OpenBSD makefile

+ makefile.sgi      =>  Silicon Graphics IRIX makefile (cc, creates static lib)

+ makefile.sggcc    =>  Silicon Graphics (gcc,

+                       creates libpng12.so.0.1.2.8)

+ makefile.sunos    =>  Sun makefile

+ makefile.solaris  =>  Solaris 2.X makefile (gcc,

+                       creates libpng12.so.0.1.2.8)

+ makefile.so9      =>  Solaris 9 makefile (gcc,

+                       creates libpng12.so.0.1.2.8)

+ makefile.32sunu   =>  Sun Ultra 32-bit makefile

+ makefile.64sunu   =>  Sun Ultra 64-bit makefile

+ makefile.sco      =>  For SCO OSr5  ELF and Unixware 7 with Native cc

+ makefile.mips     =>  MIPS makefile

+ makefile.acorn    =>  Acorn makefile

+ makefile.amiga    =>  Amiga makefile

+ smakefile.ppc     =>  AMIGA smakefile for SAS C V6.58/7.00 PPC compiler

+                       (Requires SCOPTIONS, copied from scripts/SCOPTIONS.ppc)

+ makefile.atari    =>  Atari makefile

+ makefile.beos     =>  BEOS makefile for X86

+ makefile.bor      =>  Borland makefile (uses bcc)

+ makefile.bc32     =>  32-bit Borland C++ (all modules compiled in C mode)

+ makefile.tc3      =>  Turbo C 3.0 makefile

+ makefile.dj2      =>  DJGPP 2 makefile

+ makefile.msc      =>  Microsoft C makefile

+ makefile.vcawin32 =>  makefile for Microsoft Visual C++ 5.0 and later (uses

+                       assembler code tuned for Intel MMX platform)

+ makefile.vcwin32  =>  makefile for Microsoft Visual C++ 4.0 and later (does

+                       not use assembler code)

+ makefile.os2      =>  OS/2 Makefile (gcc and emx, requires pngos2.def)

+ pngos2.def        =>  OS/2 module definition file used by makefile.os2

+ makefile.watcom   =>  Watcom 10a+ Makefile, 32-bit flat memory model

+ makevms.com       =>  VMS build script

+ descrip.mms       =>  VMS makefile for MMS or MMK

+ SCOPTIONS.ppc     =>  Used with smakefile.ppc

+Copy the file (or files) that you need from the

+scripts directory into this directory, for example

+   MSDOS example: copy scripts\makefile.msc makefile

+   UNIX example:    cp scripts/makefile.std makefile

+Read the makefile to see if you need to change any source or

+target directories to match your preferences.

+Then read pngconf.h to see if you want to make any configuration

+changes.

+Then just run "make" which will create the libpng library in

+this directory and "make test" which will run a quick test that reads

+the "pngtest.png" file and writes a "pngout.png" file that should be

+identical to it.  Look for "9782 zero samples" in the output of the

+test.  For more confidence, you can run another test by typing

+"pngtest pngnow.png" and looking for "289 zero samples" in the output.

+Also, you can run "pngtest -m contrib/pngsuite/*.png" and compare

+your output with the result shown in contrib/pngsuite/README.

+Most of the makefiles will allow you to run "make install" to

+put the library in its final resting place (if you want to

+do that, run "make install" in the zlib directory first if necessary).

+Some also allow you to run "make test-installed" after you have

+run "make install".

+If you encounter a compiler error message complaining about the

+lines

+      __png.h__ already includes setjmp.h;

+      __dont__ include it again.;

+This means you have compiled another module that includes setjmp.h,

+which is hazardous because the two modules might not include exactly

+the same setjmp.h.  If you are sure that you know what you are doing

+and that they are exactly the same, then you can comment out or

+delete the two lines.  Better yet, use the cexcept interface

+instead, as demonstrated in contrib/visupng of the libpng distribution.

+Further information can be found in the README and libpng.txt

+files, in the individual makefiles, in png.h, and the manual pages

+libpng.3 and png.5.

--- /dev/null

+++ b/src/gfx/libpng/KNOWNBUG

@@ -1,0 +1,11 @@

+Known bugs in libpng version 1.2.8

+1. April 22, 2001: pnggccrd.c has been reported to crash on NetBSD when

+   reading interlaced PNG files, when assembler code is enabled but running

+   on a non-MMX i386 platform.

+   STATUS: Under investigation.  The change to pnggccrd.c in libpng-1.2.1

+   fixed a problem under FreeBSD but not the problem with NetBSD, which

+   still fails as of libpng-1.2.2rc1.

--- /dev/null

+++ b/src/gfx/libpng/LICENSE

@@ -1,0 +1,109 @@

+This copy of the libpng notices is provided for your convenience.  In case of

+any discrepancy between this copy and the notices in the file png.h that is

+included in the libpng distribution, the latter shall prevail.

+COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:

+If you modify libpng you may insert additional notices immediately following

+this sentence.

+libpng version 1.2.6, December 3, 2004, is

+Copyright (c) 2004 Glenn Randers-Pehrson, and is

+distributed according to the same disclaimer and license as libpng-1.2.5

+with the following individual added to the list of Contributing Authors

+   Cosmin Truta

+libpng versions 1.0.7, July 1, 2000, through 1.2.5 - October 3, 2002, are

+Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are

+distributed according to the same disclaimer and license as libpng-1.0.6

+with the following individuals added to the list of Contributing Authors

+   Simon-Pierre Cadieux

+   Eric S. Raymond

+   Gilles Vollant

+and with the following additions to the disclaimer:

+   There is no warranty against interference with your enjoyment of the

+   library or against infringement.  There is no warranty that our

+   efforts or the library will fulfill any of your particular purposes

+   or needs.  This library is provided with all faults, and the entire

+   risk of satisfactory quality, performance, accuracy, and effort is with

+   the user.

+libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are

+Copyright (c) 1998, 1999 Glenn Randers-Pehrson, and are

+distributed according to the same disclaimer and license as libpng-0.96,

+with the following individuals added to the list of Contributing Authors:

+   Tom Lane

+   Glenn Randers-Pehrson

+   Willem van Schaik

+libpng versions 0.89, June 1996, through 0.96, May 1997, are

+Copyright (c) 1996, 1997 Andreas Dilger

+Distributed according to the same disclaimer and license as libpng-0.88,

+with the following individuals added to the list of Contributing Authors:

+   John Bowler

+   Kevin Bracey

+   Sam Bushell

+   Magnus Holmgren

+   Greg Roelofs

+   Tom Tanner

+libpng versions 0.5, May 1995, through 0.88, January 1996, are

+Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.

+For the purposes of this copyright and license, "Contributing Authors"

+is defined as the following set of individuals:

+   Andreas Dilger

+   Dave Martindale

+   Guy Eric Schalnat

+   Paul Schmidt

+   Tim Wegner

+The PNG Reference Library is supplied "AS IS".  The Contributing Authors

+and Group 42, Inc. disclaim all warranties, expressed or implied,

+including, without limitation, the warranties of merchantability and of

+fitness for any purpose.  The Contributing Authors and Group 42, Inc.

+assume no liability for direct, indirect, incidental, special, exemplary,

+or consequential damages, which may result from the use of the PNG

+Reference Library, even if advised of the possibility of such damage.

+Permission is hereby granted to use, copy, modify, and distribute this

+source code, or portions hereof, for any purpose, without fee, subject

+to the following restrictions:

+1. The origin of this source code must not be misrepresented.

+2. Altered versions must be plainly marked as such and must not

+   be misrepresented as being the original source.

+3. This Copyright notice may not be removed or altered from any

+   source or altered source distribution.

+The Contributing Authors and Group 42, Inc. specifically permit, without

+fee, and encourage the use of this source code as a component to

+supporting the PNG file format in commercial products.  If you use this

+source code in a product, acknowledgment is not required but would be

+appreciated.

+A "png_get_copyright" function is available, for convenient use in "about"

+boxes and the like:

+   printf("%s",png_get_copyright(NULL));

+Also, the PNG logo (in PNG format, of course) is supplied in the

+files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).

+Libpng is OSI Certified Open Source Software.  OSI Certified Open Source is a

+certification mark of the Open Source Initiative.

+Glenn Randers-Pehrson

+glennrp at users.sourceforge.net

+December 3, 2004

--- /dev/null

+++ b/src/gfx/libpng/README

@@ -1,0 +1,262 @@

+README for libpng version 1.2.8 - December 3, 2004 (shared library 12.0)

+See the note about version numbers near the top of png.h

+See INSTALL for instructions on how to install libpng.

+Libpng comes in several distribution formats.  Get libpng-*.tar.gz

+or libpng-*.tar.bz2 if you want UNIX-style line endings in the text

+files, or lpng*.zip if you want DOS-style line endings.

+Version 0.89 was the first official release of libpng.  Don't let the

+fact that it's the first release fool you.  The libpng library has been in

+extensive use and testing since mid-1995.  By late 1997 it had

+finally gotten to the stage where there hadn't been significant

+changes to the API in some time, and people have a bad feeling about

+libraries with versions < 1.0.  Version 1.0.0 was released in

+March 1998.

+****

+Note that some of the changes to the png_info structure render this

+version of the library binary incompatible with libpng-0.89 or

+earlier versions if you are using a shared library.  The type of the

+"filler" parameter for png_set_filler() has changed from png_byte to

+png_uint_32, which will affect shared-library applications that use

+this function.

+To avoid problems with changes to the internals of png_info_struct,

+new APIs have been made available in 0.95 to avoid direct application

+access to info_ptr.  These functions are the png_set_<chunk> and

+png_get_<chunk> functions.  These functions should be used when

+accessing/storing the info_struct data, rather than manipulating it

+directly, to avoid such problems in the future.

+It is important to note that the APIs do not make current programs

+that access the info struct directly incompatible with the new

+library.  However, it is strongly suggested that new programs use

+the new APIs (as shown in example.c and pngtest.c), and older programs

+be converted to the new format, to facilitate upgrades in the future.

+****

+Additions since 0.90 include the ability to compile libpng as a

+Windows DLL, and new APIs for accessing data in the info struct.

+Experimental functions include the ability to set weighting and cost

+factors for row filter selection, direct reads of integers from buffers

+on big-endian processors that support misaligned data access, faster

+methods of doing alpha composition, and more accurate 16->8 bit color

+conversion.

+The additions since 0.89 include the ability to read from a PNG stream

+which has had some (or all) of the signature bytes read by the calling

+application.  This also allows the reading of embedded PNG streams that

+do not have the PNG file signature.  As well, it is now possible to set

+the library action on the detection of chunk CRC errors.  It is possible

+to set different actions based on whether the CRC error occurred in a

+critical or an ancillary chunk.

+The changes made to the library, and bugs fixed are based on discussions

+on the PNG-implement mailing list

+and not on material submitted privately to Guy, Andreas, or Glenn.  They will

+forward any good suggestions to the list.

+For a detailed description on using libpng, read libpng.txt.  For

+examples of libpng in a program, see example.c and pngtest.c.  For usage

+information and restrictions (what little they are) on libpng, see

+png.h.  For a description on using zlib (the compression library used by

+libpng) and zlib's restrictions, see zlib.h

+I have included a general makefile, as well as several machine and

+compiler specific ones, but you may have to modify one for your own needs.

+You should use zlib 1.0.4 or later to run this, but it MAY work with

+versions as old as zlib 0.95.  Even so, there are bugs in older zlib

+versions which can cause the output of invalid compression streams for

+some images.  You will definitely need zlib 1.0.4 or later if you are

+taking advantage of the MS-DOS "far" structure allocation for the small

+and medium memory models.  You should also note that zlib is a

+compression library that is useful for more things than just PNG files.

+You can use zlib as a drop-in replacement for fread() and fwrite() if

+you are so inclined.

+zlib should be available at the same place that libpng is, or at.

+ftp://ftp.info-zip.org/pub/infozip/zlib

+You may also want a copy of the PNG specification.  It is available

+as an RFC, a W3C Recommendation, and an ISO/IEC Standard.  You can find

+these at http://www.libpng.org/pub/png/documents/

+This code is currently being archived at libpng.sf.net in the

+[DOWNLOAD] area, and on CompuServe, Lib 20 (PNG SUPPORT)

+at GO GRAPHSUP.  If you can't find it in any of those places,

+e-mail me, and I'll help you find it.

+If you have any code changes, requests, problems, etc., please e-mail

+them to me.  Also, I'd appreciate any make files or project files,

+and any modifications you needed to make to get libpng to compile,

+along with a #define variable to tell what compiler/system you are on.

+If you needed to add transformations to libpng, or wish libpng would

+provide the image in a different way, drop me a note (and code, if

+possible), so I can consider supporting the transformation.

+Finally, if you get any warning messages when compiling libpng

+(note: not zlib), and they are easy to fix, I'd appreciate the

+fix.  Please mention "libpng" somewhere in the subject line.  Thanks.

+This release was created and will be supported by myself (of course

+based in a large way on Guy's and Andreas' earlier work), and the PNG group.

+glennrp at users.sourceforge.net

+png-implement at ccrc.wustl.edu (subscription required; write to

+majordomo at ccrc.wustl.edu with "subscribe png-implement" in the message).

+You can't reach Guy, the original libpng author, at the addresses

+given in previous versions of this document.  He and Andreas will read mail

+addressed to the png-implement list, however.

+Please do not send general questions about PNG.  Send them to

+the (png-list at ccrc.wustl.edu, subscription required, write to

+majordomo at ccrc.wustl.edu with "subscribe png-list" in your message).

+On the other hand,

+please do not send libpng questions to that address, send them to me

+or to the png-implement list.  I'll

+get them in the end anyway.  If you have a question about something

+in the PNG specification that is related to using libpng, send it

+to me.  Send me any questions that start with "I was using libpng,

+and ...".  If in doubt, send questions to me.  I'll bounce them

+to others, if necessary.

+Please do not send suggestions on how to change PNG.  We have

+been discussing PNG for nine years now, and it is official and

+finished.  If you have suggestions for libpng, however, I'll

+gladly listen.  Even if your suggestion is not used immediately,

+it may be used later.

+Files in this distribution:

+      ANNOUNCE      =>  Announcement of this version, with recent changes

+      CHANGES       =>  Description of changes between libpng versions

+      KNOWNBUG      =>  List of known bugs and deficiencies

+      LICENSE       =>  License to use and redistribute libpng

+      README        =>  This file

+      TODO          =>  Things not implemented in the current library

+      Y2KINFO       =>  Statement of Y2K compliance

+      example.c     =>  Example code for using libpng functions

+      libpng.3      =>  manual page for libpng (includes libpng.txt)

+      libpng.txt    =>  Description of libpng and its functions

+      libpngpf.3    =>  manual page for libpng's private functions

+      png.5         =>  manual page for the PNG format

+      png.c         =>  Basic interface functions common to library

+      png.h         =>  Library function and interface declarations

+      pngconf.h     =>  System specific library configuration

+      pngasmrd.h    =>  Header file for assembler-coded functions

+      pngerror.c    =>  Error/warning message I/O functions

+      pngget.c      =>  Functions for retrieving info from struct

+      pngmem.c      =>  Memory handling functions

+      pngbar.png    =>  PNG logo, 88x31

+      pngnow.png    =>  PNG logo, 98x31

+      pngpread.c    =>  Progressive reading functions

+      pngread.c     =>  Read data/helper high-level functions

+      pngrio.c      =>  Lowest-level data read I/O functions

+      pngrtran.c    =>  Read data transformation functions

+      pngrutil.c    =>  Read data utility functions

+      pngset.c      =>  Functions for storing data into the info_struct

+      pngtest.c     =>  Library test program

+      pngtest.png   =>  Library test sample image

+      pngtrans.c    =>  Common data transformation functions

+      pngwio.c      =>  Lowest-level write I/O functions

+      pngwrite.c    =>  High-level write functions

+      pngwtran.c    =>  Write data transformations

+      pngwutil.c    =>  Write utility functions

+      contrib       =>  Contributions

+       gregbook         =>  source code for PNG reading and writing, from

+                            Greg Roelofs' "PNG: The Definitive Guide",

+                            O'Reilly, 1999

+       msvctest     =>  Builds and runs pngtest using a MSVC workspace

+       pngminus     =>  Simple pnm2png and png2pnm programs

+       pngsuite     =>  Test images

+       visupng      =>  Contains a MSVC workspace for VisualPng

+      projects      =>  Contains project files and workspaces for building DLL

+       beos             =>  Contains a Beos workspace for building libpng

+       c5builder        =>  Contains a Borland workspace for building libpng

+                            and zlib

+       visualc6         =>  Contains a Microsoft Visual C++ (MSVC) workspace

+                            for building libpng and zlib

+       netware.txt      =>  Contains instructions for downloading a set of

+                            project files for building libpng and zlib on

+                            Netware.

+       wince.txt        =>  Contains instructions for downloading a Microsoft

+                            Visual C++ (Windows CD Toolkit) workspace for

+                            building libpng and zlib on WindowsCE

+      scripts       =>  Directory containing scripts for building libpng:

+       descrip.mms      =>  VMS makefile for MMS or MMK

+       makefile.std     =>  Generic UNIX makefile (cc, creates static libpng.a)

+       makefile.elf     =>  Linux/ELF makefile symbol versioning,

+                            gcc, creates libpng12.so.0.1.2.8)

+       makefile.linux   =>  Linux/ELF makefile

+                            (gcc, creates libpng12.so.0.1.2.8)

+       makefile.gcmmx   =>  Linux/ELF makefile

+                            (gcc, creates libpng12.so.0.1.2.8,

+                            uses assembler code tuned for Intel MMX platform)

+       makefile.gcc     =>  Generic makefile (gcc, creates static libpng.a)

+       makefile.knr     =>  Archaic UNIX Makefile that converts files with

+                            ansi2knr (Requires ansi2knr.c from

+                            ftp://ftp.cs.wisc.edu/ghost)

+       makefile.aix     =>  AIX makefile

+       makefile.cygwin  =>  Cygwin/gcc makefile

+       makefile.darwin  =>  Darwin makefile

+       makefile.dec     =>  DEC Alpha UNIX makefile

+       makefile.freebsd =>  FreeBSD makefile

+       makefile.hpgcc   =>  HPUX makefile using gcc

+       makefile.hpux    =>  HPUX (10.20 and 11.00) makefile

+       makefile.hp64    =>  HPUX (10.20 and 11.00) makefile, 64 bit

+       makefile.ibmc    =>  IBM C/C++ version 3.x for Win32 and OS/2 (static)

+       makefile.intel   =>  Intel C/C++ version 4.0 and later

+       libpng.icc       =>  Project file, IBM VisualAge/C++ 4.0 or later

+       makefile.netbsd  =>  NetBSD/cc makefile, PNGGCCRD, makes libpng.so.

+       makefile.ne12bsd  =>  NetBSD/cc makefile, PNGGCCRD, makes libpng12.so

+       makefile.openbsd =>  OpenBSD makefile

+       makefile.sgi     =>  Silicon Graphics IRIX (cc, creates static lib)

+       makefile.sggcc   =>  Silicon Graphics

+                            (gcc, creates libpng12.so.0.1.2.8)

+       makefile.sunos   =>  Sun makefile

+       makefile.solaris =>  Solaris 2.X makefile

+                            (gcc, creates libpng12.so.0.1.2.8)

+       makefile.so9     =>  Solaris 9 makefile

+                            (gcc, creates libpng12.so.0.1.2.8)

+       makefile.32sunu  =>  Sun Ultra 32-bit makefile

+       makefile.64sunu  =>  Sun Ultra 64-bit makefile

+       makefile.sco     =>  For SCO OSr5  ELF and Unixware 7 with Native cc

+       makefile.mips    =>  MIPS makefile

+       makefile.acorn   =>  Acorn makefile

+       makefile.amiga   =>  Amiga makefile

+       smakefile.ppc    =>  AMIGA smakefile for SAS C V6.58/7.00 PPC

+                            compiler (Requires SCOPTIONS, copied from

+                            scripts/SCOPTIONS.ppc)

+       makefile.atari   =>  Atari makefile

+       makefile.beos    =>  BEOS makefile for X86

+       makefile.bor     =>  Borland makefile (uses bcc)

+       makefile.bc32    =>  32-bit Borland C++ (all modules compiled in C mode)

+       makefile.tc3     =>  Turbo C 3.0 makefile

+       makefile.dj2     =>  DJGPP 2 makefile

+       makefile.msc     =>  Microsoft C makefile

+       makefile.vcawin32=>  makefile for Microsoft Visual C++ 5.0 and

+                            later (uses assembler code tuned for Intel MMX

+                            platform)

+       makefile.vcwin32 =>  makefile for Microsoft Visual C++ 4.0 and

+                            later (does not use assembler code)

+       makefile.os2     =>  OS/2 Makefile (gcc and emx, requires pngos2.def)

+       pngos2.def       =>  OS/2 module definition file used by makefile.os2

+       makefile.watcom  =>  Watcom 10a+ Makefile, 32-bit flat memory model

+       makevms.com      =>  VMS build script

+       SCOPTIONS.ppc    =>  Used with smakefile.ppc

+Good luck, and happy coding.

+-Glenn Randers-Pehrson (current maintainer)

+ Internet: glennrp at users.sourceforge.net

+-Andreas Eric Dilger (former maintainer, 1996-1997)

+ Internet: adilger at enel.ucalgary.ca

+ Web: http://www-mddsp.enel.ucalgary.ca/People/adilger/

+-Guy Eric Schalnat (original author and former maintainer, 1995-1996)

+ (formerly of Group 42, Inc)

+ Internet: gschal at infinet.com

--- /dev/null

+++ b/src/gfx/libpng/TODO

@@ -1,0 +1,24 @@

+TODO - list of things to do for libpng:

+Final bug fixes.

+Improve API by hiding the png_struct and png_info structs.

+Finish work on the no-floating-point version (including gamma compensation)

+Better C++ wrapper/full C++ implementation?

+Fix problem with C++ and EXTERN "C".

+cHRM transformation.

+Improve setjmp/longjmp usage or remove it in favor of returning error codes.

+Add "grayscale->palette" transformation and "palette->grayscale" detection.

+Improved dithering.

+Multi-lingual error and warning message support.

+Complete sRGB transformation (presently it simply uses gamma=0.45455).

+Man pages for function calls.

+Better documentation.

+Better filter selection

+   (counting huffman bits/precompression?  filter inertia?  filter costs?).

+Histogram creation.

+Text conversion between different code pages (Latin-1 -> Mac and DOS).

+Should we always malloc 2^bit_depth PLTE/tRNS/hIST entries for safety?

+Build gamma tables using fixed point (and do away with floating point entirely).

+Use greater precision when changing to linear gamma for compositing against

+  background and doing rgb-to-gray transformation.

+Investigate pre-incremented loop counters and other loop constructions.

--- /dev/null

+++ b/src/gfx/libpng/Y2KINFO

@@ -1,0 +1,55 @@

+   Y2K compliance in libpng:

+   =========================

+      December 3, 2004

+      Since the PNG Development group is an ad-hoc body, we can't make

+      an official declaration.

+      This is your unofficial assurance that libpng from version 0.71 and

+      upward through 1.2.8 are Y2K compliant.  It is my belief that earlier

+      versions were also Y2K compliant.

+      Libpng only has three year fields.  One is a 2-byte unsigned integer

+      that will hold years up to 65535.  The other two hold the date in text

+      format, and will hold years up to 9999.

+      The integer is

+          "png_uint_16 year" in png_time_struct.

+      The strings are

+          "png_charp time_buffer" in png_struct and

+          "near_time_buffer", which is a local character string in png.c.

+      There are seven time-related functions:

+          png_convert_to_rfc_1123() in png.c

+            (formerly png_convert_to_rfc_1152() in error)

+          png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c

+          png_convert_from_time_t() in pngwrite.c

+          png_get_tIME() in pngget.c

+          png_handle_tIME() in pngrutil.c, called in pngread.c

+          png_set_tIME() in pngset.c

+          png_write_tIME() in pngwutil.c, called in pngwrite.c

+      All appear to handle dates properly in a Y2K environment.  The

+      png_convert_from_time_t() function calls gmtime() to convert from system

+      clock time, which returns (year - 1900), which we properly convert to

+      the full 4-digit year.  There is a possibility that applications using

+      libpng are not passing 4-digit years into the png_convert_to_rfc_1123()

+      function, or that they are incorrectly passing only a 2-digit year

+      instead of "year - 1900" into the png_convert_from_struct_tm() function,

+      but this is not under our control.  The libpng documentation has always

+      stated that it works with 4-digit years, and the APIs have been

+      documented as such.

+      The tIME chunk itself is also Y2K compliant.  It uses a 2-byte unsigned

+      integer to hold the year, and can hold years as large as 65535.

+      zlib, upon which libpng depends, is also Y2K compliant.  It contains

+      no date-related code.

+         Glenn Randers-Pehrson

+         libpng maintainer

+         PNG Development Group

--- /dev/null

+++ b/src/gfx/libpng/configure

@@ -1,0 +1,13 @@

+#!/bin/sh

+echo "

+  There is no \"configure\" script in this distribution of

+  libpng-1.2.8.

+  Instead, please copy the appropriate makefile for your system from the

+  \"scripts\" directory.  Read the INSTALL file for more details.

+  Update, July 2004: you can get a "configure" based distribution

+  from the libpng distribution sites.  Download the file

+  libpng-1.2.8-config.tar.gz

+"

--- /dev/null

+++ b/src/gfx/libpng/example.c

@@ -1,0 +1,808 @@

+#if 0 /* in case someone actually tries to compile this */

+/* example.c - an example of using libpng */

+/* This is an example of how to use libpng to read and write PNG files.

+ * The file libpng.txt is much more verbose then this.  If you have not

+ * read it, do so first.  This was designed to be a starting point of an

+ * implementation.  This is not officially part of libpng, is hereby placed

+ * in the public domain, and therefore does not require a copyright notice.

+ *

+ * This file does not currently compile, because it is missing certain

+ * parts, like allocating memory to hold an image.  You will have to

+ * supply these parts to get it to compile.  For an example of a minimal

+ * working PNG reader/writer, see pngtest.c, included in this distribution;

+ * see also the programs in the contrib directory.

+ */

+#include "png.h"

+ /* The png_jmpbuf() macro, used in error handling, became available in

+  * libpng version 1.0.6.  If you want to be able to run your code with older

+  * versions of libpng, you must define the macro yourself (but only if it

+  * is not already defined by libpng!).

+  */

+#ifndef png_jmpbuf

+#  define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)

+#endif

+/* Check to see if a file is a PNG file using png_sig_cmp().  png_sig_cmp()

+ * returns zero if the image is a PNG and nonzero if it isn't a PNG.

+ *

+ * The function check_if_png() shown here, but not used, returns nonzero (true)

+ * if the file can be opened and is a PNG, 0 (false) otherwise.

+ *

+ * If this call is successful, and you are going to keep the file open,

+ * you should call png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK); once

+ * you have created the png_ptr, so that libpng knows your application

+ * has read that many bytes from the start of the file.  Make sure you

+ * don't call png_set_sig_bytes() with more than 8 bytes read or give it

+ * an incorrect number of bytes read, or you will either have read too

+ * many bytes (your fault), or you are telling libpng to read the wrong

+ * number of magic bytes (also your fault).

+ *

+ * Many applications already read the first 2 or 4 bytes from the start

+ * of the image to determine the file type, so it would be easiest just

+ * to pass the bytes to png_sig_cmp() or even skip that if you know

+ * you have a PNG file, and call png_set_sig_bytes().

+ */

+#define PNG_BYTES_TO_CHECK 4

+int check_if_png(char *file_name, FILE **fp)

+{

+   char buf[PNG_BYTES_TO_CHECK];

+   /* Open the prospective PNG file. */

+   if ((*fp = fopen(file_name, "rb")) == NULL)

+      return 0;

+   /* Read in some of the signature bytes */

+   if (fread(buf, 1, PNG_BYTES_TO_CHECK, *fp) != PNG_BYTES_TO_CHECK)

+      return 0;

+   /* Compare the first PNG_BYTES_TO_CHECK bytes of the signature.

+      Return nonzero (true) if they match */

+   return(!png_sig_cmp(buf, (png_size_t)0, PNG_BYTES_TO_CHECK));

+}

+/* Read a PNG file.  You may want to return an error code if the read

+ * fails (depending upon the failure).  There are two "prototypes" given

+ * here - one where we are given the filename, and we need to open the

+ * file, and the other where we are given an open file (possibly with

+ * some or all of the magic bytes read - see comments above).

+ */

+#ifdef open_file /* prototype 1 */

+void read_png(char *file_name)  /* We need to open the file */

+{

+   png_structp png_ptr;

+   png_infop info_ptr;

+   unsigned int sig_read = 0;

+   png_uint_32 width, height;

+   int bit_depth, color_type, interlace_type;

+   FILE *fp;

+   if ((fp = fopen(file_name, "rb")) == NULL)

+      return (ERROR);

+#else no_open_file /* prototype 2 */

+void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */

+{

+   png_structp png_ptr;

+   png_infop info_ptr;

+   png_uint_32 width, height;

+   int bit_depth, color_type, interlace_type;

+#endif no_open_file /* only use one prototype! */

+   /* Create and initialize the png_struct with the desired error handler

+    * functions.  If you want to use the default stderr and longjump method,

+    * you can supply NULL for the last three parameters.  We also supply the

+    * the compiler header file version, so that we know if the application

+    * was compiled with a compatible version of the library.  REQUIRED

+    */

+   png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,

+      png_voidp user_error_ptr, user_error_fn, user_warning_fn);

+   if (png_ptr == NULL)

+   {

+      fclose(fp);

+      return (ERROR);

+   }

+   /* Allocate/initialize the memory for image information.  REQUIRED. */

+   info_ptr = png_create_info_struct(png_ptr);

+   if (info_ptr == NULL)

+   {

+      fclose(fp);

+      png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);

+      return (ERROR);

+   }

+   /* Set error handling if you are using the setjmp/longjmp method (this is

+    * the normal method of doing things with libpng).  REQUIRED unless you

+    * set up your own error handlers in the png_create_read_struct() earlier.

+    */

+   if (setjmp(png_jmpbuf(png_ptr)))

+   {

+      /* Free all of the memory associated with the png_ptr and info_ptr */

+      png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);

+      fclose(fp);

+      /* If we get here, we had a problem reading the file */

+      return (ERROR);

+   }

+   /* One of the following I/O initialization methods is REQUIRED */

+#ifdef streams /* PNG file I/O method 1 */

+   /* Set up the input control if you are using standard C streams */

+   png_init_io(png_ptr, fp);

+#else no_streams /* PNG file I/O method 2 */

+   /* If you are using replacement read functions, instead of calling

+    * png_init_io() here you would call:

+    */

+   png_set_read_fn(png_ptr, (void *)user_io_ptr, user_read_fn);

+   /* where user_io_ptr is a structure you want available to the callbacks */

+#endif no_streams /* Use only one I/O method! */

+   /* If we have already read some of the signature */

+   png_set_sig_bytes(png_ptr, sig_read);

+#ifdef hilevel

+   /*

+    * If you have enough memory to read in the entire image at once,

+    * and you need to specify only transforms that can be controlled

+    * with one of the PNG_TRANSFORM_* bits (this presently excludes

+    * dithering, filling, setting background, and doing gamma

+    * adjustment), then you can read the entire image (including

+    * pixels) into the info structure with this call:

+    */

+   png_read_png(png_ptr, info_ptr, png_transforms, png_voidp_NULL);

+#else

+   /* OK, you're doing it the hard way, with the lower-level functions */

+   /* The call to png_read_info() gives us all of the information from the

+    * PNG file before the first IDAT (image data chunk).  REQUIRED

+    */

+   png_read_info(png_ptr, info_ptr);

+   png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,

+       &interlace_type, int_p_NULL, int_p_NULL);

+/* Set up the data transformations you want.  Note that these are all

+ * optional.  Only call them if you want/need them.  Many of the

+ * transformations only work on specific types of images, and many

+ * are mutually exclusive.

+ */

+   /* tell libpng to strip 16 bit/color files down to 8 bits/color */

+   png_set_strip_16(png_ptr);

+   /* Strip alpha bytes from the input data without combining with the

+    * background (not recommended).

+    */

+   png_set_strip_alpha(png_ptr);

+   /* Extract multiple pixels with bit depths of 1, 2, and 4 from a single

+    * byte into separate bytes (useful for paletted and grayscale images).

+    */

+   png_set_packing(png_ptr);

+   /* Change the order of packed pixels to least significant bit first

+    * (not useful if you are using png_set_packing). */

+   png_set_packswap(png_ptr);

+   /* Expand paletted colors into true RGB triplets */

+   if (color_type == PNG_COLOR_TYPE_PALETTE)

+      png_set_palette_rgb(png_ptr);

+   /* Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */

+   if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)

+      png_set_gray_1_2_4_to_8(png_ptr);

+   /* Expand paletted or RGB images with transparency to full alpha channels

+    * so the data will be available as RGBA quartets.

+    */

+   if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))

+      png_set_tRNS_to_alpha(png_ptr);

+   /* Set the background color to draw transparent and alpha images over.

+    * It is possible to set the red, green, and blue components directly

+    * for paletted images instead of supplying a palette index.  Note that

+    * even if the PNG file supplies a background, you are not required to

+    * use it - you should use the (solid) application background if it has one.

+    */

+   png_color_16 my_background, *image_background;

+   if (png_get_bKGD(png_ptr, info_ptr, &image_background))

+      png_set_background(png_ptr, image_background,

+                         PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);

+   else

+      png_set_background(png_ptr, &my_background,

+                         PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);

+   /* Some suggestions as to how to get a screen gamma value */

+   /* Note that screen gamma is the display_exponent, which includes

+    * the CRT_exponent and any correction for viewing conditions */

+   if (/* We have a user-defined screen gamma value */)

+   {

+      screen_gamma = user-defined screen_gamma;

+   }

+   /* This is one way that applications share the same screen gamma value */

+   else if ((gamma_str = getenv("SCREEN_GAMMA")) != NULL)

+   {

+      screen_gamma = atof(gamma_str);

+   }

+   /* If we don't have another value */

+   else

+   {

+      screen_gamma = 2.2;  /* A good guess for a PC monitors in a dimly

+                              lit room */

+      screen_gamma = 1.7 or 1.0;  /* A good guess for Mac systems */

+   }

+   /* Tell libpng to handle the gamma conversion for you.  The final call

+    * is a good guess for PC generated images, but it should be configurable

+    * by the user at run time by the user.  It is strongly suggested that

+    * your application support gamma correction.

+    */

+   int intent;

+   if (png_get_sRGB(png_ptr, info_ptr, &intent))

+      png_set_gamma(png_ptr, screen_gamma, 0.45455);

+   else

+   {

+      double image_gamma;

+      if (png_get_gAMA(png_ptr, info_ptr, &image_gamma))

+         png_set_gamma(png_ptr, screen_gamma, image_gamma);

+      else

+         png_set_gamma(png_ptr, screen_gamma, 0.45455);

+   }

+   /* Dither RGB files down to 8 bit palette or reduce palettes

+    * to the number of colors available on your screen.

+    */

+   if (color_type & PNG_COLOR_MASK_COLOR)

+   {

+      int num_palette;

+      png_colorp palette;

+      /* This reduces the image to the application supplied palette */

+      if (/* we have our own palette */)

+      {

+         /* An array of colors to which the image should be dithered */

+         png_color std_color_cube[MAX_SCREEN_COLORS];

+         png_set_dither(png_ptr, std_color_cube, MAX_SCREEN_COLORS,

+            MAX_SCREEN_COLORS, png_uint_16p_NULL, 0);

+      }

+      /* This reduces the image to the palette supplied in the file */

+      else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette))

+      {

+         png_uint_16p histogram = NULL;

+         png_get_hIST(png_ptr, info_ptr, &histogram);

+         png_set_dither(png_ptr, palette, num_palette,

+                        max_screen_colors, histogram, 0);

+      }

+   }

+   /* invert monochrome files to have 0 as white and 1 as black */

+   png_set_invert_mono(png_ptr);

+   /* If you want to shift the pixel values from the range [0,255] or

+    * [0,65535] to the original [0,7] or [0,31], or whatever range the

+    * colors were originally in:

+    */

+   if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))

+   {

+      png_color_8p sig_bit;

+      png_get_sBIT(png_ptr, info_ptr, &sig_bit);

+      png_set_shift(png_ptr, sig_bit);

+   }

+   /* flip the RGB pixels to BGR (or RGBA to BGRA) */

+   if (color_type & PNG_COLOR_MASK_COLOR)

+      png_set_bgr(png_ptr);

+   /* swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */

+   png_set_swap_alpha(png_ptr);

+   /* swap bytes of 16 bit files to least significant byte first */

+   png_set_swap(png_ptr);

+   /* Add filler (or alpha) byte (before/after each RGB triplet) */

+   png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);

+   /* Turn on interlace handling.  REQUIRED if you are not using

+    * png_read_image().  To see how to handle interlacing passes,

+    * see the png_read_row() method below:

+    */

+   number_passes = png_set_interlace_handling(png_ptr);

+   /* Optional call to gamma correct and add the background to the palette

+    * and update info structure.  REQUIRED if you are expecting libpng to

+    * update the palette for you (ie you selected such a transform above).

+    */

+   png_read_update_info(png_ptr, info_ptr);

+   /* Allocate the memory to hold the image using the fields of info_ptr. */

+   /* The easiest way to read the image: */

+   png_bytep row_pointers[height];

+   for (row = 0; row < height; row++)

+   {

+      row_pointers[row] = png_malloc(png_ptr, png_get_rowbytes(png_ptr,

+         info_ptr));

+   }

+   /* Now it's time to read the image.  One of these methods is REQUIRED */

+#ifdef entire /* Read the entire image in one go */

+   png_read_image(png_ptr, row_pointers);

+#else no_entire /* Read the image one or more scanlines at a time */

+   /* The other way to read images - deal with interlacing: */

+   for (pass = 0; pass < number_passes; pass++)

+   {

+#ifdef single /* Read the image a single row at a time */

+      for (y = 0; y < height; y++)

+      {

+         png_read_rows(png_ptr, &row_pointers[y], png_bytepp_NULL, 1);

+      }

+#else no_single /* Read the image several rows at a time */

+      for (y = 0; y < height; y += number_of_rows)

+      {

+#ifdef sparkle /* Read the image using the "sparkle" effect. */

+         png_read_rows(png_ptr, &row_pointers[y], png_bytepp_NULL,

+            number_of_rows);

+#else no_sparkle /* Read the image using the "rectangle" effect */

+         png_read_rows(png_ptr, png_bytepp_NULL, &row_pointers[y],

+            number_of_rows);

+#endif no_sparkle /* use only one of these two methods */

+      }

+      /* if you want to display the image after every pass, do

+         so here */

+#endif no_single /* use only one of these two methods */

+   }

+#endif no_entire /* use only one of these two methods */

+   /* read rest of file, and get additional chunks in info_ptr - REQUIRED */

+   png_read_end(png_ptr, info_ptr);

+#endif hilevel

+   /* At this point you have read the entire image */

+   /* clean up after the read, and free any memory allocated - REQUIRED */

+   png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);

+   /* close the file */

+   fclose(fp);

+   /* that's it */

+   return (OK);

+}

+/* progressively read a file */

+int

+initialize_png_reader(png_structp *png_ptr, png_infop *info_ptr)

+{

+   /* Create and initialize the png_struct with the desired error handler

+    * functions.  If you want to use the default stderr and longjump method,

+    * you can supply NULL for the last three parameters.  We also check that

+    * the library version is compatible in case we are using dynamically

+    * linked libraries.

+    */

+   *png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,

+       png_voidp user_error_ptr, user_error_fn, user_warning_fn);

+   if (*png_ptr == NULL)

+   {

+      *info_ptr = NULL;

+      return (ERROR);

+   }

+   *info_ptr = png_create_info_struct(png_ptr);

+   if (*info_ptr == NULL)

+   {

+      png_destroy_read_struct(png_ptr, info_ptr, png_infopp_NULL);

+      return (ERROR);

+   }

+   if (setjmp(png_jmpbuf((*png_ptr))))

+   {

+      png_destroy_read_struct(png_ptr, info_ptr, png_infopp_NULL);

+      return (ERROR);

+   }

+   /* This one's new.  You will need to provide all three

+    * function callbacks, even if you aren't using them all.

+    * If you aren't using all functions, you can specify NULL

+    * parameters.  Even when all three functions are NULL,

+    * you need to call png_set_progressive_read_fn().

+    * These functions shouldn't be dependent on global or

+    * static variables if you are decoding several images

+    * simultaneously.  You should store stream specific data

+    * in a separate struct, given as the second parameter,

+    * and retrieve the pointer from inside the callbacks using

+    * the function png_get_progressive_ptr(png_ptr).

+    */

+   png_set_progressive_read_fn(*png_ptr, (void *)stream_data,

+      info_callback, row_callback, end_callback);

+   return (OK);

+}

+int

+process_data(png_structp *png_ptr, png_infop *info_ptr,

+   png_bytep buffer, png_uint_32 length)

+{

+   if (setjmp(png_jmpbuf((*png_ptr))))

+   {

+      /* Free the png_ptr and info_ptr memory on error */

+      png_destroy_read_struct(png_ptr, info_ptr, png_infopp_NULL);

+      return (ERROR);

+   }

+   /* This one's new also.  Simply give it chunks of data as

+    * they arrive from the data stream (in order, of course).

+    * On Segmented machines, don't give it any more than 64K.

+    * The library seems to run fine with sizes of 4K, although

+    * you can give it much less if necessary (I assume you can

+    * give it chunks of 1 byte, but I haven't tried with less

+    * than 256 bytes yet).  When this function returns, you may

+    * want to display any rows that were generated in the row

+    * callback, if you aren't already displaying them there.

+    */

+   png_process_data(*png_ptr, *info_ptr, buffer, length);

+   return (OK);

+}

+info_callback(png_structp png_ptr, png_infop info)

+{

+/* do any setup here, including setting any of the transformations

+ * mentioned in the Reading PNG files section.  For now, you _must_

+ * call either png_start_read_image() or png_read_update_info()

+ * after all the transformations are set (even if you don't set

+ * any).  You may start getting rows before png_process_data()

+ * returns, so this is your last chance to prepare for that.

+ */

+}

+row_callback(png_structp png_ptr, png_bytep new_row,

+   png_uint_32 row_num, int pass)

+{

+/*

+ * This function is called for every row in the image.  If the

+ * image is interlaced, and you turned on the interlace handler,

+ * this function will be called for every row in every pass.

+ *

+ * In this function you will receive a pointer to new row data from

+ * libpng called new_row that is to replace a corresponding row (of

+ * the same data format) in a buffer allocated by your application.

+ *

+ * The new row data pointer new_row may be NULL, indicating there is

+ * no new data to be replaced (in cases of interlace loading).

+ *

+ * If new_row is not NULL then you need to call

+ * png_progressive_combine_row() to replace the corresponding row as

+ * shown below:

+ */

+   /* Check if row_num is in bounds. */

+   if((row_num >= 0) && (row_num < height))

+   {

+     /* Get pointer to corresponding row in our

+      * PNG read buffer.

+      */

+     png_bytep old_row = ((png_bytep *)our_data)[row_num];

+     /* If both rows are allocated then copy the new row

+      * data to the corresponding row data.

+      */

+     if((old_row != NULL) && (new_row != NULL))

+     png_progressive_combine_row(png_ptr, old_row, new_row);

+   }

+/*

+ * The rows and passes are called in order, so you don't really

+ * need the row_num and pass, but I'm supplying them because it

+ * may make your life easier.

+ *

+ * For the non-NULL rows of interlaced images, you must call

+ * png_progressive_combine_row() passing in the new row and the

+ * old row, as demonstrated above.  You can call this function for

+ * NULL rows (it will just return) and for non-interlaced images

+ * (it just does the png_memcpy for you) if it will make the code

+ * easier.  Thus, you can just do this for all cases:

+ */

+   png_progressive_combine_row(png_ptr, old_row, new_row);

+/* where old_row is what was displayed for previous rows.  Note

+ * that the first pass (pass == 0 really) will completely cover

+ * the old row, so the rows do not have to be initialized.  After

+ * the first pass (and only for interlaced images), you will have

+ * to pass the current row as new_row, and the function will combine

+ * the old row and the new row.

+ */

+}

+end_callback(png_structp png_ptr, png_infop info)

+{

+/* this function is called when the whole image has been read,

+ * including any chunks after the image (up to and including

+ * the IEND).  You will usually have the same info chunk as you

+ * had in the header, although some data may have been added

+ * to the comments and time fields.

+ *

+ * Most people won't do much here, perhaps setting a flag that

+ * marks the image as finished.

+ */

+}

+/* write a png file */

+void write_png(char *file_name /* , ... other image information ... */)

+{

+   FILE *fp;

+   png_structp png_ptr;

+   png_infop info_ptr;

+   png_colorp palette;

+   /* open the file */

+   fp = fopen(file_name, "wb");

+   if (fp == NULL)

+      return (ERROR);

+   /* Create and initialize the png_struct with the desired error handler

+    * functions.  If you want to use the default stderr and longjump method,

+    * you can supply NULL for the last three parameters.  We also check that

+    * the library version is compatible with the one used at compile time,

+    * in case we are using dynamically linked libraries.  REQUIRED.

+    */

+   png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,

+      png_voidp user_error_ptr, user_error_fn, user_warning_fn);

+   if (png_ptr == NULL)

+   {

+      fclose(fp);

+      return (ERROR);

+   }

+   /* Allocate/initialize the image information data.  REQUIRED */

+   info_ptr = png_create_info_struct(png_ptr);

+   if (info_ptr == NULL)

+   {

+      fclose(fp);

+      png_destroy_write_struct(&png_ptr,  png_infopp_NULL);

+      return (ERROR);

+   }

+   /* Set error handling.  REQUIRED if you aren't supplying your own

+    * error handling functions in the png_create_write_struct() call.

+    */

+   if (setjmp(png_jmpbuf(png_ptr)))

+   {

+      /* If we get here, we had a problem reading the file */

+      fclose(fp);

+      png_destroy_write_struct(&png_ptr, &info_ptr);

+      return (ERROR);

+   }

+   /* One of the following I/O initialization functions is REQUIRED */

+#ifdef streams /* I/O initialization method 1 */

+   /* set up the output control if you are using standard C streams */

+   png_init_io(png_ptr, fp);

+#else no_streams /* I/O initialization method 2 */

+   /* If you are using replacement read functions, instead of calling

+    * png_init_io() here you would call */

+   png_set_write_fn(png_ptr, (void *)user_io_ptr, user_write_fn,

+      user_IO_flush_function);

+   /* where user_io_ptr is a structure you want available to the callbacks */

+#endif no_streams /* only use one initialization method */

+#ifdef hilevel

+   /* This is the easy way.  Use it if you already have all the

+    * image info living info in the structure.  You could "|" many

+    * PNG_TRANSFORM flags into the png_transforms integer here.

+    */

+   png_write_png(png_ptr, info_ptr, png_transforms, png_voidp_NULL);

+#else

+   /* This is the hard way */

+   /* Set the image information here.  Width and height are up to 2^31,

+    * bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on

+    * the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,

+    * PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,

+    * or PNG_COLOR_TYPE_RGB_ALPHA.  interlace is either PNG_INTERLACE_NONE or

+    * PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST

+    * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED

+    */

+   png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, PNG_COLOR_TYPE_???,

+      PNG_INTERLACE_????, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);

+   /* set the palette if there is one.  REQUIRED for indexed-color images */

+   palette = (png_colorp)png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH

+             * png_sizeof (png_color));

+   /* ... set palette colors ... */

+   png_set_PLTE(png_ptr, info_ptr, palette, PNG_MAX_PALETTE_LENGTH);

+   /* You must not free palette here, because png_set_PLTE only makes a link to

+      the palette that you malloced.  Wait until you are about to destroy

+      the png structure. */

+   /* optional significant bit chunk */

+   /* if we are dealing with a grayscale image then */

+   sig_bit.gray = true_bit_depth;

+   /* otherwise, if we are dealing with a color image then */

+   sig_bit.red = true_red_bit_depth;

+   sig_bit.green = true_green_bit_depth;

+   sig_bit.blue = true_blue_bit_depth;

+   /* if the image has an alpha channel then */

+   sig_bit.alpha = true_alpha_bit_depth;

+   png_set_sBIT(png_ptr, info_ptr, sig_bit);

+   /* Optional gamma chunk is strongly suggested if you have any guess

+    * as to the correct gamma of the image.

+    */

+   png_set_gAMA(png_ptr, info_ptr, gamma);

+   /* Optionally write comments into the image */

+   text_ptr[0].key = "Title";

+   text_ptr[0].text = "Mona Lisa";

+   text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE;

+   text_ptr[1].key = "Author";

+   text_ptr[1].text = "Leonardo DaVinci";

+   text_ptr[1].compression = PNG_TEXT_COMPRESSION_NONE;

+   text_ptr[2].key = "Description";

+   text_ptr[2].text = "<long text>";

+   text_ptr[2].compression = PNG_TEXT_COMPRESSION_zTXt;

+#ifdef PNG_iTXt_SUPPORTED

+   text_ptr[0].lang = NULL;

+   text_ptr[1].lang = NULL;

+   text_ptr[2].lang = NULL;

+#endif

+   png_set_text(png_ptr, info_ptr, text_ptr, 3);

+   /* other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs, */

+   /* note that if sRGB is present the gAMA and cHRM chunks must be ignored

+    * on read and must be written in accordance with the sRGB profile */

+   /* Write the file header information.  REQUIRED */

+   png_write_info(png_ptr, info_ptr);

+   /* If you want, you can write the info in two steps, in case you need to

+    * write your private chunk ahead of PLTE:

+    *

+    *   png_write_info_before_PLTE(write_ptr, write_info_ptr);

+    *   write_my_chunk();

+    *   png_write_info(png_ptr, info_ptr);

+    *

+    * However, given the level of known- and unknown-chunk support in 1.1.0

+    * and up, this should no longer be necessary.

+    */

+   /* Once we write out the header, the compression type on the text

+    * chunks gets changed to PNG_TEXT_COMPRESSION_NONE_WR or

+    * PNG_TEXT_COMPRESSION_zTXt_WR, so it doesn't get written out again

+    * at the end.

+    */

+   /* set up the transformations you want.  Note that these are

+    * all optional.  Only call them if you want them.

+    */

+   /* invert monochrome pixels */

+   png_set_invert_mono(png_ptr);

+   /* Shift the pixels up to a legal bit depth and fill in

+    * as appropriate to correctly scale the image.

+    */

+   png_set_shift(png_ptr, &sig_bit);

+   /* pack pixels into bytes */

+   png_set_packing(png_ptr);

+   /* swap location of alpha bytes from ARGB to RGBA */

+   png_set_swap_alpha(png_ptr);

+   /* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into

+    * RGB (4 channels -> 3 channels). The second parameter is not used.

+    */

+   png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);

+   /* flip BGR pixels to RGB */

+   png_set_bgr(png_ptr);

+   /* swap bytes of 16-bit files to most significant byte first */

+   png_set_swap(png_ptr);

+   /* swap bits of 1, 2, 4 bit packed pixel formats */

+   png_set_packswap(png_ptr);

+   /* turn on interlace handling if you are not using png_write_image() */

+   if (interlacing)

+      number_passes = png_set_interlace_handling(png_ptr);

+   else

+      number_passes = 1;

+   /* The easiest way to write the image (you may have a different memory

+    * layout, however, so choose what fits your needs best).  You need to

+    * use the first method if you aren't handling interlacing yourself.

+    */

+   png_uint_32 k, height, width;

+   png_byte image[height][width*bytes_per_pixel];

+   png_bytep row_pointers[height];

+   if (height > PNG_UINT_32_MAX/png_sizeof(png_bytep))

+     png_error (png_ptr, "Image is too tall to process in memory");

+   for (k = 0; k < height; k++)

+     row_pointers[k] = image + k*width*bytes_per_pixel;

+   /* One of the following output methods is REQUIRED */

+#ifdef entire /* write out the entire image data in one call */

+   png_write_image(png_ptr, row_pointers);

+   /* the other way to write the image - deal with interlacing */

+#else no_entire /* write out the image data by one or more scanlines */

+   /* The number of passes is either 1 for non-interlaced images,

+    * or 7 for interlaced images.

+    */

+   for (pass = 0; pass < number_passes; pass++)

+   {

+      /* Write a few rows at a time. */

+      png_write_rows(png_ptr, &row_pointers[first_row], number_of_rows);

+      /* If you are only writing one row at a time, this works */

+      for (y = 0; y < height; y++)

+      {

+         png_write_rows(png_ptr, &row_pointers[y], 1);

+      }

+   }

+#endif no_entire /* use only one output method */

+   /* You can write optional chunks like tEXt, zTXt, and tIME at the end

+    * as well.  Shouldn't be necessary in 1.1.0 and up as all the public

+    * chunks are supported and you can use png_set_unknown_chunks() to

+    * register unknown chunks into the info structure to be written out.

+    */

+   /* It is REQUIRED to call this to finish writing the rest of the file */

+   png_write_end(png_ptr, info_ptr);

+#endif hilevel

+   /* If you png_malloced a palette, free it here (don't free info_ptr->palette,

+      as recommended in versions 1.0.5m and earlier of this example; if

+      libpng mallocs info_ptr->palette, libpng will free it).  If you

+      allocated it with malloc() instead of png_malloc(), use free() instead

+      of png_free(). */

+   png_free(png_ptr, palette);

+   palette=NULL;

+   /* Similarly, if you png_malloced any data that you passed in with

+      png_set_something(), such as a hist or trans array, free it here,

+      when you can be sure that libpng is through with it. */

+   png_free(png_ptr, trans);

+   trans=NULL;

+   /* clean up after the write, and free any memory allocated */

+   png_destroy_write_struct(&png_ptr, &info_ptr);

+   /* close the file */

+   fclose(fp);

+   /* that's it */

+   return (OK);

+}

+#endif /* if 0 */

--- /dev/null

+++ b/src/gfx/libpng/libpng.3.man

@@ -1,0 +1,4022 @@

+.TH LIBPNG 3 "December 3, 2004"

+.SH NAME

+libpng \- Portable Network Graphics (PNG) Reference Library 1.2.8

+.SH SYNOPSIS

+\fI\fB

+\fB#include <png.h>\fP

+\fI\fB

+\fBpng_uint_32 png_access_version_number \fI(void\fP\fB);\fP

+\fI\fB

+\fBint png_check_sig (png_bytep \fP\fIsig\fP\fB, int \fInum\fP\fB);\fP

+\fI\fB

+\fBvoid png_chunk_error (png_structp \fP\fIpng_ptr\fP\fB, png_const_charp \fIerror\fP\fB);\fP

+\fI\fB

+\fBvoid png_chunk_warning (png_structp \fP\fIpng_ptr\fP\fB, png_const_charp \fImessage\fP\fB);\fP

+\fI\fB

+\fBvoid png_convert_from_struct_tm (png_timep \fP\fIptime\fP\fB, struct tm FAR * \fIttime\fP\fB);\fP

+\fI\fB

+\fBvoid png_convert_from_time_t (png_timep \fP\fIptime\fP\fB, time_t \fIttime\fP\fB);\fP

+\fI\fB

+\fBpng_charp png_convert_to_rfc1123 (png_structp \fP\fIpng_ptr\fP\fB, png_timep \fIptime\fP\fB);\fP

+\fI\fB

+\fBpng_infop png_create_info_struct (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_structp png_create_read_struct (png_const_charp \fP\fIuser_png_ver\fP\fB, png_voidp \fP\fIerror_ptr\fP\fB, png_error_ptr \fP\fIerror_fn\fP\fB, png_error_ptr \fIwarn_fn\fP\fB);\fP

+\fI\fB

+\fBpng_structp png_create_read_struct_2(png_const_charp \fP\fIuser_png_ver\fP\fB, png_voidp \fP\fIerror_ptr\fP\fB, png_error_ptr \fP\fIerror_fn\fP\fB, png_error_ptr \fP\fIwarn_fn\fP\fB, png_voidp \fP\fImem_ptr\fP\fB, png_malloc_ptr \fP\fImalloc_fn\fP\fB, png_free_ptr \fIfree_fn\fP\fB);\fP

+\fI\fB

+\fBpng_structp png_create_write_struct (png_const_charp \fP\fIuser_png_ver\fP\fB, png_voidp \fP\fIerror_ptr\fP\fB, png_error_ptr \fP\fIerror_fn\fP\fB, png_error_ptr \fIwarn_fn\fP\fB);\fP

+\fI\fB

+\fBpng_structp png_create_write_struct_2(png_const_charp \fP\fIuser_png_ver\fP\fB, png_voidp \fP\fIerror_ptr\fP\fB, png_error_ptr \fP\fIerror_fn\fP\fB, png_error_ptr \fP\fIwarn_fn\fP\fB, png_voidp \fP\fImem_ptr\fP\fB, png_malloc_ptr \fP\fImalloc_fn\fP\fB, png_free_ptr \fIfree_fn\fP\fB);\fP

+\fI\fB

+\fBint png_debug(int \fP\fIlevel\fP\fB, png_const_charp \fImessage\fP\fB);\fP

+\fI\fB

+\fBint png_debug1(int \fP\fIlevel\fP\fB, png_const_charp \fP\fImessage\fP\fB, \fIp1\fP\fB);\fP

+\fI\fB

+\fBint png_debug2(int \fP\fIlevel\fP\fB, png_const_charp \fP\fImessage\fP\fB, \fP\fIp1\fP\fB, \fIp2\fP\fB);\fP

+\fI\fB

+\fBvoid png_destroy_info_struct (png_structp \fP\fIpng_ptr\fP\fB, png_infopp \fIinfo_ptr_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_destroy_read_struct (png_structpp \fP\fIpng_ptr_ptr\fP\fB, png_infopp \fP\fIinfo_ptr_ptr\fP\fB, png_infopp \fIend_info_ptr_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_destroy_write_struct (png_structpp \fP\fIpng_ptr_ptr\fP\fB, png_infopp \fIinfo_ptr_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_error (png_structp \fP\fIpng_ptr\fP\fB, png_const_charp \fIerror\fP\fB);\fP

+\fI\fB

+\fBvoid png_free (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fIptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_free_chunk_list (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_free_default(png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fIptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_free_data (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fInum\fP\fB);\fP

+\fI\fB

+\fBpng_byte png_get_bit_depth (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_bKGD (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_color_16p \fI*background\fP\fB);\fP

+\fI\fB

+\fBpng_byte png_get_channels (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_cHRM (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, double \fP\fI*white_x\fP\fB, double \fP\fI*white_y\fP\fB, double \fP\fI*red_x\fP\fB, double \fP\fI*red_y\fP\fB, double \fP\fI*green_x\fP\fB, double \fP\fI*green_y\fP\fB, double \fP\fI*blue_x\fP\fB, double \fI*blue_y\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_cHRM_fixed (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fI*white_x\fP\fB, png_uint_32 \fP\fI*white_y\fP\fB, png_uint_32 \fP\fI*red_x\fP\fB, png_uint_32 \fP\fI*red_y\fP\fB, png_uint_32 \fP\fI*green_x\fP\fB, png_uint_32 \fP\fI*green_y\fP\fB, png_uint_32 \fP\fI*blue_x\fP\fB, png_uint_32 \fI*blue_y\fP\fB);\fP

+\fI\fB

+\fBpng_byte png_get_color_type (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_byte png_get_compression_type (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_byte png_get_copyright (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_voidp png_get_error_ptr (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_byte png_get_filter_type (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_gAMA (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, double \fI*file_gamma\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_gAMA_fixed (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fI*int_file_gamma\fP\fB);\fP

+\fI\fB

+\fBpng_byte png_get_header_ver (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_byte png_get_header_version (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_hIST (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_16p \fI*hist\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_iCCP (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_charpp \fP\fIname\fP\fB, int \fP\fI*compression_type\fP\fB, png_charpp \fP\fIprofile\fP\fB, png_uint_32 \fI*proflen\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_IHDR (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fI*width\fP\fB, png_uint_32 \fP\fI*height\fP\fB, int \fP\fI*bit_depth\fP\fB, int \fP\fI*color_type\fP\fB, int \fP\fI*interlace_type\fP\fB, int \fP\fI*compression_type\fP\fB, int \fI*filter_type\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_image_height (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_image_width (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_byte png_get_interlace_type (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_voidp png_get_io_ptr (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_byte png_get_libpng_ver (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_voidp png_get_mem_ptr(png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_oFFs (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fI*offset_x\fP\fB, png_uint_32 \fP\fI*offset_y\fP\fB, int \fI*unit_type\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_pCAL (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_charp \fP\fI*purpose\fP\fB, png_int_32 \fP\fI*X0\fP\fB, png_int_32 \fP\fI*X1\fP\fB, int \fP\fI*type\fP\fB, int \fP\fI*nparams\fP\fB, png_charp \fP\fI*units\fP\fB, png_charpp \fI*params\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_pHYs (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fI*res_x\fP\fB, png_uint_32 \fP\fI*res_y\fP\fB, int \fI*unit_type\fP\fB);\fP

+\fI\fB

+\fBfloat png_get_pixel_aspect_ratio (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_pixels_per_meter (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_voidp png_get_progressive_ptr (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_PLTE (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_colorp \fP\fI*palette\fP\fB, int \fI*num_palette\fP\fB);\fP

+\fI\fB

+\fBpng_byte png_get_rgb_to_gray_status (png_structp \fIpng_ptr)

+\fBpng_uint_32 png_get_rowbytes (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_bytepp png_get_rows (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_sBIT (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_color_8p \fI*sig_bit\fP\fB);\fP

+\fI\fB

+\fBpng_bytep png_get_signature (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_sPLT (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_spalette_p \fI*splt_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_sRGB (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fI*intent\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_text (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_textp \fP\fI*text_ptr\fP\fB, int \fI*num_text\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_tIME (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_timep \fI*mod_time\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_tRNS (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_bytep \fP\fI*trans\fP\fB, int \fP\fI*num_trans\fP\fB, png_color_16p \fI*trans_values\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_unknown_chunks (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_unknown_chunkpp \fIunknowns\fP\fB);\fP

+\fI\fB

+\fBpng_voidp png_get_user_chunk_ptr (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_user_height_max( png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_voidp png_get_user_transform_ptr (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_user_width_max (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_valid (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIflag\fP\fB);\fP

+\fI\fB

+\fBpng_int_32 png_get_x_offset_microns (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_int_32 png_get_x_offset_pixels (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_x_pixels_per_meter (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_int_32 png_get_y_offset_microns (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_int_32 png_get_y_offset_pixels (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_y_pixels_per_meter (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_get_compression_buffer_size (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBint png_handle_as_unknown (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fIchunk_name\fP\fB);\fP

+\fI\fB

+\fBvoid png_init_io (png_structp \fP\fIpng_ptr\fP\fB, FILE \fI*fp\fP\fB);\fP

+\fI\fB

+\fBDEPRECATED: void png_info_init (png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBDEPRECATED: void png_info_init_2 (png_infopp \fP\fIptr_ptr\fP\fB, png_size_t \fIpng_info_struct_size\fP\fB);\fP

+\fI\fB

+\fBpng_voidp png_malloc (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fIsize\fP\fB);\fP

+\fI\fB

+\fBpng_voidp png_malloc_default(png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fIsize\fP\fB);\fP

+\fI\fB

+\fBvoidp png_memcpy (png_voidp \fP\fIs1\fP\fB, png_voidp \fP\fIs2\fP\fB, png_size_t \fIsize\fP\fB);\fP

+\fI\fB

+\fBpng_voidp png_memcpy_check (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fIs1\fP\fB, png_voidp \fP\fIs2\fP\fB, png_uint_32 \fIsize\fP\fB);\fP

+\fI\fB

+\fBvoidp png_memset (png_voidp \fP\fIs1\fP\fB, int \fP\fIvalue\fP\fB, png_size_t \fIsize\fP\fB);\fP

+\fI\fB

+\fBpng_voidp png_memset_check (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fIs1\fP\fB, int \fP\fIvalue\fP\fB, png_uint_32 \fIsize\fP\fB);\fP

+\fI\fB

+\fBDEPRECATED: void png_permit_empty_plte (png_structp \fP\fIpng_ptr\fP\fB, int \fIempty_plte_permitted\fP\fB);\fP

+\fI\fB

+\fBvoid png_process_data (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_bytep \fP\fIbuffer\fP\fB, png_size_t \fIbuffer_size\fP\fB);\fP

+\fI\fB

+\fBvoid png_progressive_combine_row (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIold_row\fP\fB, png_bytep \fInew_row\fP\fB);\fP

+\fI\fB

+\fBvoid png_read_destroy (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_infop \fIend_info_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_read_end (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_read_image (png_structp \fP\fIpng_ptr\fP\fB, png_bytepp \fIimage\fP\fB);\fP

+\fI\fB

+\fBDEPRECATED: void png_read_init (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBDEPRECATED: void png_read_init_2 (png_structpp \fP\fIptr_ptr\fP\fB, png_const_charp \fP\fIuser_png_ver\fP\fB, png_size_t \fP\fIpng_struct_size\fP\fB, png_size_t \fIpng_info_size\fP\fB);\fP

+\fI\fB

+\fBvoid png_read_info (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_read_png (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fP\fItransforms\fP\fB, png_voidp \fIparams\fP\fB);\fP

+\fI\fB

+\fBvoid png_read_row (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIrow\fP\fB, png_bytep \fIdisplay_row\fP\fB);\fP

+\fI\fB

+\fBvoid png_read_rows (png_structp \fP\fIpng_ptr\fP\fB, png_bytepp \fP\fIrow\fP\fB, png_bytepp \fP\fIdisplay_row\fP\fB, png_uint_32 \fInum_rows\fP\fB);\fP

+\fI\fB

+\fBvoid png_read_update_info (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fB#if \fI!defined(PNG_1_0_X)

+\fBvoid png_set_add_alpha (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fP\fIfiller\fP\fB, int \fIflags\fP\fB);\fP

+\fI\fB#endif

+\fI\fB

+\fBvoid png_set_background (png_structp \fP\fIpng_ptr\fP\fB, png_color_16p \fP\fIbackground_color\fP\fB, int \fP\fIbackground_gamma_code\fP\fB, int \fP\fIneed_expand\fP\fB, double \fIbackground_gamma\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_bgr (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_bKGD (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_color_16p \fIbackground\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_cHRM (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, double \fP\fIwhite_x\fP\fB, double \fP\fIwhite_y\fP\fB, double \fP\fIred_x\fP\fB, double \fP\fIred_y\fP\fB, double \fP\fIgreen_x\fP\fB, double \fP\fIgreen_y\fP\fB, double \fP\fIblue_x\fP\fB, double \fIblue_y\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_cHRM_fixed (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fIwhite_x\fP\fB, png_uint_32 \fP\fIwhite_y\fP\fB, png_uint_32 \fP\fIred_x\fP\fB, png_uint_32 \fP\fIred_y\fP\fB, png_uint_32 \fP\fIgreen_x\fP\fB, png_uint_32 \fP\fIgreen_y\fP\fB, png_uint_32 \fP\fIblue_x\fP\fB, png_uint_32 \fIblue_y\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_compression_level (png_structp \fP\fIpng_ptr\fP\fB, int \fIlevel\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_compression_mem_level (png_structp \fP\fIpng_ptr\fP\fB, int \fImem_level\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_compression_method (png_structp \fP\fIpng_ptr\fP\fB, int \fImethod\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_compression_strategy (png_structp \fP\fIpng_ptr\fP\fB, int \fIstrategy\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_compression_window_bits (png_structp \fP\fIpng_ptr\fP\fB, int \fIwindow_bits\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_crc_action (png_structp \fP\fIpng_ptr\fP\fB, int \fP\fIcrit_action\fP\fB, int \fIancil_action\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_dither (png_structp \fP\fIpng_ptr\fP\fB, png_colorp \fP\fIpalette\fP\fB, int \fP\fInum_palette\fP\fB, int \fP\fImaximum_colors\fP\fB, png_uint_16p \fP\fIhistogram\fP\fB, int \fIfull_dither\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_error_fn (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fIerror_ptr\fP\fB, png_error_ptr \fP\fIerror_fn\fP\fB, png_error_ptr \fIwarning_fn\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_expand (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_filler (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fP\fIfiller\fP\fB, int \fIflags\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_filter (png_structp \fP\fIpng_ptr\fP\fB, int \fP\fImethod\fP\fB, int \fIfilters\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_filter_heuristics (png_structp \fP\fIpng_ptr\fP\fB, int \fP\fIheuristic_method\fP\fB, int \fP\fInum_weights\fP\fB, png_doublep \fP\fIfilter_weights\fP\fB, png_doublep \fIfilter_costs\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_flush (png_structp \fP\fIpng_ptr\fP\fB, int \fInrows\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_gamma (png_structp \fP\fIpng_ptr\fP\fB, double \fP\fIscreen_gamma\fP\fB, double \fIdefault_file_gamma\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_gAMA (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, double \fIfile_gamma\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_gAMA_fixed (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIfile_gamma\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_gray_1_2_4_to_8(png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_gray_to_rgb (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_hIST (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_16p \fIhist\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_iCCP (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_charp \fP\fIname\fP\fB, int \fP\fIcompression_type\fP\fB, png_charp \fP\fIprofile\fP\fB, png_uint_32 \fIproflen\fP\fB);\fP

+\fI\fB

+\fBint png_set_interlace_handling (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_invalid (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fImask\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_invert_alpha (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_invert_mono (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_IHDR (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fIwidth\fP\fB, png_uint_32 \fP\fIheight\fP\fB, int \fP\fIbit_depth\fP\fB, int \fP\fIcolor_type\fP\fB, int \fP\fIinterlace_type\fP\fB, int \fP\fIcompression_type\fP\fB, int \fIfilter_type\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_keep_unknown_chunks (png_structp \fP\fIpng_ptr\fP\fB, int \fP\fIkeep\fP\fB, png_bytep \fP\fIchunk_list\fP\fB, int \fInum_chunks\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_mem_fn(png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fImem_ptr\fP\fB, png_malloc_ptr \fP\fImalloc_fn\fP\fB, png_free_ptr \fIfree_fn\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_oFFs (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fIoffset_x\fP\fB, png_uint_32 \fP\fIoffset_y\fP\fB, int \fIunit_type\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_packing (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_packswap (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_palette_to_rgb(png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_pCAL (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_charp \fP\fIpurpose\fP\fB, png_int_32 \fP\fIX0\fP\fB, png_int_32 \fP\fIX1\fP\fB, int \fP\fItype\fP\fB, int \fP\fInparams\fP\fB, png_charp \fP\fIunits\fP\fB, png_charpp \fIparams\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_pHYs (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fIres_x\fP\fB, png_uint_32 \fP\fIres_y\fP\fB, int \fIunit_type\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_progressive_read_fn (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fIprogressive_ptr\fP\fB, png_progressive_info_ptr \fP\fIinfo_fn\fP\fB, png_progressive_row_ptr \fP\fIrow_fn\fP\fB, png_progressive_end_ptr \fIend_fn\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_PLTE (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_colorp \fP\fIpalette\fP\fB, int \fInum_palette\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_read_fn (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fIio_ptr\fP\fB, png_rw_ptr \fIread_data_fn\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_read_status_fn (png_structp \fP\fIpng_ptr\fP\fB, png_read_status_ptr \fIread_row_fn\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_read_user_transform_fn (png_structp \fP\fIpng_ptr\fP\fB, png_user_transform_ptr \fIread_user_transform_fn\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_rgb_to_gray (png_structp \fP\fIpng_ptr\fP\fB, int \fP\fIerror_action\fP\fB, double \fP\fIred\fP\fB, double \fIgreen\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_rgb_to_gray_fixed (png_structp \fP\fIpng_ptr\fP\fB, int error_action png_fixed_point \fP\fIred\fP\fB, png_fixed_point \fIgreen\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_rows (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_bytepp \fIrow_pointers\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_sBIT (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_color_8p \fIsig_bit\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_sCAL (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_charp \fP\fIunit\fP\fB, double \fP\fIwidth\fP\fB, double \fIheight\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_shift (png_structp \fP\fIpng_ptr\fP\fB, png_color_8p \fItrue_bits\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_sig_bytes (png_structp \fP\fIpng_ptr\fP\fB, int \fInum_bytes\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_sPLT (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_spalette_p \fP\fIsplt_ptr\fP\fB, int \fInum_spalettes\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_sRGB (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fIintent\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_sRGB_gAMA_and_cHRM (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fIintent\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_strip_16 (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_strip_alpha (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_swap (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_swap_alpha (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_text (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_textp \fP\fItext_ptr\fP\fB, int \fInum_text\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_tIME (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_timep \fImod_time\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_tRNS (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_bytep \fP\fItrans\fP\fB, int \fP\fInum_trans\fP\fB, png_color_16p \fItrans_values\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_tRNS_to_alpha(png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBpng_uint_32 png_set_unknown_chunks (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_unknown_chunkp \fP\fIunknowns\fP\fB, int \fP\fInum\fP\fB, int \fIlocation\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_unknown_chunk_location(png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fP\fIchunk\fP\fB, int \fIlocation\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_read_user_chunk_fn (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fIuser_chunk_ptr\fP\fB, png_user_chunk_ptr \fIread_user_chunk_fn\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_user_limits (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fP\fIuser_width_max\fP\fB, png_uint_32 \fIuser_height_max\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_user_transform_info (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fIuser_transform_ptr\fP\fB, int \fP\fIuser_transform_depth\fP\fB, int \fIuser_transform_channels\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_write_fn (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fIio_ptr\fP\fB, png_rw_ptr \fP\fIwrite_data_fn\fP\fB, png_flush_ptr \fIoutput_flush_fn\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_write_status_fn (png_structp \fP\fIpng_ptr\fP\fB, png_write_status_ptr \fIwrite_row_fn\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_write_user_transform_fn (png_structp \fP\fIpng_ptr\fP\fB, png_user_transform_ptr \fIwrite_user_transform_fn\fP\fB);\fP

+\fI\fB

+\fBvoid png_set_compression_buffer_size(png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fIsize\fP\fB);\fP

+\fI\fB

+\fBint png_sig_cmp (png_bytep \fP\fIsig\fP\fB, png_size_t \fP\fIstart\fP\fB, png_size_t \fInum_to_check\fP\fB);\fP

+\fI\fB

+\fBvoid png_start_read_image (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_warning (png_structp \fP\fIpng_ptr\fP\fB, png_const_charp \fImessage\fP\fB);\fP

+\fI\fB

+\fBvoid png_write_chunk (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIchunk_name\fP\fB, png_bytep \fP\fIdata\fP\fB, png_size_t \fIlength\fP\fB);\fP

+\fI\fB

+\fBvoid png_write_chunk_data (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIdata\fP\fB, png_size_t \fIlength\fP\fB);\fP

+\fI\fB

+\fBvoid png_write_chunk_end (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_write_chunk_start (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIchunk_name\fP\fB, png_uint_32 \fIlength\fP\fB);\fP

+\fI\fB

+\fBvoid png_write_destroy (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_write_end (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_write_flush (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_write_image (png_structp \fP\fIpng_ptr\fP\fB, png_bytepp \fIimage\fP\fB);\fP

+\fI\fB

+\fBDEPRECATED: void png_write_init (png_structp \fIpng_ptr\fP\fB);\fP

+\fI\fB

+\fBDEPRECATED: void png_write_init_2 (png_structpp \fP\fIptr_ptr\fP\fB, png_const_charp \fP\fIuser_png_ver\fP\fB, png_size_t \fP\fIpng_struct_size\fP\fB, png_size_t \fIpng_info_size\fP\fB);\fP

+\fI\fB

+\fBvoid png_write_info (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_write_info_before_PLTE (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP

+\fI\fB

+\fBvoid png_write_png (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fP\fItransforms\fP\fB, png_voidp \fIparams\fP\fB);\fP

+\fI\fB

+\fBvoid png_write_row (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fIrow\fP\fB);\fP

+\fI\fB

+\fBvoid png_write_rows (png_structp \fP\fIpng_ptr\fP\fB, png_bytepp \fP\fIrow\fP\fB, png_uint_32 \fInum_rows\fP\fB);\fP

+\fI\fB

+\fBvoidpf png_zalloc (voidpf \fP\fIpng_ptr\fP\fB, uInt \fP\fIitems\fP\fB, uInt \fIsize\fP\fB);\fP

+\fI\fB

+\fBvoid png_zfree (voidpf \fP\fIpng_ptr\fP\fB, voidpf \fIptr\fP\fB);\fP

+\fI\fB

+.SH DESCRIPTION

+The

+.I libpng

+library supports encoding, decoding, and various manipulations of

+the Portable Network Graphics (PNG) format image files.  It uses the

+.IR zlib(3)

+compression library.

+Following is a copy of the libpng.txt file that accompanies libpng.

+.SH LIBPNG.TXT

+libpng.txt - A description on how to use and modify libpng

+ libpng version 1.2.8 - December 3, 2004

+ Updated and distributed by Glenn Randers-Pehrson

+ <glennrp at users.sourceforge.net>

+ Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ For conditions of distribution and use, see copyright

+ notice in png.h.

+ based on:

+ libpng 1.0 beta 6  version 0.96 May 28, 1997

+ Updated and distributed by Andreas Dilger

+ Copyright (c) 1996, 1997 Andreas Dilger

+ libpng 1.0 beta 2 - version 0.88  January 26, 1996

+ For conditions of distribution and use, see copyright

+ notice in png.h. Copyright (c) 1995, 1996 Guy Eric

+ Schalnat, Group 42, Inc.

+ Updated/rewritten per request in the libpng FAQ

+ Copyright (c) 1995, 1996 Frank J. T. Wojcik

+ December 18, 1995 & January 20, 1996

+.SH I. Introduction

+This file describes how to use and modify the PNG reference library

+(known as libpng) for your own use.  There are five sections to this

+file: introduction, structures, reading, writing, and modification and

+configuration notes for various special platforms.  In addition to this

+file, example.c is a good starting point for using the library, as

+it is heavily commented and should include everything most people

+will need.  We assume that libpng is already installed; see the

+INSTALL file for instructions on how to install libpng.

+Libpng was written as a companion to the PNG specification, as a way

+of reducing the amount of time and effort it takes to support the PNG

+file format in application programs.

+The PNG specification (second edition), November 2003, is available as

+a W3C Recommendation and as an ISO Standard (ISO/IEC 15948:2003 (E)) at

+<http://www.w3.org/TR/2003/REC-PNG-20031110/

+The W3C and ISO documents have identical technical content.

+The PNG-1.2 specification is available at

+<http://www.libpng.org/pub/png/documents/>

+The PNG-1.0 specification is available

+as RFC 2083 <http://www.libpng.org/pub/png/documents/> and as a

+W3C Recommendation <http://www.w3.org/TR/REC.png.html>. Some

+additional chunks are described in the special-purpose public chunks

+documents at <http://www.libpng.org/pub/png/documents/>.

+Other information

+about PNG, and the latest version of libpng, can be found at the PNG home

+page, <http://www.libpng.org/pub/png/>.

+Most users will not have to modify the library significantly; advanced

+users may want to modify it more.  All attempts were made to make it as

+complete as possible, while keeping the code easy to understand.

+Currently, this library only supports C.  Support for other languages

+is being considered.

+Libpng has been designed to handle multiple sessions at one time,

+to be easily modifiable, to be portable to the vast majority of

+machines (ANSI, K&R, 16-, 32-, and 64-bit) available, and to be easy

+to use.  The ultimate goal of libpng is to promote the acceptance of

+the PNG file format in whatever way possible.  While there is still

+work to be done (see the TODO file), libpng should cover the

+majority of the needs of its users.

+Libpng uses zlib for its compression and decompression of PNG files.

+Further information about zlib, and the latest version of zlib, can

+be found at the zlib home page, <http://www.info-zip.org/pub/infozip/zlib/>.

+The zlib compression utility is a general purpose utility that is

+useful for more than PNG files, and can be used without libpng.

+See the documentation delivered with zlib for more details.

+You can usually find the source files for the zlib utility wherever you

+find the libpng source files.

+Libpng is thread safe, provided the threads are using different

+instances of the structures.  Each thread should have its own

+png_struct and png_info instances, and thus its own image.

+Libpng does not protect itself against two threads using the

+same instance of a structure.  Note: thread safety may be defeated

+by use of some of the MMX assembler code in pnggccrd.c, which is only

+compiled when the user defines PNG_THREAD_UNSAFE_OK.

+.SH II. Structures

+There are two main structures that are important to libpng, png_struct

+and png_info.  The first, png_struct, is an internal structure that

+will not, for the most part, be used by a user except as the first

+variable passed to every libpng function call.

+The png_info structure is designed to provide information about the

+PNG file.  At one time, the fields of png_info were intended to be

+directly accessible to the user.  However, this tended to cause problems

+with applications using dynamically loaded libraries, and as a result

+a set of interface functions for png_info (the png_get_*() and png_set_*()

+functions) was developed.  The fields of png_info are still available for

+older applications, but it is suggested that applications use the new

+interfaces if at all possible.

+Applications that do make direct access to the members of png_struct (except

+for png_ptr->jmpbuf) must be recompiled whenever the library is updated,

+and applications that make direct access to the members of png_info must

+be recompiled if they were compiled or loaded with libpng version 1.0.6,

+in which the members were in a different order.  In version 1.0.7, the

+members of the png_info structure reverted to the old order, as they were

+in versions 0.97c through 1.0.5.  Starting with version 2.0.0, both

+structures are going to be hidden, and the contents of the structures will

+only be accessible through the png_get/png_set functions.

+The png.h header file is an invaluable reference for programming with libpng.

+And while I'm on the topic, make sure you include the libpng header file:

+#include <png.h>

+.SH III. Reading

+We'll now walk you through the possible functions to call when reading

+in a PNG file sequentially, briefly explaining the syntax and purpose

+of each one.  See example.c and png.h for more detail.  While

+progressive reading is covered in the next section, you will still

+need some of the functions discussed in this section to read a PNG

+file.

+.SS Setup

+You will want to do the I/O initialization(*) before you get into libpng,

+so if it doesn't work, you don't have much to undo.  Of course, you

+will also want to insure that you are, in fact, dealing with a PNG

+file.  Libpng provides a simple check to see if a file is a PNG file.

+To use it, pass in the first 1 to 8 bytes of the file to the function

+png_sig_cmp(), and it will return 0 if the bytes match the corresponding

+bytes of the PNG signature, or nonzero otherwise.  Of course, the more bytes

+you pass in, the greater the accuracy of the prediction.

+If you are intending to keep the file pointer open for use in libpng,

+you must ensure you don't read more than 8 bytes from the beginning

+of the file, and you also have to make a call to png_set_sig_bytes_read()

+with the number of bytes you read from the beginning.  Libpng will

+then only check the bytes (if any) that your program didn't read.

+(*): If you are not using the standard I/O functions, you will need

+to replace them with custom functions.  See the discussion under

+Customizing libpng.

+    FILE *fp = fopen(file_name, "rb");

+    if (!fp)

+    {

+        return (ERROR);

+    }

+    fread(header, 1, number, fp);

+    is_png = !png_sig_cmp(header, 0, number);

+    if (!is_png)

+    {

+        return (NOT_PNG);

+    }

+Next, png_struct and png_info need to be allocated and initialized.  In

+order to ensure that the size of these structures is correct even with a

+dynamically linked libpng, there are functions to initialize and

+allocate the structures.  We also pass the library version, optional

+pointers to error handling functions, and a pointer to a data struct for

+use by the error functions, if necessary (the pointer and functions can

+be NULL if the default error handlers are to be used).  See the section

+on Changes to Libpng below regarding the old initialization functions.

+The structure allocation functions quietly return NULL if they fail to

+create the structure, so your application should check for that.

+    png_structp png_ptr = png_create_read_struct

+       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,

+        user_error_fn, user_warning_fn);

+    if (!png_ptr)

+        return (ERROR);

+    png_infop info_ptr = png_create_info_struct(png_ptr);

+    if (!info_ptr)

+    {

+        png_destroy_read_struct(&png_ptr,

+           (png_infopp)NULL, (png_infopp)NULL);

+        return (ERROR);

+    }

+    png_infop end_info = png_create_info_struct(png_ptr);

+    if (!end_info)

+    {

+        png_destroy_read_struct(&png_ptr, &info_ptr,

+          (png_infopp)NULL);

+        return (ERROR);

+    }

+If you want to use your own memory allocation routines,

+define PNG_USER_MEM_SUPPORTED and use

+png_create_read_struct_2() instead of png_create_read_struct():

+    png_structp png_ptr = png_create_read_struct_2

+       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,

+        user_error_fn, user_warning_fn, (png_voidp)

+        user_mem_ptr, user_malloc_fn, user_free_fn);

+The error handling routines passed to png_create_read_struct()

+and the memory alloc/free routines passed to png_create_struct_2()

+are only necessary if you are not using the libpng supplied error

+handling and memory alloc/free functions.

+When libpng encounters an error, it expects to longjmp back

+to your routine.  Therefore, you will need to call setjmp and pass

+your png_jmpbuf(png_ptr).  If you read the file from different

+routines, you will need to update the jmpbuf field every time you enter

+a new routine that will call a png_*() function.

+See your documentation of setjmp/longjmp for your compiler for more

+information on setjmp/longjmp.  See the discussion on libpng error

+handling in the Customizing Libpng section below for more information

+on the libpng error handling.  If an error occurs, and libpng longjmp's

+back to your setjmp, you will want to call png_destroy_read_struct() to

+free any memory.

+    if (setjmp(png_jmpbuf(png_ptr)))

+    {

+        png_destroy_read_struct(&png_ptr, &info_ptr,

+           &end_info);

+        fclose(fp);

+        return (ERROR);

+    }

+If you would rather avoid the complexity of setjmp/longjmp issues,

+you can compile libpng with PNG_SETJMP_NOT_SUPPORTED, in which case

+errors will result in a call to PNG_ABORT() which defaults to abort().

+Now you need to set up the input code.  The default for libpng is to

+use the C function fread().  If you use this, you will need to pass a

+valid FILE * in the function png_init_io().  Be sure that the file is

+opened in binary mode.  If you wish to handle reading data in another

+way, you need not call the png_init_io() function, but you must then

+implement the libpng I/O methods discussed in the Customizing Libpng

+section below.

+    png_init_io(png_ptr, fp);

+If you had previously opened the file and read any of the signature from

+the beginning in order to see if this was a PNG file, you need to let

+libpng know that there are some bytes missing from the start of the file.

+    png_set_sig_bytes(png_ptr, number);

+.SS Setting up callback code

+You can set up a callback function to handle any unknown chunks in the

+input stream. You must supply the function

+    read_chunk_callback(png_ptr ptr,

+         png_unknown_chunkp chunk);

+    {

+       /* The unknown chunk structure contains your

+          chunk data: */

+           png_byte name[5];

+           png_byte *data;

+           png_size_t size;

+       /* Note that libpng has already taken care of

+          the CRC handling */

+       /* put your code here.  Return one of the

+          following: */

+       return (-n); /* chunk had an error */

+       return (0); /* did not recognize */

+       return (n); /* success */

+    }

+(You can give your function another name that you like instead of

+"read_chunk_callback")

+To inform libpng about your function, use

+    png_set_read_user_chunk_fn(png_ptr, user_chunk_ptr,

+        read_chunk_callback);

+This names not only the callback function, but also a user pointer that

+you can retrieve with

+    png_get_user_chunk_ptr(png_ptr);

+At this point, you can set up a callback function that will be

+called after each row has been read, which you can use to control

+a progress meter or the like.  It's demonstrated in pngtest.c.

+You must supply a function

+    void read_row_callback(png_ptr ptr, png_uint_32 row,

+       int pass);

+    {

+      /* put your code here */

+    }

+(You can give it another name that you like instead of "read_row_callback")

+To inform libpng about your function, use

+    png_set_read_status_fn(png_ptr, read_row_callback);

+.SS Width and height limits

+The PNG specification allows the width and height of an image to be as

+large as 2^31-1 (0x7fffffff), or about 2.147 billion rows and columns.

+Since very few applications really need to process such large images,

+we have imposed an arbitrary 1-million limit on rows and columns.

+Larger images will be rejected immediately with a png_error() call. If

+you wish to override this limit, you can use

+   png_set_user_limits(png_ptr, width_max, height_max);

+to set your own limits, or use width_max = height_max = 0x7fffffffL

+to allow all valid dimensions (libpng may reject some very large images

+anyway because of potential buffer overflow conditions).

+You should put this statement after you create the PNG structure and

+before calling png_read_info(), png_read_png(), or png_process_data().

+If you need to retrieve the limits that are being applied, use

+   width_max = png_get_user_width_max(png_ptr);

+   height_max = png_get_user_height_max(png_ptr);

+.SS Unknown-chunk handling

+Now you get to set the way the library processes unknown chunks in the

+input PNG stream. Both known and unknown chunks will be read.  Normal

+behavior is that known chunks will be parsed into information in

+various info_ptr members; unknown chunks will be discarded. To change

+this, you can call:

+    png_set_keep_unknown_chunks(png_ptr, keep,

+        chunk_list, num_chunks);

+    keep       - 0: do not handle as unknown

+                 1: do not keep

+                 2: keep only if safe-to-copy

+                 3: keep even if unsafe-to-copy

+               You can use these definitions:

+                 PNG_HANDLE_CHUNK_AS_DEFAULT   0

+                 PNG_HANDLE_CHUNK_NEVER        1

+                 PNG_HANDLE_CHUNK_IF_SAFE      2

+                 PNG_HANDLE_CHUNK_ALWAYS       3

+    chunk_list - list of chunks affected (a byte string,

+                 five bytes per chunk, NULL or '\0' if

+                 num_chunks is 0)

+    num_chunks - number of chunks affected; if 0, all

+                 unknown chunks are affected.  If nonzero,

+                 only the chunks in the list are affected

+Unknown chunks declared in this way will be saved as raw data onto a

+list of png_unknown_chunk structures.  If a chunk that is normally

+known to libpng is named in the list, it will be handled as unknown,

+according to the "keep" directive.  If a chunk is named in successive

+instances of png_set_keep_unknown_chunks(), the final instance will

+take precedence.  The IHDR and IEND chunks should not be named in

+chunk_list; if they are, libpng will process them normally anyway.

+.SS The high-level read interface

+At this point there are two ways to proceed; through the high-level

+read interface, or through a sequence of low-level read operations.

+You can use the high-level interface if (a) you are willing to read

+the entire image into memory, and (b) the input transformations

+you want to do are limited to the following set:

+    PNG_TRANSFORM_IDENTITY      No transformation

+    PNG_TRANSFORM_STRIP_16      Strip 16-bit samples to

+                                8 bits

+    PNG_TRANSFORM_STRIP_ALPHA   Discard the alpha channel

+    PNG_TRANSFORM_PACKING       Expand 1, 2 and 4-bit

+                                samples to bytes

+    PNG_TRANSFORM_PACKSWAP      Change order of packed

+                                pixels to LSB first

+    PNG_TRANSFORM_EXPAND        Perform set_expand()

+    PNG_TRANSFORM_INVERT_MONO   Invert monochrome images

+    PNG_TRANSFORM_SHIFT         Normalize pixels to the

+                                sBIT depth

+    PNG_TRANSFORM_BGR           Flip RGB to BGR, RGBA

+                                to BGRA

+    PNG_TRANSFORM_SWAP_ALPHA    Flip RGBA to ARGB or GA

+                                to AG

+    PNG_TRANSFORM_INVERT_ALPHA  Change alpha from opacity

+                                to transparency

+    PNG_TRANSFORM_SWAP_ENDIAN   Byte-swap 16-bit samples

+(This excludes setting a background color, doing gamma transformation,

+dithering, and setting filler.)  If this is the case, simply do this:

+    png_read_png(png_ptr, info_ptr, png_transforms, NULL)

+where png_transforms is an integer containing the logical OR of

+some set of transformation flags.  This call is equivalent to png_read_info(),

+followed the set of transformations indicated by the transform mask,

+then png_read_image(), and finally png_read_end().

+(The final parameter of this call is not yet used.  Someday it might point

+to transformation parameters required by some future input transform.)

+You must use png_transforms and not call any png_set_transform() functions

+when you use png_read_png().

+After you have called png_read_png(), you can retrieve the image data

+with

+   row_pointers = png_get_rows(png_ptr, info_ptr);

+where row_pointers is an array of pointers to the pixel data for each row:

+   png_bytep row_pointers[height];

+If you know your image size and pixel size ahead of time, you can allocate

+row_pointers prior to calling png_read_png() with

+   if (height > PNG_UINT_32_MAX/png_sizeof(png_byte))

+      png_error (png_ptr,

+         "Image is too tall to process in memory");

+   if (width > PNG_UINT_32_MAX/pixel_size)

+      png_error (png_ptr,

+         "Image is too wide to process in memory");

+   row_pointers = png_malloc(png_ptr,

+      height*png_sizeof(png_bytep));

+   for (int i=0; i<height, i++)

+      row_pointers[i]=png_malloc(png_ptr,

+         width*pixel_size);

+   png_set_rows(png_ptr, info_ptr, &row_pointers);

+Alternatively you could allocate your image in one big block and define

+row_pointers[i] to point into the proper places in your block.

+If you use png_set_rows(), the application is responsible for freeing

+row_pointers (and row_pointers[i], if they were separately allocated).

+If you don't allocate row_pointers ahead of time, png_read_png() will

+do it, and it'll be free'ed when you call png_destroy_*().

+.SS The low-level read interface

+If you are going the low-level route, you are now ready to read all

+the file information up to the actual image data.  You do this with a

+call to png_read_info().

+    png_read_info(png_ptr, info_ptr);

+This will process all chunks up to but not including the image data.

+.SS Querying the info structure

+Functions are used to get the information from the info_ptr once it

+has been read.  Note that these fields may not be completely filled

+in until png_read_end() has read the chunk data following the image.

+    png_get_IHDR(png_ptr, info_ptr, &width, &height,

+       &bit_depth, &color_type, &interlace_type,

+       &compression_type, &filter_method);

+    width          - holds the width of the image

+                     in pixels (up to 2^31).

+    height         - holds the height of the image

+                     in pixels (up to 2^31).

+    bit_depth      - holds the bit depth of one of the

+                     image channels.  (valid values are

+                     1, 2, 4, 8, 16 and depend also on

+                     the color_type.  See also

+                     significant bits (sBIT) below).

+    color_type     - describes which color/alpha channels

+                         are present.

+                     PNG_COLOR_TYPE_GRAY

+                        (bit depths 1, 2, 4, 8, 16)

+                     PNG_COLOR_TYPE_GRAY_ALPHA

+                        (bit depths 8, 16)

+                     PNG_COLOR_TYPE_PALETTE

+                        (bit depths 1, 2, 4, 8)

+                     PNG_COLOR_TYPE_RGB

+                        (bit_depths 8, 16)

+                     PNG_COLOR_TYPE_RGB_ALPHA

+                        (bit_depths 8, 16)

+                     PNG_COLOR_MASK_PALETTE

+                     PNG_COLOR_MASK_COLOR

+                     PNG_COLOR_MASK_ALPHA

+    filter_method  - (must be PNG_FILTER_TYPE_BASE

+                     for PNG 1.0, and can also be

+                     PNG_INTRAPIXEL_DIFFERENCING if

+                     the PNG datastream is embedded in

+                     a MNG-1.0 datastream)

+    compression_type - (must be PNG_COMPRESSION_TYPE_BASE

+                     for PNG 1.0)

+    interlace_type - (PNG_INTERLACE_NONE or

+                     PNG_INTERLACE_ADAM7)

+    Any or all of interlace_type, compression_type, of

+    filter_method can be NULL if you are

+    not interested in their values.

+    channels = png_get_channels(png_ptr, info_ptr);

+    channels       - number of channels of info for the

+                     color type (valid values are 1 (GRAY,

+                     PALETTE), 2 (GRAY_ALPHA), 3 (RGB),

+                     4 (RGB_ALPHA or RGB + filler byte))

+    rowbytes = png_get_rowbytes(png_ptr, info_ptr);

+    rowbytes       - number of bytes needed to hold a row

+    signature = png_get_signature(png_ptr, info_ptr);

+    signature      - holds the signature read from the

+                     file (if any).  The data is kept in

+                     the same offset it would be if the

+                     whole signature were read (i.e. if an

+                     application had already read in 4

+                     bytes of signature before starting

+                     libpng, the remaining 4 bytes would

+                     be in signature[4] through signature[7]

+                     (see png_set_sig_bytes())).

+    width            = png_get_image_width(png_ptr,

+                         info_ptr);

+    height           = png_get_image_height(png_ptr,

+                         info_ptr);

+    bit_depth        = png_get_bit_depth(png_ptr,

+                         info_ptr);

+    color_type       = png_get_color_type(png_ptr,

+                         info_ptr);

+    filter_method    = png_get_filter_type(png_ptr,

+                         info_ptr);

+    compression_type = png_get_compression_type(png_ptr,

+                         info_ptr);

+    interlace_type   = png_get_interlace_type(png_ptr,

+                         info_ptr);

+These are also important, but their validity depends on whether the chunk

+has been read.  The png_get_valid(png_ptr, info_ptr, PNG_INFO_<chunk>) and

+png_get_<chunk>(png_ptr, info_ptr, ...) functions return non-zero if the

+data has been read, or zero if it is missing.  The parameters to the

+png_get_<chunk> are set directly if they are simple data types, or a pointer

+into the info_ptr is returned for any complex types.

+    png_get_PLTE(png_ptr, info_ptr, &palette,

+                     &num_palette);

+    palette        - the palette for the file

+                     (array of png_color)

+    num_palette    - number of entries in the palette

+    png_get_gAMA(png_ptr, info_ptr, &gamma);

+    gamma          - the gamma the file is written

+                     at (PNG_INFO_gAMA)

+    png_get_sRGB(png_ptr, info_ptr, &srgb_intent);

+    srgb_intent    - the rendering intent (PNG_INFO_sRGB)

+                     The presence of the sRGB chunk

+                     means that the pixel data is in the

+                     sRGB color space.  This chunk also

+                     implies specific values of gAMA and

+                     cHRM.

+    png_get_iCCP(png_ptr, info_ptr, &name,

+       &compression_type, &profile, &proflen);

+    name            - The profile name.

+    compression     - The compression type; always

+                      PNG_COMPRESSION_TYPE_BASE for PNG 1.0.

+                      You may give NULL to this argument to

+                      ignore it.

+    profile         - International Color Consortium color

+                      profile data. May contain NULs.

+    proflen         - length of profile data in bytes.

+    png_get_sBIT(png_ptr, info_ptr, &sig_bit);

+    sig_bit        - the number of significant bits for

+                     (PNG_INFO_sBIT) each of the gray,

+                     red, green, and blue channels,

+                     whichever are appropriate for the

+                     given color type (png_color_16)

+    png_get_tRNS(png_ptr, info_ptr, &trans, &num_trans,

+                     &trans_values);

+    trans          - array of transparent entries for

+                     palette (PNG_INFO_tRNS)

+    trans_values   - graylevel or color sample values of

+                     the single transparent color for

+                     non-paletted images (PNG_INFO_tRNS)

+    num_trans      - number of transparent entries

+                     (PNG_INFO_tRNS)

+    png_get_hIST(png_ptr, info_ptr, &hist);

+                     (PNG_INFO_hIST)

+    hist           - histogram of palette (array of

+                     png_uint_16)

+    png_get_tIME(png_ptr, info_ptr, &mod_time);

+    mod_time       - time image was last modified

+                    (PNG_VALID_tIME)

+    png_get_bKGD(png_ptr, info_ptr, &background);

+    background     - background color (PNG_VALID_bKGD)

+                     valid 16-bit red, green and blue

+                     values, regardless of color_type

+    num_comments   = png_get_text(png_ptr, info_ptr,

+                     &text_ptr, &num_text);

+    num_comments   - number of comments

+    text_ptr       - array of png_text holding image

+                     comments

+    text_ptr[i].compression - type of compression used

+                 on "text" PNG_TEXT_COMPRESSION_NONE

+                           PNG_TEXT_COMPRESSION_zTXt

+                           PNG_ITXT_COMPRESSION_NONE

+                           PNG_ITXT_COMPRESSION_zTXt

+    text_ptr[i].key   - keyword for comment.  Must contain

+                         1-79 characters.

+    text_ptr[i].text  - text comments for current

+                         keyword.  Can be empty.

+    text_ptr[i].text_length - length of text string,

+                 after decompression, 0 for iTXt

+    text_ptr[i].itxt_length - length of itxt string,

+                 after decompression, 0 for tEXt/zTXt

+    text_ptr[i].lang  - language of comment (empty

+                         string for unknown).

+    text_ptr[i].lang_key  - keyword in UTF-8

+                         (empty string for unknown).

+    num_text       - number of comments (same as

+                     num_comments; you can put NULL here

+                     to avoid the duplication)

+    Note while png_set_text() will accept text, language,

+    and translated keywords that can be NULL pointers, the

+    structure returned by png_get_text will always contain

+    regular zero-terminated C strings.  They might be

+    empty strings but they will never be NULL pointers.

+    num_spalettes = png_get_sPLT(png_ptr, info_ptr,

+       &palette_ptr);

+    palette_ptr    - array of palette structures holding

+                     contents of one or more sPLT chunks

+                     read.

+    num_spalettes  - number of sPLT chunks read.

+    png_get_oFFs(png_ptr, info_ptr, &offset_x, &offset_y,

+       &unit_type);

+    offset_x       - positive offset from the left edge

+                     of the screen

+    offset_y       - positive offset from the top edge

+                     of the screen

+    unit_type      - PNG_OFFSET_PIXEL, PNG_OFFSET_MICROMETER

+    png_get_pHYs(png_ptr, info_ptr, &res_x, &res_y,

+       &unit_type);

+    res_x          - pixels/unit physical resolution in

+                     x direction

+    res_y          - pixels/unit physical resolution in

+                     x direction

+    unit_type      - PNG_RESOLUTION_UNKNOWN,

+                     PNG_RESOLUTION_METER

+    png_get_sCAL(png_ptr, info_ptr, &unit, &width,

+       &height)

+    unit        - physical scale units (an integer)

+    width       - width of a pixel in physical scale units

+    height      - height of a pixel in physical scale units

+                 (width and height are doubles)

+    png_get_sCAL_s(png_ptr, info_ptr, &unit, &width,

+       &height)

+    unit        - physical scale units (an integer)

+    width       - width of a pixel in physical scale units

+    height      - height of a pixel in physical scale units

+                 (width and height are strings like "2.54")

+    num_unknown_chunks = png_get_unknown_chunks(png_ptr,

+       info_ptr, &unknowns)

+    unknowns          - array of png_unknown_chunk

+                        structures holding unknown chunks

+    unknowns[i].name  - name of unknown chunk

+    unknowns[i].data  - data of unknown chunk

+    unknowns[i].size  - size of unknown chunk's data

+    unknowns[i].location - position of chunk in file

+    The value of "i" corresponds to the order in which the

+    chunks were read from the PNG file or inserted with the

+    png_set_unknown_chunks() function.

+The data from the pHYs chunk can be retrieved in several convenient

+forms:

+    res_x = png_get_x_pixels_per_meter(png_ptr,

+       info_ptr)

+    res_y = png_get_y_pixels_per_meter(png_ptr,

+       info_ptr)

+    res_x_and_y = png_get_pixels_per_meter(png_ptr,

+       info_ptr)

+    res_x = png_get_x_pixels_per_inch(png_ptr,

+       info_ptr)

+    res_y = png_get_y_pixels_per_inch(png_ptr,

+       info_ptr)

+    res_x_and_y = png_get_pixels_per_inch(png_ptr,

+       info_ptr)

+    aspect_ratio = png_get_pixel_aspect_ratio(png_ptr,

+       info_ptr)

+   (Each of these returns 0 [signifying "unknown"] if

+       the data is not present or if res_x is 0;

+       res_x_and_y is 0 if res_x != res_y)

+The data from the oFFs chunk can be retrieved in several convenient

+forms:

+    x_offset = png_get_x_offset_microns(png_ptr, info_ptr);

+    y_offset = png_get_y_offset_microns(png_ptr, info_ptr);

+    x_offset = png_get_x_offset_inches(png_ptr, info_ptr);

+    y_offset = png_get_y_offset_inches(png_ptr, info_ptr);

+   (Each of these returns 0 [signifying "unknown" if both

+       x and y are 0] if the data is not present or if the

+       chunk is present but the unit is the pixel)

+For more information, see the png_info definition in png.h and the

+PNG specification for chunk contents.  Be careful with trusting

+rowbytes, as some of the transformations could increase the space

+needed to hold a row (expand, filler, gray_to_rgb, etc.).

+See png_read_update_info(), below.

+A quick word about text_ptr and num_text.  PNG stores comments in

+keyword/text pairs, one pair per chunk, with no limit on the number

+of text chunks, and a 2^31 byte limit on their size.  While there are

+suggested keywords, there is no requirement to restrict the use to these

+strings.  It is strongly suggested that keywords and text be sensible

+to humans (that's the point), so don't use abbreviations.  Non-printing

+symbols are not allowed.  See the PNG specification for more details.

+There is also no requirement to have text after the keyword.

+Keywords should be limited to 79 Latin-1 characters without leading or

+trailing spaces, but non-consecutive spaces are allowed within the

+keyword.  It is possible to have the same keyword any number of times.

+The text_ptr is an array of png_text structures, each holding a

+pointer to a language string, a pointer to a keyword and a pointer to

+a text string.  The text string, language code, and translated

+keyword may be empty or NULL pointers.  The keyword/text

+pairs are put into the array in the order that they are received.

+However, some or all of the text chunks may be after the image, so, to

+make sure you have read all the text chunks, don't mess with these

+until after you read the stuff after the image.  This will be

+mentioned again below in the discussion that goes with png_read_end().

+.SS Input transformations

+After you've read the header information, you can set up the library

+to handle any special transformations of the image data.  The various

+ways to transform the data will be described in the order that they

+should occur.  This is important, as some of these change the color

+type and/or bit depth of the data, and some others only work on

+certain color types and bit depths.  Even though each transformation

+checks to see if it has data that it can do something with, you should

+make sure to only enable a transformation if it will be valid for the

+data.  For example, don't swap red and blue on grayscale data.

+The colors used for the background and transparency values should be

+supplied in the same format/depth as the current image data.  They

+are stored in the same format/depth as the image data in a bKGD or tRNS

+chunk, so this is what libpng expects for this data.  The colors are

+transformed to keep in sync with the image data when an application

+calls the png_read_update_info() routine (see below).

+Data will be decoded into the supplied row buffers packed into bytes

+unless the library has been told to transform it into another format.

+For example, 4 bit/pixel paletted or grayscale data will be returned

+2 pixels/byte with the leftmost pixel in the high-order bits of the

+byte, unless png_set_packing() is called.  8-bit RGB data will be stored

+in RGB RGB RGB format unless png_set_filler() or png_set_add_alpha()

+is called to insert filler bytes, either before or after each RGB triplet.

+16-bit RGB data will be returned RRGGBB RRGGBB, with the most significant

+byte of the color value first, unless png_set_strip_16() is called to

+transform it to regular RGB RGB triplets, or png_set_filler() or

+png_set_add alpha() is called to insert filler bytes, either before or

+after each RRGGBB triplet.  Similarly, 8-bit or 16-bit grayscale data can

+be modified with

+png_set_filler(), png_set_add_alpha(), or png_set_strip_16().

+The following code transforms grayscale images of less than 8 to 8 bits,

+changes paletted images to RGB, and adds a full alpha channel if there is

+transparency information in a tRNS chunk.  This is most useful on

+grayscale images with bit depths of 2 or 4 or if there is a multiple-image

+viewing application that wishes to treat all images in the same way.

+    if (color_type == PNG_COLOR_TYPE_PALETTE)

+        png_set_palette_to_rgb(png_ptr);

+    if (color_type == PNG_COLOR_TYPE_GRAY &&

+        bit_depth < 8) png_set_gray_1_2_4_to_8(png_ptr);

+    if (png_get_valid(png_ptr, info_ptr,

+        PNG_INFO_tRNS)) png_set_tRNS_to_alpha(png_ptr);

+These three functions are actually aliases for png_set_expand(), added

+in libpng version 1.0.4, with the function names expanded to improve code

+readability.  In some future version they may actually do different

+things.

+PNG can have files with 16 bits per channel.  If you only can handle

+8 bits per channel, this will strip the pixels down to 8 bit.

+    if (bit_depth == 16)

+        png_set_strip_16(png_ptr);

+If, for some reason, you don't need the alpha channel on an image,

+and you want to remove it rather than combining it with the background

+(but the image author certainly had in mind that you *would* combine

+it with the background, so that's what you should probably do):

+    if (color_type & PNG_COLOR_MASK_ALPHA)

+        png_set_strip_alpha(png_ptr);

+In PNG files, the alpha channel in an image

+is the level of opacity.  If you need the alpha channel in an image to

+be the level of transparency instead of opacity, you can invert the

+alpha channel (or the tRNS chunk data) after it's read, so that 0 is

+fully opaque and 255 (in 8-bit or paletted images) or 65535 (in 16-bit

+images) is fully transparent, with

+    png_set_invert_alpha(png_ptr);

+PNG files pack pixels of bit depths 1, 2, and 4 into bytes as small as

+they can, resulting in, for example, 8 pixels per byte for 1 bit

+files.  This code expands to 1 pixel per byte without changing the

+values of the pixels:

+    if (bit_depth < 8)

+        png_set_packing(png_ptr);

+PNG files have possible bit depths of 1, 2, 4, 8, and 16.  All pixels

+stored in a PNG image have been "scaled" or "shifted" up to the next

+higher possible bit depth (e.g. from 5 bits/sample in the range [0,31] to

+8 bits/sample in the range [0, 255]).  However, it is also possible to

+convert the PNG pixel data back to the original bit depth of the image.

+This call reduces the pixels back down to the original bit depth:

+    png_color_8p sig_bit;

+    if (png_get_sBIT(png_ptr, info_ptr, &sig_bit))

+        png_set_shift(png_ptr, sig_bit);

+PNG files store 3-color pixels in red, green, blue order.  This code

+changes the storage of the pixels to blue, green, red:

+    if (color_type == PNG_COLOR_TYPE_RGB ||

+        color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+        png_set_bgr(png_ptr);

+PNG files store RGB pixels packed into 3 or 6 bytes. This code expands them

+into 4 or 8 bytes for windowing systems that need them in this format:

+    if (color_type == PNG_COLOR_TYPE_RGB)

+        png_set_filler(png_ptr, filler, PNG_FILLER_BEFORE);

+where "filler" is the 8 or 16-bit number to fill with, and the location is

+either PNG_FILLER_BEFORE or PNG_FILLER_AFTER, depending upon whether

+you want the filler before the RGB or after.  This transformation

+does not affect images that already have full alpha channels.  To add an

+opaque alpha channel, use filler=0xff or 0xffff and PNG_FILLER_AFTER which

+will generate RGBA pixels.

+Note that png_set_filler() does not change the color type.  If you want

+to do that, you can add a true alpha channel with

+    if (color_type == PNG_COLOR_TYPE_RGB ||

+           color_type == PNG_COLOR_TYPE_GRAY)

+    png_set_add_alpha(png_ptr, filler, PNG_FILLER_AFTER);

+where "filler" contains the alpha value to assign to each pixel.

+This function was added in libpng-1.2.7.

+If you are reading an image with an alpha channel, and you need the

+data as ARGB instead of the normal PNG format RGBA:

+    if (color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+        png_set_swap_alpha(png_ptr);

+For some uses, you may want a grayscale image to be represented as

+RGB.  This code will do that conversion:

+    if (color_type == PNG_COLOR_TYPE_GRAY ||

+        color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

+          png_set_gray_to_rgb(png_ptr);

+Conversely, you can convert an RGB or RGBA image to grayscale or grayscale

+with alpha.

+    if (color_type == PNG_COLOR_TYPE_RGB ||

+        color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+          png_set_rgb_to_gray_fixed(png_ptr, error_action,

+             int red_weight, int green_weight);

+    error_action = 1: silently do the conversion

+    error_action = 2: issue a warning if the original

+                      image has any pixel where

+                      red != green or red != blue

+    error_action = 3: issue an error and abort the

+                      conversion if the original

+                      image has any pixel where

+                      red != green or red != blue

+    red_weight:       weight of red component times 100000

+    green_weight:     weight of green component times 100000

+                      If either weight is negative, default

+                      weights (21268, 71514) are used.

+If you have set error_action = 1 or 2, you can

+later check whether the image really was gray, after processing

+the image rows, with the png_get_rgb_to_gray_status(png_ptr) function.

+It will return a png_byte that is zero if the image was gray or

+1 if there were any non-gray pixels.  bKGD and sBIT data

+will be silently converted to grayscale, using the green channel

+data, regardless of the error_action setting.

+With red_weight+green_weight<=100000,

+the normalized graylevel is computed:

+    int rw = red_weight * 65536;

+    int gw = green_weight * 65536;

+    int bw = 65536 - (rw + gw);

+    gray = (rw*red + gw*green + bw*blue)/65536;

+The default values approximate those recommended in the Charles

+Poynton's Color FAQ, <http://www.inforamp.net/~poynton/>

+Copyright (c) 1998-01-04 Charles Poynton <poynton at inforamp.net>

+    Y = 0.212671 * R + 0.715160 * G + 0.072169 * B

+Libpng approximates this with

+    Y = 0.21268 * R    + 0.7151 * G    + 0.07217 * B

+which can be expressed with integers as

+    Y = (6969 * R + 23434 * G + 2365 * B)/32768

+The calculation is done in a linear colorspace, if the image gamma

+is known.

+If you have a grayscale and you are using png_set_expand_depth(),

+png_set_expand(), or png_set_gray_to_rgb to change to truecolor or to

+a higher bit-depth, you must either supply the background color as a gray

+value at the original file bit-depth (need_expand = 1) or else supply the

+background color as an RGB triplet at the final, expanded bit depth

+(need_expand = 0).  Similarly, if you are reading a paletted image, you

+must either supply the background color as a palette index (need_expand = 1)

+or as an RGB triplet that may or may not be in the palette (need_expand = 0).

+    png_color_16 my_background;

+    png_color_16p image_background;

+    if (png_get_bKGD(png_ptr, info_ptr, &image_background))

+        png_set_background(png_ptr, image_background,

+          PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);

+    else

+        png_set_background(png_ptr, &my_background,

+          PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);

+The png_set_background() function tells libpng to composite images

+with alpha or simple transparency against the supplied background

+color.  If the PNG file contains a bKGD chunk (PNG_INFO_bKGD valid),

+you may use this color, or supply another color more suitable for

+the current display (e.g., the background color from a web page).  You

+need to tell libpng whether the color is in the gamma space of the

+display (PNG_BACKGROUND_GAMMA_SCREEN for colors you supply), the file

+(PNG_BACKGROUND_GAMMA_FILE for colors from the bKGD chunk), or one

+that is neither of these gammas (PNG_BACKGROUND_GAMMA_UNIQUE - I don't

+know why anyone would use this, but it's here).

+To properly display PNG images on any kind of system, the application needs

+to know what the display gamma is.  Ideally, the user will know this, and

+the application will allow them to set it.  One method of allowing the user

+to set the display gamma separately for each system is to check for a

+SCREEN_GAMMA or DISPLAY_GAMMA environment variable, which will hopefully be

+correctly set.

+Note that display_gamma is the overall gamma correction required to produce

+pleasing results, which depends on the lighting conditions in the surrounding

+environment.  In a dim or brightly lit room, no compensation other than

+the physical gamma exponent of the monitor is needed, while in a dark room

+a slightly smaller exponent is better.

+   double gamma, screen_gamma;

+   if (/* We have a user-defined screen

+       gamma value */)

+   {

+      screen_gamma = user_defined_screen_gamma;

+   }

+   /* One way that applications can share the same

+      screen gamma value */

+   else if ((gamma_str = getenv("SCREEN_GAMMA"))

+      != NULL)

+   {

+      screen_gamma = (double)atof(gamma_str);

+   }

+   /* If we don't have another value */

+   else

+   {

+      screen_gamma = 2.2; /* A good guess for a

+           PC monitor in a bright office or a dim room */

+      screen_gamma = 2.0; /* A good guess for a

+           PC monitor in a dark room */

+      screen_gamma = 1.7 or 1.0;  /* A good

+           guess for Mac systems */

+   }

+The png_set_gamma() function handles gamma transformations of the data.

+Pass both the file gamma and the current screen_gamma.  If the file does

+not have a gamma value, you can pass one anyway if you have an idea what

+it is (usually 0.45455 is a good guess for GIF images on PCs).  Note

+that file gammas are inverted from screen gammas.  See the discussions

+on gamma in the PNG specification for an excellent description of what

+gamma is, and why all applications should support it.  It is strongly

+recommended that PNG viewers support gamma correction.

+   if (png_get_gAMA(png_ptr, info_ptr, &gamma))

+      png_set_gamma(png_ptr, screen_gamma, gamma);

+   else

+      png_set_gamma(png_ptr, screen_gamma, 0.45455);

+If you need to reduce an RGB file to a paletted file, or if a paletted

+file has more entries then will fit on your screen, png_set_dither()

+will do that.  Note that this is a simple match dither that merely

+finds the closest color available.  This should work fairly well with

+optimized palettes, and fairly badly with linear color cubes.  If you

+pass a palette that is larger then maximum_colors, the file will

+reduce the number of colors in the palette so it will fit into

+maximum_colors.  If there is a histogram, it will use it to make

+more intelligent choices when reducing the palette.  If there is no

+histogram, it may not do as good a job.

+   if (color_type & PNG_COLOR_MASK_COLOR)

+   {

+      if (png_get_valid(png_ptr, info_ptr,

+         PNG_INFO_PLTE))

+      {

+         png_uint_16p histogram = NULL;

+         png_get_hIST(png_ptr, info_ptr,

+            &histogram);

+         png_set_dither(png_ptr, palette, num_palette,

+            max_screen_colors, histogram, 1);

+      }

+      else

+      {

+         png_color std_color_cube[MAX_SCREEN_COLORS] =

+            { ... colors ... };

+         png_set_dither(png_ptr, std_color_cube,

+            MAX_SCREEN_COLORS, MAX_SCREEN_COLORS,

+            NULL,0);

+      }

+   }

+PNG files describe monochrome as black being zero and white being one.

+The following code will reverse this (make black be one and white be

+zero):

+   if (bit_depth == 1 && color_type == PNG_COLOR_TYPE_GRAY)

+      png_set_invert_mono(png_ptr);

+This function can also be used to invert grayscale and gray-alpha images:

+   if (color_type == PNG_COLOR_TYPE_GRAY ||

+        color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

+      png_set_invert_mono(png_ptr);

+PNG files store 16 bit pixels in network byte order (big-endian,

+ie. most significant bits first).  This code changes the storage to the

+other way (little-endian, i.e. least significant bits first, the

+way PCs store them):

+    if (bit_depth == 16)

+        png_set_swap(png_ptr);

+If you are using packed-pixel images (1, 2, or 4 bits/pixel), and you

+need to change the order the pixels are packed into bytes, you can use:

+    if (bit_depth < 8)

+       png_set_packswap(png_ptr);

+Finally, you can write your own transformation function if none of

+the existing ones meets your needs.  This is done by setting a callback

+with

+    png_set_read_user_transform_fn(png_ptr,

+       read_transform_fn);

+You must supply the function

+    void read_transform_fn(png_ptr ptr, row_info_ptr

+       row_info, png_bytep data)

+See pngtest.c for a working example.  Your function will be called

+after all of the other transformations have been processed.

+You can also set up a pointer to a user structure for use by your

+callback function, and you can inform libpng that your transform

+function will change the number of channels or bit depth with the

+function

+    png_set_user_transform_info(png_ptr, user_ptr,

+       user_depth, user_channels);

+The user's application, not libpng, is responsible for allocating and

+freeing any memory required for the user structure.

+You can retrieve the pointer via the function

+png_get_user_transform_ptr().  For example:

+    voidp read_user_transform_ptr =

+       png_get_user_transform_ptr(png_ptr);

+The last thing to handle is interlacing; this is covered in detail below,

+but you must call the function here if you want libpng to handle expansion

+of the interlaced image.

+    number_of_passes = png_set_interlace_handling(png_ptr);

+After setting the transformations, libpng can update your png_info

+structure to reflect any transformations you've requested with this

+call.  This is most useful to update the info structure's rowbytes

+field so you can use it to allocate your image memory.  This function

+will also update your palette with the correct screen_gamma and

+background if these have been given with the calls above.

+    png_read_update_info(png_ptr, info_ptr);

+After you call png_read_update_info(), you can allocate any

+memory you need to hold the image.  The row data is simply

+raw byte data for all forms of images.  As the actual allocation

+varies among applications, no example will be given.  If you

+are allocating one large chunk, you will need to build an

+array of pointers to each row, as it will be needed for some

+of the functions below.

+.SS Reading image data

+After you've allocated memory, you can read the image data.

+The simplest way to do this is in one function call.  If you are

+allocating enough memory to hold the whole image, you can just

+call png_read_image() and libpng will read in all the image data

+and put it in the memory area supplied.  You will need to pass in

+an array of pointers to each row.

+This function automatically handles interlacing, so you don't need

+to call png_set_interlace_handling() or call this function multiple

+times, or any of that other stuff necessary with png_read_rows().

+   png_read_image(png_ptr, row_pointers);

+where row_pointers is:

+   png_bytep row_pointers[height];

+You can point to void or char or whatever you use for pixels.

+If you don't want to read in the whole image at once, you can

+use png_read_rows() instead.  If there is no interlacing (check

+interlace_type == PNG_INTERLACE_NONE), this is simple:

+    png_read_rows(png_ptr, row_pointers, NULL,

+       number_of_rows);

+where row_pointers is the same as in the png_read_image() call.

+If you are doing this just one row at a time, you can do this with

+a single row_pointer instead of an array of row_pointers:

+    png_bytep row_pointer = row;

+    png_read_row(png_ptr, row_pointer, NULL);

+If the file is interlaced (interlace_type != 0 in the IHDR chunk), things

+get somewhat harder.  The only current (PNG Specification version 1.2)

+interlacing type for PNG is (interlace_type == PNG_INTERLACE_ADAM7)

+is a somewhat complicated 2D interlace scheme, known as Adam7, that

+breaks down an image into seven smaller images of varying size, based

+on an 8x8 grid.

+libpng can fill out those images or it can give them to you "as is".

+If you want them filled out, there are two ways to do that.  The one

+mentioned in the PNG specification is to expand each pixel to cover

+those pixels that have not been read yet (the "rectangle" method).

+This results in a blocky image for the first pass, which gradually

+smooths out as more pixels are read.  The other method is the "sparkle"

+method, where pixels are drawn only in their final locations, with the

+rest of the image remaining whatever colors they were initialized to

+before the start of the read.  The first method usually looks better,

+but tends to be slower, as there are more pixels to put in the rows.

+If you don't want libpng to handle the interlacing details, just call

+png_read_rows() seven times to read in all seven images.  Each of the

+images is a valid image by itself, or they can all be combined on an

+8x8 grid to form a single image (although if you intend to combine them

+you would be far better off using the libpng interlace handling).

+The first pass will return an image 1/8 as wide as the entire image

+(every 8th column starting in column 0) and 1/8 as high as the original

+(every 8th row starting in row 0), the second will be 1/8 as wide

+(starting in column 4) and 1/8 as high (also starting in row 0).  The

+third pass will be 1/4 as wide (every 4th pixel starting in column 0) and

+1/8 as high (every 8th row starting in row 4), and the fourth pass will

+be 1/4 as wide and 1/4 as high (every 4th column starting in column 2,

+and every 4th row starting in row 0).  The fifth pass will return an

+image 1/2 as wide, and 1/4 as high (starting at column 0 and row 2),

+while the sixth pass will be 1/2 as wide and 1/2 as high as the original

+(starting in column 1 and row 0).  The seventh and final pass will be as

+wide as the original, and 1/2 as high, containing all of the odd

+numbered scanlines.  Phew!

+If you want libpng to expand the images, call this before calling

+png_start_read_image() or png_read_update_info():

+    if (interlace_type == PNG_INTERLACE_ADAM7)

+        number_of_passes

+           = png_set_interlace_handling(png_ptr);

+This will return the number of passes needed.  Currently, this

+is seven, but may change if another interlace type is added.

+This function can be called even if the file is not interlaced,

+where it will return one pass.

+If you are not going to display the image after each pass, but are

+going to wait until the entire image is read in, use the sparkle

+effect.  This effect is faster and the end result of either method

+is exactly the same.  If you are planning on displaying the image

+after each pass, the "rectangle" effect is generally considered the

+better looking one.

+If you only want the "sparkle" effect, just call png_read_rows() as

+normal, with the third parameter NULL.  Make sure you make pass over

+the image number_of_passes times, and you don't change the data in the

+rows between calls.  You can change the locations of the data, just

+not the data.  Each pass only writes the pixels appropriate for that

+pass, and assumes the data from previous passes is still valid.

+    png_read_rows(png_ptr, row_pointers, NULL,

+       number_of_rows);

+If you only want the first effect (the rectangles), do the same as

+before except pass the row buffer in the third parameter, and leave

+the second parameter NULL.

+    png_read_rows(png_ptr, NULL, row_pointers,

+       number_of_rows);

+.SS Finishing a sequential read

+After you are finished reading the image through either the high- or

+low-level interfaces, you can finish reading the file.  If you are

+interested in comments or time, which may be stored either before or

+after the image data, you should pass the separate png_info struct if

+you want to keep the comments from before and after the image

+separate.  If you are not interested, you can pass NULL.

+   png_read_end(png_ptr, end_info);

+When you are done, you can free all memory allocated by libpng like this:

+   png_destroy_read_struct(&png_ptr, &info_ptr,

+       &end_info);

+It is also possible to individually free the info_ptr members that

+point to libpng-allocated storage with the following function:

+    png_free_data(png_ptr, info_ptr, mask, seq)

+    mask - identifies data to be freed, a mask

+           containing the logical OR of one or

+           more of

+             PNG_FREE_PLTE, PNG_FREE_TRNS,

+             PNG_FREE_HIST, PNG_FREE_ICCP,

+             PNG_FREE_PCAL, PNG_FREE_ROWS,

+             PNG_FREE_SCAL, PNG_FREE_SPLT,

+             PNG_FREE_TEXT, PNG_FREE_UNKN,

+           or simply PNG_FREE_ALL

+    seq  - sequence number of item to be freed

+           (-1 for all items)

+This function may be safely called when the relevant storage has

+already been freed, or has not yet been allocated, or was allocated

+by the user and not by libpng,  and will in those

+cases do nothing.  The "seq" parameter is ignored if only one item

+of the selected data type, such as PLTE, is allowed.  If "seq" is not

+-1, and multiple items are allowed for the data type identified in

+the mask, such as text or sPLT, only the n'th item in the structure

+is freed, where n is "seq".

+The default behavior is only to free data that was allocated internally

+by libpng.  This can be changed, so that libpng will not free the data,

+or so that it will free data that was allocated by the user with png_malloc()

+or png_zalloc() and passed in via a png_set_*() function, with

+    png_data_freer(png_ptr, info_ptr, freer, mask)

+    mask   - which data elements are affected

+             same choices as in png_free_data()

+    freer  - one of

+               PNG_DESTROY_WILL_FREE_DATA

+               PNG_SET_WILL_FREE_DATA

+               PNG_USER_WILL_FREE_DATA

+This function only affects data that has already been allocated.

+You can call this function after reading the PNG data but before calling

+any png_set_*() functions, to control whether the user or the png_set_*()

+function is responsible for freeing any existing data that might be present,

+and again after the png_set_*() functions to control whether the user

+or png_destroy_*() is supposed to free the data.  When the user assumes

+responsibility for libpng-allocated data, the application must use

+png_free() to free it, and when the user transfers responsibility to libpng

+for data that the user has allocated, the user must have used png_malloc()

+or png_zalloc() to allocate it.

+If you allocated your row_pointers in a single block, as suggested above in

+the description of the high level read interface, you must not transfer

+responsibility for freeing it to the png_set_rows or png_read_destroy function,

+because they would also try to free the individual row_pointers[i].

+If you allocated text_ptr.text, text_ptr.lang, and text_ptr.translated_keyword

+separately, do not transfer responsibility for freeing text_ptr to libpng,

+because when libpng fills a png_text structure it combines these members with

+the key member, and png_free_data() will free only text_ptr.key.  Similarly,

+if you transfer responsibility for free'ing text_ptr from libpng to your

+application, your application must not separately free those members.

+The png_free_data() function will turn off the "valid" flag for anything

+it frees.  If you need to turn the flag off for a chunk that was freed by your

+application instead of by libpng, you can use

+    png_set_invalid(png_ptr, info_ptr, mask);

+    mask - identifies the chunks to be made invalid,

+           containing the logical OR of one or

+           more of

+             PNG_INFO_gAMA, PNG_INFO_sBIT,

+             PNG_INFO_cHRM, PNG_INFO_PLTE,

+             PNG_INFO_tRNS, PNG_INFO_bKGD,

+             PNG_INFO_hIST, PNG_INFO_pHYs,

+             PNG_INFO_oFFs, PNG_INFO_tIME,

+             PNG_INFO_pCAL, PNG_INFO_sRGB,

+             PNG_INFO_iCCP, PNG_INFO_sPLT,

+             PNG_INFO_sCAL, PNG_INFO_IDAT

+For a more compact example of reading a PNG image, see the file example.c.

+.SS Reading PNG files progressively

+The progressive reader is slightly different then the non-progressive

+reader.  Instead of calling png_read_info(), png_read_rows(), and

+png_read_end(), you make one call to png_process_data(), which calls

+callbacks when it has the info, a row, or the end of the image.  You

+set up these callbacks with png_set_progressive_read_fn().  You don't

+have to worry about the input/output functions of libpng, as you are

+giving the library the data directly in png_process_data().  I will

+assume that you have read the section on reading PNG files above,

+so I will only highlight the differences (although I will show

+all of the code).

+png_structp png_ptr;

+png_infop info_ptr;

+ /*  An example code fragment of how you would

+     initialize the progressive reader in your

+     application. */

+ int

+ initialize_png_reader()

+ {

+    png_ptr = png_create_read_struct

+        (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,

+         user_error_fn, user_warning_fn);

+    if (!png_ptr)

+        return (ERROR);

+    info_ptr = png_create_info_struct(png_ptr);

+    if (!info_ptr)

+    {

+        png_destroy_read_struct(&png_ptr, (png_infopp)NULL,

+           (png_infopp)NULL);

+        return (ERROR);

+    }

+    if (setjmp(png_jmpbuf(png_ptr)))

+    {

+        png_destroy_read_struct(&png_ptr, &info_ptr,

+           (png_infopp)NULL);

+        return (ERROR);

+    }

+    /* This one's new.  You can provide functions

+       to be called when the header info is valid,

+       when each row is completed, and when the image

+       is finished.  If you aren't using all functions,

+       you can specify NULL parameters.  Even when all

+       three functions are NULL, you need to call

+       png_set_progressive_read_fn().  You can use

+       any struct as the user_ptr (cast to a void pointer

+       for the function call), and retrieve the pointer

+       from inside the callbacks using the function

+          png_get_progressive_ptr(png_ptr);

+       which will return a void pointer, which you have

+       to cast appropriately.

+     */

+    png_set_progressive_read_fn(png_ptr, (void *)user_ptr,

+        info_callback, row_callback, end_callback);

+    return 0;

+ }

+ /* A code fragment that you call as you receive blocks

+   of data */

+ int

+ process_data(png_bytep buffer, png_uint_32 length)

+ {

+    if (setjmp(png_jmpbuf(png_ptr)))

+    {

+        png_destroy_read_struct(&png_ptr, &info_ptr,

+           (png_infopp)NULL);

+        return (ERROR);

+    }

+    /* This one's new also.  Simply give it a chunk

+       of data from the file stream (in order, of

+       course).  On machines with segmented memory

+       models machines, don't give it any more than

+       64K.  The library seems to run fine with sizes

+       of 4K. Although you can give it much less if

+       necessary (I assume you can give it chunks of

+       1 byte, I haven't tried less then 256 bytes

+       yet).  When this function returns, you may

+       want to display any rows that were generated

+       in the row callback if you don't already do

+       so there.

+     */

+    png_process_data(png_ptr, info_ptr, buffer, length);

+    return 0;

+ }

+ /* This function is called (as set by

+    png_set_progressive_read_fn() above) when enough data

+    has been supplied so all of the header has been

+    read.

+ */

+ void

+ info_callback(png_structp png_ptr, png_infop info)

+ {

+    /* Do any setup here, including setting any of

+       the transformations mentioned in the Reading

+       PNG files section.  For now, you _must_ call

+       either png_start_read_image() or

+       png_read_update_info() after all the

+       transformations are set (even if you don't set

+       any).  You may start getting rows before

+       png_process_data() returns, so this is your

+       last chance to prepare for that.

+     */

+ }

+ /* This function is called when each row of image

+    data is complete */

+ void

+ row_callback(png_structp png_ptr, png_bytep new_row,

+    png_uint_32 row_num, int pass)

+ {

+    /* If the image is interlaced, and you turned

+       on the interlace handler, this function will

+       be called for every row in every pass.  Some

+       of these rows will not be changed from the

+       previous pass.  When the row is not changed,

+       the new_row variable will be NULL.  The rows

+       and passes are called in order, so you don't

+       really need the row_num and pass, but I'm

+       supplying them because it may make your life

+       easier.

+       For the non-NULL rows of interlaced images,

+       you must call png_progressive_combine_row()

+       passing in the row and the old row.  You can

+       call this function for NULL rows (it will just

+       return) and for non-interlaced images (it just

+       does the memcpy for you) if it will make the

+       code easier.  Thus, you can just do this for

+       all cases:

+     */

+        png_progressive_combine_row(png_ptr, old_row,

+          new_row);

+    /* where old_row is what was displayed for

+       previously for the row.  Note that the first

+       pass (pass == 0, really) will completely cover

+       the old row, so the rows do not have to be

+       initialized.  After the first pass (and only

+       for interlaced images), you will have to pass

+       the current row, and the function will combine

+       the old row and the new row.

+    */

+ }

+ void

+ end_callback(png_structp png_ptr, png_infop info)

+ {

+    /* This function is called after the whole image

+       has been read, including any chunks after the

+       image (up to and including the IEND).  You

+       will usually have the same info chunk as you

+       had in the header, although some data may have

+       been added to the comments and time fields.

+       Most people won't do much here, perhaps setting

+       a flag that marks the image as finished.

+     */

+ }

+.SH IV. Writing

+Much of this is very similar to reading.  However, everything of

+importance is repeated here, so you won't have to constantly look

+back up in the reading section to understand writing.

+.SS Setup

+You will want to do the I/O initialization before you get into libpng,

+so if it doesn't work, you don't have anything to undo. If you are not

+using the standard I/O functions, you will need to replace them with

+custom writing functions.  See the discussion under Customizing libpng.

+    FILE *fp = fopen(file_name, "wb");

+    if (!fp)

+    {

+       return (ERROR);

+    }

+Next, png_struct and png_info need to be allocated and initialized.

+As these can be both relatively large, you may not want to store these

+on the stack, unless you have stack space to spare.  Of course, you

+will want to check if they return NULL.  If you are also reading,

+you won't want to name your read structure and your write structure

+both "png_ptr"; you can call them anything you like, such as

+"read_ptr" and "write_ptr".  Look at pngtest.c, for example.

+    png_structp png_ptr = png_create_write_struct

+       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,

+        user_error_fn, user_warning_fn);

+    if (!png_ptr)

+       return (ERROR);

+    png_infop info_ptr = png_create_info_struct(png_ptr);

+    if (!info_ptr)

+    {

+       png_destroy_write_struct(&png_ptr,

+         (png_infopp)NULL);

+       return (ERROR);

+    }

+If you want to use your own memory allocation routines,

+define PNG_USER_MEM_SUPPORTED and use

+png_create_write_struct_2() instead of png_create_write_struct():

+    png_structp png_ptr = png_create_write_struct_2

+       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,

+        user_error_fn, user_warning_fn, (png_voidp)

+        user_mem_ptr, user_malloc_fn, user_free_fn);

+After you have these structures, you will need to set up the

+error handling.  When libpng encounters an error, it expects to

+longjmp() back to your routine.  Therefore, you will need to call

+setjmp() and pass the png_jmpbuf(png_ptr).  If you

+write the file from different routines, you will need to update

+the png_jmpbuf(png_ptr) every time you enter a new routine that will

+call a png_*() function.  See your documentation of setjmp/longjmp

+for your compiler for more information on setjmp/longjmp.  See

+the discussion on libpng error handling in the Customizing Libpng

+section below for more information on the libpng error handling.

+    if (setjmp(png_jmpbuf(png_ptr)))

+    {

+       png_destroy_write_struct(&png_ptr, &info_ptr);

+       fclose(fp);

+       return (ERROR);

+    }

+    ...

+    return;

+If you would rather avoid the complexity of setjmp/longjmp issues,

+you can compile libpng with PNG_SETJMP_NOT_SUPPORTED, in which case

+errors will result in a call to PNG_ABORT() which defaults to abort().

+Now you need to set up the output code.  The default for libpng is to

+use the C function fwrite().  If you use this, you will need to pass a

+valid FILE * in the function png_init_io().  Be sure that the file is

+opened in binary mode.  Again, if you wish to handle writing data in

+another way, see the discussion on libpng I/O handling in the Customizing

+Libpng section below.

+    png_init_io(png_ptr, fp);

+.SS Write callbacks

+At this point, you can set up a callback function that will be

+called after each row has been written, which you can use to control

+a progress meter or the like.  It's demonstrated in pngtest.c.

+You must supply a function

+    void write_row_callback(png_ptr, png_uint_32 row,

+       int pass);

+    {

+      /* put your code here */

+    }

+(You can give it another name that you like instead of "write_row_callback")

+To inform libpng about your function, use

+    png_set_write_status_fn(png_ptr, write_row_callback);

+You now have the option of modifying how the compression library will

+run.  The following functions are mainly for testing, but may be useful

+in some cases, like if you need to write PNG files extremely fast and

+are willing to give up some compression, or if you want to get the

+maximum possible compression at the expense of slower writing.  If you

+have no special needs in this area, let the library do what it wants by

+not calling this function at all, as it has been tuned to deliver a good

+speed/compression ratio. The second parameter to png_set_filter() is

+the filter method, for which the only valid values are 0 (as of the

+July 1999 PNG specification, version 1.2) or 64 (if you are writing

+a PNG datastream that is to be embedded in a MNG datastream).  The third

+parameter is a flag that indicates which filter type(s) are to be tested

+for each scanline.  See the PNG specification for details on the specific filter

+types.

+    /* turn on or off filtering, and/or choose

+       specific filters.  You can use either a single

+       PNG_FILTER_VALUE_NAME or the logical OR of one

+       or more PNG_FILTER_NAME masks. */

+    png_set_filter(png_ptr, 0,

+       PNG_FILTER_NONE  | PNG_FILTER_VALUE_NONE |

+       PNG_FILTER_SUB   | PNG_FILTER_VALUE_SUB  |

+       PNG_FILTER_UP    | PNG_FILTER_VALUE_UP   |

+       PNG_FILTER_AVE   | PNG_FILTER_VALUE_AVE  |

+       PNG_FILTER_PAETH | PNG_FILTER_VALUE_PAETH|

+       PNG_ALL_FILTERS);

+If an application

+wants to start and stop using particular filters during compression,

+it should start out with all of the filters (to ensure that the previous

+row of pixels will be stored in case it's needed later), and then add

+and remove them after the start of compression.

+If you are writing a PNG datastream that is to be embedded in a MNG

+datastream, the second parameter can be either 0 or 64.

+The png_set_compression_*() functions interface to the zlib compression

+library, and should mostly be ignored unless you really know what you are

+doing.  The only generally useful call is png_set_compression_level()

+which changes how much time zlib spends on trying to compress the image

+data.  See the Compression Library (zlib.h and algorithm.txt, distributed

+with zlib) for details on the compression levels.

+    /* set the zlib compression level */

+    png_set_compression_level(png_ptr,

+        Z_BEST_COMPRESSION);

+    /* set other zlib parameters */

+    png_set_compression_mem_level(png_ptr, 8);

+    png_set_compression_strategy(png_ptr,

+        Z_DEFAULT_STRATEGY);

+    png_set_compression_window_bits(png_ptr, 15);

+    png_set_compression_method(png_ptr, 8);

+    png_set_compression_buffer_size(png_ptr, 8192)

+extern PNG_EXPORT(void,png_set_zbuf_size)

+.SS Setting the contents of info for output

+You now need to fill in the png_info structure with all the data you

+wish to write before the actual image.  Note that the only thing you

+are allowed to write after the image is the text chunks and the time

+chunk (as of PNG Specification 1.2, anyway).  See png_write_end() and

+the latest PNG specification for more information on that.  If you

+wish to write them before the image, fill them in now, and flag that

+data as being valid.  If you want to wait until after the data, don't

+fill them until png_write_end().  For all the fields in png_info and

+their data types, see png.h.  For explanations of what the fields

+contain, see the PNG specification.

+Some of the more important parts of the png_info are:

+    png_set_IHDR(png_ptr, info_ptr, width, height,

+       bit_depth, color_type, interlace_type,

+       compression_type, filter_method)

+    width          - holds the width of the image

+                     in pixels (up to 2^31).

+    height         - holds the height of the image

+                     in pixels (up to 2^31).

+    bit_depth      - holds the bit depth of one of the

+                     image channels.

+                     (valid values are 1, 2, 4, 8, 16

+                     and depend also on the

+                     color_type.  See also significant

+                     bits (sBIT) below).

+    color_type     - describes which color/alpha

+                     channels are present.

+                     PNG_COLOR_TYPE_GRAY

+                        (bit depths 1, 2, 4, 8, 16)

+                     PNG_COLOR_TYPE_GRAY_ALPHA

+                        (bit depths 8, 16)

+                     PNG_COLOR_TYPE_PALETTE

+                        (bit depths 1, 2, 4, 8)

+                     PNG_COLOR_TYPE_RGB

+                        (bit_depths 8, 16)

+                     PNG_COLOR_TYPE_RGB_ALPHA

+                        (bit_depths 8, 16)

+                     PNG_COLOR_MASK_PALETTE

+                     PNG_COLOR_MASK_COLOR

+                     PNG_COLOR_MASK_ALPHA

+    interlace_type - PNG_INTERLACE_NONE or

+                     PNG_INTERLACE_ADAM7

+    compression_type - (must be

+                     PNG_COMPRESSION_TYPE_DEFAULT)

+    filter_method  - (must be PNG_FILTER_TYPE_DEFAULT

+                     or, if you are writing a PNG to

+                     be embedded in a MNG datastream,

+                     can also be

+                     PNG_INTRAPIXEL_DIFFERENCING)

+    png_set_PLTE(png_ptr, info_ptr, palette,

+       num_palette);

+    palette        - the palette for the file

+                     (array of png_color)

+    num_palette    - number of entries in the palette

+    png_set_gAMA(png_ptr, info_ptr, gamma);

+    gamma          - the gamma the image was created

+                     at (PNG_INFO_gAMA)

+    png_set_sRGB(png_ptr, info_ptr, srgb_intent);

+    srgb_intent    - the rendering intent

+                     (PNG_INFO_sRGB) The presence of

+                     the sRGB chunk means that the pixel

+                     data is in the sRGB color space.

+                     This chunk also implies specific

+                     values of gAMA and cHRM.  Rendering

+                     intent is the CSS-1 property that

+                     has been defined by the International

+                     Color Consortium

+                     (http://www.color.org).

+                     It can be one of

+                     PNG_sRGB_INTENT_SATURATION,

+                     PNG_sRGB_INTENT_PERCEPTUAL,

+                     PNG_sRGB_INTENT_ABSOLUTE, or

+                     PNG_sRGB_INTENT_RELATIVE.

+    png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr,

+       srgb_intent);

+    srgb_intent    - the rendering intent

+                     (PNG_INFO_sRGB) The presence of the

+                     sRGB chunk means that the pixel

+                     data is in the sRGB color space.

+                     This function also causes gAMA and

+                     cHRM chunks with the specific values

+                     that are consistent with sRGB to be

+                     written.

+    png_set_iCCP(png_ptr, info_ptr, name, compression_type,

+                      profile, proflen);

+    name            - The profile name.

+    compression     - The compression type; always

+                      PNG_COMPRESSION_TYPE_BASE for PNG 1.0.

+                      You may give NULL to this argument to

+                      ignore it.

+    profile         - International Color Consortium color

+                      profile data. May contain NULs.

+    proflen         - length of profile data in bytes.

+    png_set_sBIT(png_ptr, info_ptr, sig_bit);

+    sig_bit        - the number of significant bits for

+                     (PNG_INFO_sBIT) each of the gray, red,

+                     green, and blue channels, whichever are

+                     appropriate for the given color type

+                     (png_color_16)

+    png_set_tRNS(png_ptr, info_ptr, trans, num_trans,

+       trans_values);

+    trans          - array of transparent entries for

+                     palette (PNG_INFO_tRNS)

+    trans_values   - graylevel or color sample values of

+                     the single transparent color for

+                     non-paletted images (PNG_INFO_tRNS)

+    num_trans      - number of transparent entries

+                     (PNG_INFO_tRNS)

+    png_set_hIST(png_ptr, info_ptr, hist);

+                    (PNG_INFO_hIST)

+    hist           - histogram of palette (array of

+                     png_uint_16)

+    png_set_tIME(png_ptr, info_ptr, mod_time);

+    mod_time       - time image was last modified

+                     (PNG_VALID_tIME)

+    png_set_bKGD(png_ptr, info_ptr, background);

+    background     - background color (PNG_VALID_bKGD)

+    png_set_text(png_ptr, info_ptr, text_ptr, num_text);

+    text_ptr       - array of png_text holding image

+                     comments

+    text_ptr[i].compression - type of compression used

+                 on "text" PNG_TEXT_COMPRESSION_NONE

+                           PNG_TEXT_COMPRESSION_zTXt

+                           PNG_ITXT_COMPRESSION_NONE

+                           PNG_ITXT_COMPRESSION_zTXt

+    text_ptr[i].key   - keyword for comment.  Must contain

+                 1-79 characters.

+    text_ptr[i].text  - text comments for current

+                         keyword.  Can be NULL or empty.

+    text_ptr[i].text_length - length of text string,

+                 after decompression, 0 for iTXt

+    text_ptr[i].itxt_length - length of itxt string,

+                 after decompression, 0 for tEXt/zTXt

+    text_ptr[i].lang  - language of comment (NULL or

+                         empty for unknown).

+    text_ptr[i].translated_keyword  - keyword in UTF-8 (NULL

+                         or empty for unknown).

+    num_text       - number of comments

+    png_set_sPLT(png_ptr, info_ptr, &palette_ptr,

+       num_spalettes);

+    palette_ptr    - array of png_sPLT_struct structures

+                     to be added to the list of palettes

+                     in the info structure.

+    num_spalettes  - number of palette structures to be

+                     added.

+    png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y,

+        unit_type);

+    offset_x  - positive offset from the left

+                     edge of the screen

+    offset_y  - positive offset from the top

+                     edge of the screen

+    unit_type - PNG_OFFSET_PIXEL, PNG_OFFSET_MICROMETER

+    png_set_pHYs(png_ptr, info_ptr, res_x, res_y,

+        unit_type);

+    res_x       - pixels/unit physical resolution

+                  in x direction

+    res_y       - pixels/unit physical resolution

+                  in y direction

+    unit_type   - PNG_RESOLUTION_UNKNOWN,

+                  PNG_RESOLUTION_METER

+    png_set_sCAL(png_ptr, info_ptr, unit, width, height)

+    unit        - physical scale units (an integer)

+    width       - width of a pixel in physical scale units

+    height      - height of a pixel in physical scale units

+                  (width and height are doubles)

+    png_set_sCAL_s(png_ptr, info_ptr, unit, width, height)

+    unit        - physical scale units (an integer)

+    width       - width of a pixel in physical scale units

+    height      - height of a pixel in physical scale units

+                 (width and height are strings like "2.54")

+    png_set_unknown_chunks(png_ptr, info_ptr, &unknowns,

+       num_unknowns)

+    unknowns          - array of png_unknown_chunk

+                        structures holding unknown chunks

+    unknowns[i].name  - name of unknown chunk

+    unknowns[i].data  - data of unknown chunk

+    unknowns[i].size  - size of unknown chunk's data

+    unknowns[i].location - position to write chunk in file

+                           0: do not write chunk

+                           PNG_HAVE_IHDR: before PLTE

+                           PNG_HAVE_PLTE: before IDAT

+                           PNG_AFTER_IDAT: after IDAT

+The "location" member is set automatically according to

+what part of the output file has already been written.

+You can change its value after calling png_set_unknown_chunks()

+as demonstrated in pngtest.c.  Within each of the "locations",

+the chunks are sequenced according to their position in the

+structure (that is, the value of "i", which is the order in which

+the chunk was either read from the input file or defined with

+png_set_unknown_chunks).

+A quick word about text and num_text.  text is an array of png_text

+structures.  num_text is the number of valid structures in the array.

+Each png_text structure holds a language code, a keyword, a text value,

+and a compression type.

+The compression types have the same valid numbers as the compression

+types of the image data.  Currently, the only valid number is zero.

+However, you can store text either compressed or uncompressed, unlike

+images, which always have to be compressed.  So if you don't want the

+text compressed, set the compression type to PNG_TEXT_COMPRESSION_NONE.

+Because tEXt and zTXt chunks don't have a language field, if you

+specify PNG_TEXT_COMPRESSION_NONE or PNG_TEXT_COMPRESSION_zTXt

+any language code or translated keyword will not be written out.

+Until text gets around 1000 bytes, it is not worth compressing it.

+After the text has been written out to the file, the compression type

+is set to PNG_TEXT_COMPRESSION_NONE_WR or PNG_TEXT_COMPRESSION_zTXt_WR,

+so that it isn't written out again at the end (in case you are calling

+png_write_end() with the same struct.

+The keywords that are given in the PNG Specification are:

+    Title            Short (one line) title or

+                     caption for image

+    Author           Name of image's creator

+    Description      Description of image (possibly long)

+    Copyright        Copyright notice

+    Creation Time    Time of original image creation

+                     (usually RFC 1123 format, see below)

+    Software         Software used to create the image

+    Disclaimer       Legal disclaimer

+    Warning          Warning of nature of content

+    Source           Device used to create the image

+    Comment          Miscellaneous comment; conversion

+                     from other image format

+The keyword-text pairs work like this.  Keywords should be short

+simple descriptions of what the comment is about.  Some typical

+keywords are found in the PNG specification, as is some recommendations

+on keywords.  You can repeat keywords in a file.  You can even write

+some text before the image and some after.  For example, you may want

+to put a description of the image before the image, but leave the

+disclaimer until after, so viewers working over modem connections

+don't have to wait for the disclaimer to go over the modem before

+they start seeing the image.  Finally, keywords should be full

+words, not abbreviations.  Keywords and text are in the ISO 8859-1

+(Latin-1) character set (a superset of regular ASCII) and can not

+contain NUL characters, and should not contain control or other

+unprintable characters.  To make the comments widely readable, stick

+with basic ASCII, and avoid machine specific character set extensions

+like the IBM-PC character set.  The keyword must be present, but

+you can leave off the text string on non-compressed pairs.

+Compressed pairs must have a text string, as only the text string

+is compressed anyway, so the compression would be meaningless.

+PNG supports modification time via the png_time structure.  Two

+conversion routines are provided, png_convert_from_time_t() for

+time_t and png_convert_from_struct_tm() for struct tm.  The

+time_t routine uses gmtime().  You don't have to use either of

+these, but if you wish to fill in the png_time structure directly,

+you should provide the time in universal time (GMT) if possible

+instead of your local time.  Note that the year number is the full

+year (e.g. 1998, rather than 98 - PNG is year 2000 compliant!), and

+that months start with 1.

+If you want to store the time of the original image creation, you should

+use a plain tEXt chunk with the "Creation Time" keyword.  This is

+necessary because the "creation time" of a PNG image is somewhat vague,

+depending on whether you mean the PNG file, the time the image was

+created in a non-PNG format, a still photo from which the image was

+scanned, or possibly the subject matter itself.  In order to facilitate

+machine-readable dates, it is recommended that the "Creation Time"

+tEXt chunk use RFC 1123 format dates (e.g. "22 May 1997 18:07:10 GMT"),

+although this isn't a requirement.  Unlike the tIME chunk, the

+"Creation Time" tEXt chunk is not expected to be automatically changed

+by the software.  To facilitate the use of RFC 1123 dates, a function

+png_convert_to_rfc1123(png_timep) is provided to convert from PNG

+time to an RFC 1123 format string.

+.SS Writing unknown chunks

+You can use the png_set_unknown_chunks function to queue up chunks

+for writing.  You give it a chunk name, raw data, and a size; that's

+all there is to it.  The chunks will be written by the next following

+png_write_info_before_PLTE, png_write_info, or png_write_end function.

+Any chunks previously read into the info structure's unknown-chunk

+list will also be written out in a sequence that satisfies the PNG

+specification's ordering rules.

+.SS The high-level write interface

+At this point there are two ways to proceed; through the high-level

+write interface, or through a sequence of low-level write operations.

+You can use the high-level interface if your image data is present

+in the info structure.  All defined output

+transformations are permitted, enabled by the following masks.

+    PNG_TRANSFORM_IDENTITY      No transformation

+    PNG_TRANSFORM_PACKING       Pack 1, 2 and 4-bit samples

+    PNG_TRANSFORM_PACKSWAP      Change order of packed

+                                pixels to LSB first

+    PNG_TRANSFORM_INVERT_MONO   Invert monochrome images

+    PNG_TRANSFORM_SHIFT         Normalize pixels to the

+                                sBIT depth

+    PNG_TRANSFORM_BGR           Flip RGB to BGR, RGBA

+                                to BGRA

+    PNG_TRANSFORM_SWAP_ALPHA    Flip RGBA to ARGB or GA

+                                to AG

+    PNG_TRANSFORM_INVERT_ALPHA  Change alpha from opacity

+                                to transparency

+    PNG_TRANSFORM_SWAP_ENDIAN   Byte-swap 16-bit samples

+    PNG_TRANSFORM_STRIP_FILLER  Strip out filler bytes.

+If you have valid image data in the info structure (you can use

+png_set_rows() to put image data in the info structure), simply do this:

+    png_write_png(png_ptr, info_ptr, png_transforms, NULL)

+where png_transforms is an integer containing the logical OR of some set of

+transformation flags.  This call is equivalent to png_write_info(),

+followed the set of transformations indicated by the transform mask,

+then png_write_image(), and finally png_write_end().

+(The final parameter of this call is not yet used.  Someday it might point

+to transformation parameters required by some future output transform.)

+You must use png_transforms and not call any png_set_transform() functions

+when you use png_write_png().

+.SS The low-level write interface

+If you are going the low-level route instead, you are now ready to

+write all the file information up to the actual image data.  You do

+this with a call to png_write_info().

+    png_write_info(png_ptr, info_ptr);

+Note that there is one transformation you may need to do before

+png_write_info().  In PNG files, the alpha channel in an image is the

+level of opacity.  If your data is supplied as a level of

+transparency, you can invert the alpha channel before you write it, so

+that 0 is fully transparent and 255 (in 8-bit or paletted images) or

+65535 (in 16-bit images) is fully opaque, with

+    png_set_invert_alpha(png_ptr);

+This must appear before png_write_info() instead of later with the

+other transformations because in the case of paletted images the tRNS

+chunk data has to be inverted before the tRNS chunk is written.  If

+your image is not a paletted image, the tRNS data (which in such cases

+represents a single color to be rendered as transparent) won't need to

+be changed, and you can safely do this transformation after your

+png_write_info() call.

+If you need to write a private chunk that you want to appear before

+the PLTE chunk when PLTE is present, you can write the PNG info in

+two steps, and insert code to write your own chunk between them:

+    png_write_info_before_PLTE(png_ptr, info_ptr);

+    png_set_unknown_chunks(png_ptr, info_ptr, ...);

+    png_write_info(png_ptr, info_ptr);

+After you've written the file information, you can set up the library

+to handle any special transformations of the image data.  The various

+ways to transform the data will be described in the order that they

+should occur.  This is important, as some of these change the color

+type and/or bit depth of the data, and some others only work on

+certain color types and bit depths.  Even though each transformation

+checks to see if it has data that it can do something with, you should

+make sure to only enable a transformation if it will be valid for the

+data.  For example, don't swap red and blue on grayscale data.

+PNG files store RGB pixels packed into 3 or 6 bytes.  This code tells

+the library to strip input data that has 4 or 8 bytes per pixel down

+to 3 or 6 bytes (or strip 2 or 4-byte grayscale+filler data to 1 or 2

+bytes per pixel).

+    png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);

+where the 0 is unused, and the location is either PNG_FILLER_BEFORE or

+PNG_FILLER_AFTER, depending upon whether the filler byte in the pixel

+is stored XRGB or RGBX.

+PNG files pack pixels of bit depths 1, 2, and 4 into bytes as small as

+they can, resulting in, for example, 8 pixels per byte for 1 bit files.

+If the data is supplied at 1 pixel per byte, use this code, which will

+correctly pack the pixels into a single byte:

+    png_set_packing(png_ptr);

+PNG files reduce possible bit depths to 1, 2, 4, 8, and 16.  If your

+data is of another bit depth, you can write an sBIT chunk into the

+file so that decoders can recover the original data if desired.

+    /* Set the true bit depth of the image data */

+    if (color_type & PNG_COLOR_MASK_COLOR)

+    {

+        sig_bit.red = true_bit_depth;

+        sig_bit.green = true_bit_depth;

+        sig_bit.blue = true_bit_depth;

+    }

+    else

+    {

+        sig_bit.gray = true_bit_depth;

+    }

+    if (color_type & PNG_COLOR_MASK_ALPHA)

+    {

+        sig_bit.alpha = true_bit_depth;

+    }

+    png_set_sBIT(png_ptr, info_ptr, &sig_bit);

+If the data is stored in the row buffer in a bit depth other than

+one supported by PNG (e.g. 3 bit data in the range 0-7 for a 4-bit PNG),

+this will scale the values to appear to be the correct bit depth as

+is required by PNG.

+    png_set_shift(png_ptr, &sig_bit);

+PNG files store 16 bit pixels in network byte order (big-endian,

+ie. most significant bits first).  This code would be used if they are

+supplied the other way (little-endian, i.e. least significant bits

+first, the way PCs store them):

+    if (bit_depth > 8)

+       png_set_swap(png_ptr);

+If you are using packed-pixel images (1, 2, or 4 bits/pixel), and you

+need to change the order the pixels are packed into bytes, you can use:

+    if (bit_depth < 8)

+       png_set_packswap(png_ptr);

+PNG files store 3 color pixels in red, green, blue order.  This code

+would be used if they are supplied as blue, green, red:

+    png_set_bgr(png_ptr);

+PNG files describe monochrome as black being zero and white being

+one. This code would be used if the pixels are supplied with this reversed

+(black being one and white being zero):

+    png_set_invert_mono(png_ptr);

+Finally, you can write your own transformation function if none of

+the existing ones meets your needs.  This is done by setting a callback

+with

+    png_set_write_user_transform_fn(png_ptr,

+       write_transform_fn);

+You must supply the function

+    void write_transform_fn(png_ptr ptr, row_info_ptr

+       row_info, png_bytep data)

+See pngtest.c for a working example.  Your function will be called

+before any of the other transformations are processed.

+You can also set up a pointer to a user structure for use by your

+callback function.

+    png_set_user_transform_info(png_ptr, user_ptr, 0, 0);

+The user_channels and user_depth parameters of this function are ignored

+when writing; you can set them to zero as shown.

+You can retrieve the pointer via the function png_get_user_transform_ptr().

+For example:

+    voidp write_user_transform_ptr =

+       png_get_user_transform_ptr(png_ptr);

+It is possible to have libpng flush any pending output, either manually,

+or automatically after a certain number of lines have been written.  To

+flush the output stream a single time call:

+    png_write_flush(png_ptr);

+and to have libpng flush the output stream periodically after a certain

+number of scanlines have been written, call:

+    png_set_flush(png_ptr, nrows);

+Note that the distance between rows is from the last time png_write_flush()

+was called, or the first row of the image if it has never been called.

+So if you write 50 lines, and then png_set_flush 25, it will flush the

+output on the next scanline, and every 25 lines thereafter, unless

+png_write_flush() is called before 25 more lines have been written.

+If nrows is too small (less than about 10 lines for a 640 pixel wide

+RGB image) the image compression may decrease noticeably (although this

+may be acceptable for real-time applications).  Infrequent flushing will

+only degrade the compression performance by a few percent over images

+that do not use flushing.

+.SS Writing the image data

+That's it for the transformations.  Now you can write the image data.

+The simplest way to do this is in one function call.  If you have the

+whole image in memory, you can just call png_write_image() and libpng

+will write the image.  You will need to pass in an array of pointers to

+each row.  This function automatically handles interlacing, so you don't

+need to call png_set_interlace_handling() or call this function multiple

+times, or any of that other stuff necessary with png_write_rows().

+    png_write_image(png_ptr, row_pointers);

+where row_pointers is:

+    png_byte *row_pointers[height];

+You can point to void or char or whatever you use for pixels.

+If you don't want to write the whole image at once, you can

+use png_write_rows() instead.  If the file is not interlaced,

+this is simple:

+    png_write_rows(png_ptr, row_pointers,

+       number_of_rows);

+row_pointers is the same as in the png_write_image() call.

+If you are just writing one row at a time, you can do this with

+a single row_pointer instead of an array of row_pointers:

+    png_bytep row_pointer = row;

+    png_write_row(png_ptr, row_pointer);

+When the file is interlaced, things can get a good deal more

+complicated.  The only currently (as of the PNG Specification

+version 1.2, dated July 1999) defined interlacing scheme for PNG files

+is the "Adam7" interlace scheme, that breaks down an

+image into seven smaller images of varying size.  libpng will build

+these images for you, or you can do them yourself.  If you want to

+build them yourself, see the PNG specification for details of which

+pixels to write when.

+If you don't want libpng to handle the interlacing details, just

+use png_set_interlace_handling() and call png_write_rows() the

+correct number of times to write all seven sub-images.

+If you want libpng to build the sub-images, call this before you start

+writing any rows:

+    number_of_passes =

+       png_set_interlace_handling(png_ptr);

+This will return the number of passes needed.  Currently, this

+is seven, but may change if another interlace type is added.

+Then write the complete image number_of_passes times.

+    png_write_rows(png_ptr, row_pointers,

+       number_of_rows);

+As some of these rows are not used, and thus return immediately,

+you may want to read about interlacing in the PNG specification,

+and only update the rows that are actually used.

+.SS Finishing a sequential write

+After you are finished writing the image, you should finish writing

+the file.  If you are interested in writing comments or time, you should

+pass an appropriately filled png_info pointer.  If you are not interested,

+you can pass NULL.

+    png_write_end(png_ptr, info_ptr);

+When you are done, you can free all memory used by libpng like this:

+    png_destroy_write_struct(&png_ptr, &info_ptr);

+It is also possible to individually free the info_ptr members that

+point to libpng-allocated storage with the following function:

+    png_free_data(png_ptr, info_ptr, mask, seq)

+    mask  - identifies data to be freed, a mask

+            containing the logical OR of one or

+            more of

+              PNG_FREE_PLTE, PNG_FREE_TRNS,

+              PNG_FREE_HIST, PNG_FREE_ICCP,

+              PNG_FREE_PCAL, PNG_FREE_ROWS,

+              PNG_FREE_SCAL, PNG_FREE_SPLT,

+              PNG_FREE_TEXT, PNG_FREE_UNKN,

+            or simply PNG_FREE_ALL

+    seq   - sequence number of item to be freed

+            (-1 for all items)

+This function may be safely called when the relevant storage has

+already been freed, or has not yet been allocated, or was allocated

+by the user  and not by libpng,  and will in those

+cases do nothing.  The "seq" parameter is ignored if only one item

+of the selected data type, such as PLTE, is allowed.  If "seq" is not

+-1, and multiple items are allowed for the data type identified in

+the mask, such as text or sPLT, only the n'th item in the structure

+is freed, where n is "seq".

+If you allocated data such as a palette that you passed

+in to libpng with png_set_*, you must not free it until just before the call to

+png_destroy_write_struct().

+The default behavior is only to free data that was allocated internally

+by libpng.  This can be changed, so that libpng will not free the data,

+or so that it will free data that was allocated by the user with png_malloc()

+or png_zalloc() and passed in via a png_set_*() function, with

+    png_data_freer(png_ptr, info_ptr, freer, mask)

+    mask   - which data elements are affected

+             same choices as in png_free_data()

+    freer  - one of

+               PNG_DESTROY_WILL_FREE_DATA

+               PNG_SET_WILL_FREE_DATA

+               PNG_USER_WILL_FREE_DATA

+For example, to transfer responsibility for some data from a read structure

+to a write structure, you could use

+    png_data_freer(read_ptr, read_info_ptr,

+       PNG_USER_WILL_FREE_DATA,

+       PNG_FREE_PLTE|PNG_FREE_tRNS|PNG_FREE_hIST)

+    png_data_freer(write_ptr, write_info_ptr,

+       PNG_DESTROY_WILL_FREE_DATA,

+       PNG_FREE_PLTE|PNG_FREE_tRNS|PNG_FREE_hIST)

+thereby briefly reassigning responsibility for freeing to the user but

+immediately afterwards reassigning it once more to the write_destroy

+function.  Having done this, it would then be safe to destroy the read

+structure and continue to use the PLTE, tRNS, and hIST data in the write

+structure.

+This function only affects data that has already been allocated.

+You can call this function before calling after the png_set_*() functions

+to control whether the user or png_destroy_*() is supposed to free the data.

+When the user assumes responsibility for libpng-allocated data, the

+application must use

+png_free() to free it, and when the user transfers responsibility to libpng

+for data that the user has allocated, the user must have used png_malloc()

+or png_zalloc() to allocate it.

+If you allocated text_ptr.text, text_ptr.lang, and text_ptr.translated_keyword

+separately, do not transfer responsibility for freeing text_ptr to libpng,

+because when libpng fills a png_text structure it combines these members with

+the key member, and png_free_data() will free only text_ptr.key.  Similarly,

+if you transfer responsibility for free'ing text_ptr from libpng to your

+application, your application must not separately free those members.

+For a more compact example of writing a PNG image, see the file example.c.

+.SH V. Modifying/Customizing libpng:

+There are three issues here.  The first is changing how libpng does

+standard things like memory allocation, input/output, and error handling.

+The second deals with more complicated things like adding new chunks,

+adding new transformations, and generally changing how libpng works.

+Both of those are compile-time issues; that is, they are generally

+determined at the time the code is written, and there is rarely a need

+to provide the user with a means of changing them.  The third is a

+run-time issue:  choosing between and/or tuning one or more alternate

+versions of computationally intensive routines; specifically, optimized

+assembly-language (and therefore compiler- and platform-dependent)

+versions.

+Memory allocation, input/output, and error handling

+All of the memory allocation, input/output, and error handling in libpng

+goes through callbacks that are user-settable.  The default routines are

+in pngmem.c, pngrio.c, pngwio.c, and pngerror.c, respectively.  To change

+these functions, call the appropriate png_set_*_fn() function.

+Memory allocation is done through the functions png_malloc()

+and png_free().  These currently just call the standard C functions.  If

+your pointers can't access more then 64K at a time, you will want to set

+MAXSEG_64K in zlib.h.  Since it is unlikely that the method of handling

+memory allocation on a platform will change between applications, these

+functions must be modified in the library at compile time.  If you prefer

+to use a different method of allocating and freeing data, you can use

+png_create_read_struct_2() or png_create_write_struct_2() to register

+your own functions as described above.

+These functions also provide a void pointer that can be retrieved via

+    mem_ptr=png_get_mem_ptr(png_ptr);

+Your replacement memory functions must have prototypes as follows:

+    png_voidp malloc_fn(png_structp png_ptr,

+       png_size_t size);

+    void free_fn(png_structp png_ptr, png_voidp ptr);

+Your malloc_fn() must return NULL in case of failure.  The png_malloc()

+function will normally call png_error() if it receives a NULL from the

+system memory allocator or from your replacement malloc_fn().

+Input/Output in libpng is done through png_read() and png_write(),

+which currently just call fread() and fwrite().  The FILE * is stored in

+png_struct and is initialized via png_init_io().  If you wish to change

+the method of I/O, the library supplies callbacks that you can set

+through the function png_set_read_fn() and png_set_write_fn() at run

+time, instead of calling the png_init_io() function.  These functions

+also provide a void pointer that can be retrieved via the function

+png_get_io_ptr().  For example:

+    png_set_read_fn(png_structp read_ptr,

+        voidp read_io_ptr, png_rw_ptr read_data_fn)

+    png_set_write_fn(png_structp write_ptr,

+        voidp write_io_ptr, png_rw_ptr write_data_fn,

+        png_flush_ptr output_flush_fn);

+    voidp read_io_ptr = png_get_io_ptr(read_ptr);

+    voidp write_io_ptr = png_get_io_ptr(write_ptr);

+The replacement I/O functions must have prototypes as follows:

+    void user_read_data(png_structp png_ptr,

+        png_bytep data, png_size_t length);

+    void user_write_data(png_structp png_ptr,

+        png_bytep data, png_size_t length);

+    void user_flush_data(png_structp png_ptr);

+Supplying NULL for the read, write, or flush functions sets them back

+to using the default C stream functions.  It is an error to read from

+a write stream, and vice versa.

+Error handling in libpng is done through png_error() and png_warning().

+Errors handled through png_error() are fatal, meaning that png_error()

+should never return to its caller.  Currently, this is handled via

+setjmp() and longjmp() (unless you have compiled libpng with

+PNG_SETJMP_NOT_SUPPORTED, in which case it is handled via PNG_ABORT()),

+but you could change this to do things like exit() if you should wish.

+On non-fatal errors, png_warning() is called

+to print a warning message, and then control returns to the calling code.

+By default png_error() and png_warning() print a message on stderr via

+fprintf() unless the library is compiled with PNG_NO_CONSOLE_IO defined

+(because you don't want the messages) or PNG_NO_STDIO defined (because

+fprintf() isn't available).  If you wish to change the behavior of the error

+functions, you will need to set up your own message callbacks.  These

+functions are normally supplied at the time that the png_struct is created.

+It is also possible to redirect errors and warnings to your own replacement

+functions after png_create_*_struct() has been called by calling:

+    png_set_error_fn(png_structp png_ptr,

+        png_voidp error_ptr, png_error_ptr error_fn,

+        png_error_ptr warning_fn);

+    png_voidp error_ptr = png_get_error_ptr(png_ptr);

+If NULL is supplied for either error_fn or warning_fn, then the libpng

+default function will be used, calling fprintf() and/or longjmp() if a

+problem is encountered.  The replacement error functions should have

+parameters as follows:

+    void user_error_fn(png_structp png_ptr,

+        png_const_charp error_msg);

+    void user_warning_fn(png_structp png_ptr,

+        png_const_charp warning_msg);

+The motivation behind using setjmp() and longjmp() is the C++ throw and

+catch exception handling methods.  This makes the code much easier to write,

+as there is no need to check every return code of every function call.

+However, there are some uncertainties about the status of local variables

+after a longjmp, so the user may want to be careful about doing anything after

+setjmp returns non-zero besides returning itself.  Consult your compiler

+documentation for more details.  For an alternative approach, you may wish

+to use the "cexcept" facility (see http://cexcept.sourceforge.net).

+.SS Custom chunks

+If you need to read or write custom chunks, you may need to get deeper

+into the libpng code.  The library now has mechanisms for storing

+and writing chunks of unknown type; you can even declare callbacks

+for custom chunks.  Hoewver, this may not be good enough if the

+library code itself needs to know about interactions between your

+chunk and existing `intrinsic' chunks.

+If you need to write a new intrinsic chunk, first read the PNG

+specification. Acquire a first level of

+understanding of how it works.  Pay particular attention to the

+sections that describe chunk names, and look at how other chunks were

+designed, so you can do things similarly.  Second, check out the

+sections of libpng that read and write chunks.  Try to find a chunk

+that is similar to yours and use it as a template.  More details can

+be found in the comments inside the code.  It is best to handle unknown

+chunks in a generic method, via callback functions, instead of by

+modifying libpng functions.

+If you wish to write your own transformation for the data, look through

+the part of the code that does the transformations, and check out some of

+the simpler ones to get an idea of how they work.  Try to find a similar

+transformation to the one you want to add and copy off of it.  More details

+can be found in the comments inside the code itself.

+.SS Configuring for 16 bit platforms

+You will want to look into zconf.h to tell zlib (and thus libpng) that

+it cannot allocate more then 64K at a time.  Even if you can, the memory

+won't be accessible.  So limit zlib and libpng to 64K by defining MAXSEG_64K.

+.SS Configuring for DOS

+For DOS users who only have access to the lower 640K, you will

+have to limit zlib's memory usage via a png_set_compression_mem_level()

+call.  See zlib.h or zconf.h in the zlib library for more information.

+.SS Configuring for Medium Model

+Libpng's support for medium model has been tested on most of the popular

+compilers.  Make sure MAXSEG_64K gets defined, USE_FAR_KEYWORD gets

+defined, and FAR gets defined to far in pngconf.h, and you should be

+all set.  Everything in the library (except for zlib's structure) is

+expecting far data.  You must use the typedefs with the p or pp on

+the end for pointers (or at least look at them and be careful).  Make

+note that the rows of data are defined as png_bytepp, which is an

+unsigned char far * far *.

+.SS Configuring for gui/windowing platforms:

+You will need to write new error and warning functions that use the GUI

+interface, as described previously, and set them to be the error and

+warning functions at the time that png_create_*_struct() is called,

+in order to have them available during the structure initialization.

+They can be changed later via png_set_error_fn().  On some compilers,

+you may also have to change the memory allocators (png_malloc, etc.).

+.SS Configuring for compiler xxx:

+All includes for libpng are in pngconf.h.  If you need to add/change/delete

+an include, this is the place to do it.  The includes that are not

+needed outside libpng are protected by the PNG_INTERNAL definition,

+which is only defined for those routines inside libpng itself.  The

+files in libpng proper only include png.h, which includes pngconf.h.

+.SS Configuring zlib:

+There are special functions to configure the compression.  Perhaps the

+most useful one changes the compression level, which currently uses

+input compression values in the range 0 - 9.  The library normally

+uses the default compression level (Z_DEFAULT_COMPRESSION = 6).  Tests

+have shown that for a large majority of images, compression values in

+the range 3-6 compress nearly as well as higher levels, and do so much

+faster.  For online applications it may be desirable to have maximum speed

+(Z_BEST_SPEED = 1).  With versions of zlib after v0.99, you can also

+specify no compression (Z_NO_COMPRESSION = 0), but this would create

+files larger than just storing the raw bitmap.  You can specify the

+compression level by calling:

+    png_set_compression_level(png_ptr, level);

+Another useful one is to reduce the memory level used by the library.

+The memory level defaults to 8, but it can be lowered if you are

+short on memory (running DOS, for example, where you only have 640K).

+Note that the memory level does have an effect on compression; among

+other things, lower levels will result in sections of incompressible

+data being emitted in smaller stored blocks, with a correspondingly

+larger relative overhead of up to 15% in the worst case.

+    png_set_compression_mem_level(png_ptr, level);

+The other functions are for configuring zlib.  They are not recommended

+for normal use and may result in writing an invalid PNG file.  See

+zlib.h for more information on what these mean.

+    png_set_compression_strategy(png_ptr,

+        strategy);

+    png_set_compression_window_bits(png_ptr,

+        window_bits);

+    png_set_compression_method(png_ptr, method);

+    png_set_compression_buffer_size(png_ptr, size);

+.SS Controlling row filtering

+If you want to control whether libpng uses filtering or not, which

+filters are used, and how it goes about picking row filters, you

+can call one of these functions.  The selection and configuration

+of row filters can have a significant impact on the size and

+encoding speed and a somewhat lesser impact on the decoding speed

+of an image.  Filtering is enabled by default for RGB and grayscale

+images (with and without alpha), but not for paletted images nor

+for any images with bit depths less than 8 bits/pixel.

+The 'method' parameter sets the main filtering method, which is

+currently only '0' in the PNG 1.2 specification.  The 'filters'

+parameter sets which filter(s), if any, should be used for each

+scanline.  Possible values are PNG_ALL_FILTERS and PNG_NO_FILTERS

+to turn filtering on and off, respectively.

+Individual filter types are PNG_FILTER_NONE, PNG_FILTER_SUB,

+PNG_FILTER_UP, PNG_FILTER_AVG, PNG_FILTER_PAETH, which can be bitwise

+ORed together with '|' to specify one or more filters to use.

+These filters are described in more detail in the PNG specification.

+If you intend to change the filter type during the course of writing

+the image, you should start with flags set for all of the filters

+you intend to use so that libpng can initialize its internal

+structures appropriately for all of the filter types.  (Note that this

+means the first row must always be adaptively filtered, because libpng

+currently does not allocate the filter buffers until png_write_row()

+is called for the first time.)

+    filters = PNG_FILTER_NONE | PNG_FILTER_SUB

+              PNG_FILTER_UP | PNG_FILTER_AVE |

+              PNG_FILTER_PAETH | PNG_ALL_FILTERS;

+    png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE,

+       filters);

+              The second parameter can also be

+              PNG_INTRAPIXEL_DIFFERENCING if you are

+              writing a PNG to be embedded in a MNG

+              datastream.  This parameter must be the

+              same as the value of filter_method used

+              in png_set_IHDR().

+It is also possible to influence how libpng chooses from among the

+available filters.  This is done in one or both of two ways - by

+telling it how important it is to keep the same filter for successive

+rows, and by telling it the relative computational costs of the filters.

+    double weights[3] = {1.5, 1.3, 1.1},

+       costs[PNG_FILTER_VALUE_LAST] =

+       {1.0, 1.3, 1.3, 1.5, 1.7};

+    png_set_filter_heuristics(png_ptr,

+       PNG_FILTER_HEURISTIC_WEIGHTED, 3,

+       weights, costs);

+The weights are multiplying factors that indicate to libpng that the

+row filter should be the same for successive rows unless another row filter

+is that many times better than the previous filter.  In the above example,

+if the previous 3 filters were SUB, SUB, NONE, the SUB filter could have a

+"sum of absolute differences" 1.5 x 1.3 times higher than other filters

+and still be chosen, while the NONE filter could have a sum 1.1 times

+higher than other filters and still be chosen.  Unspecified weights are

+taken to be 1.0, and the specified weights should probably be declining

+like those above in order to emphasize recent filters over older filters.

+The filter costs specify for each filter type a relative decoding cost

+to be considered when selecting row filters.  This means that filters

+with higher costs are less likely to be chosen over filters with lower

+costs, unless their "sum of absolute differences" is that much smaller.

+The costs do not necessarily reflect the exact computational speeds of

+the various filters, since this would unduly influence the final image

+size.

+Note that the numbers above were invented purely for this example and

+are given only to help explain the function usage.  Little testing has

+been done to find optimum values for either the costs or the weights.

+.SS Removing unwanted object code

+There are a bunch of #define's in pngconf.h that control what parts of

+libpng are compiled.  All the defines end in _SUPPORTED.  If you are

+never going to use a capability, you can change the #define to #undef

+before recompiling libpng and save yourself code and data space, or

+you can turn off individual capabilities with defines that begin with

+PNG_NO_.

+You can also turn all of the transforms and ancillary chunk capabilities

+off en masse with compiler directives that define

+PNG_NO_READ[or WRITE]_TRANSFORMS, or PNG_NO_READ[or WRITE]_ANCILLARY_CHUNKS,

+or all four,

+along with directives to turn on any of the capabilities that you do

+want.  The PNG_NO_READ[or WRITE]_TRANSFORMS directives disable

+the extra transformations but still leave the library fully capable of reading

+and writing PNG files with all known public chunks

+Use of the PNG_NO_READ[or WRITE]_ANCILLARY_CHUNKS directive

+produces a library that is incapable of reading or writing ancillary chunks.

+If you are not using the progressive reading capability, you can

+turn that off with PNG_NO_PROGRESSIVE_READ (don't confuse

+this with the INTERLACING capability, which you'll still have).

+All the reading and writing specific code are in separate files, so the

+linker should only grab the files it needs.  However, if you want to

+make sure, or if you are building a stand alone library, all the

+reading files start with pngr and all the writing files start with

+pngw.  The files that don't match either (like png.c, pngtrans.c, etc.)

+are used for both reading and writing, and always need to be included.

+The progressive reader is in pngpread.c

+If you are creating or distributing a dynamically linked library (a .so

+or DLL file), you should not remove or disable any parts of the library,

+as this will cause applications linked with different versions of the

+library to fail if they call functions not available in your library.

+The size of the library itself should not be an issue, because only

+those sections that are actually used will be loaded into memory.

+.SS Requesting debug printout

+The macro definition PNG_DEBUG can be used to request debugging

+printout.  Set it to an integer value in the range 0 to 3.  Higher

+numbers result in increasing amounts of debugging information.  The

+information is printed to the "stderr" file, unless another file

+name is specified in the PNG_DEBUG_FILE macro definition.

+When PNG_DEBUG > 0, the following functions (macros) become available:

+   png_debug(level, message)

+   png_debug1(level, message, p1)

+   png_debug2(level, message, p1, p2)

+in which "level" is compared to PNG_DEBUG to decide whether to print

+the message, "message" is the formatted string to be printed,

+and p1 and p2 are parameters that are to be embedded in the string

+according to printf-style formatting directives.  For example,

+   png_debug1(2, "foo=%d\n", foo);

+is expanded to

+   if(PNG_DEBUG > 2)

+     fprintf(PNG_DEBUG_FILE, "foo=%d\n", foo);

+When PNG_DEBUG is defined but is zero, the macros aren't defined, but you

+can still use PNG_DEBUG to control your own debugging:

+   #ifdef PNG_DEBUG

+       fprintf(stderr, ...

+   #endif

+When PNG_DEBUG = 1, the macros are defined, but only png_debug statements

+having level = 0 will be printed.  There aren't any such statements in

+this version of libpng, but if you insert some they will be printed.

+.SH VI.  Runtime optimization

+A new feature in libpng 1.2.0 is the ability to dynamically switch between

+standard and optimized versions of some routines.  Currently these are

+limited to three computationally intensive tasks when reading PNG files:

+decoding row filters, expanding interlacing, and combining interlaced or

+transparent row data with previous row data.  Currently the optimized

+versions are available only for x86 (Intel, AMD, etc.) platforms with

+MMX support, though this may change in future versions.  (For example,

+the non-MMX assembler optimizations for zlib might become similarly

+runtime-selectable in future releases, in which case libpng could be

+extended to support them.  Alternatively, the compile-time choice of

+floating-point versus integer routines for gamma correction might become

+runtime-selectable.)

+Because such optimizations tend to be very platform- and compiler-dependent,

+both in how they are written and in how they perform, the new runtime code

+in libpng has been written to allow programs to query, enable, and disable

+either specific optimizations or all such optimizations.  For example, to

+enable all possible optimizations (bearing in mind that some "optimizations"

+may actually run more slowly in rare cases):

+    #if defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)

+       png_uint_32 mask, flags;

+       flags = png_get_asm_flags(png_ptr);

+       mask = png_get_asm_flagmask(PNG_SELECT_READ | PNG_SELECT_WRITE);

+       png_set_asm_flags(png_ptr, flags | mask);

+    #endif

+To enable only optimizations relevant to reading PNGs, use PNG_SELECT_READ

+by itself when calling png_get_asm_flagmask(); similarly for optimizing

+only writing.  To disable all optimizations:

+    #if defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)

+       flags = png_get_asm_flags(png_ptr);

+       mask = png_get_asm_flagmask(PNG_SELECT_READ | PNG_SELECT_WRITE);

+       png_set_asm_flags(png_ptr, flags & ~mask);

+    #endif

+To enable or disable only MMX-related features, use png_get_mmx_flagmask()

+in place of png_get_asm_flagmask().  The mmx version takes one additional

+parameter:

+    #if defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)

+       int selection = PNG_SELECT_READ | PNG_SELECT_WRITE;

+       int compilerID;

+       mask = png_get_mmx_flagmask(selection, &compilerID);

+    #endif

+On return, compilerID will indicate which version of the MMX assembler

+optimizations was compiled.  Currently two flavors exist:  Microsoft

+Visual C++ (compilerID == 1) and GNU C (a.k.a. gcc/gas, compilerID == 2).

+On non-x86 platforms or on systems compiled without MMX optimizations, a

+value of -1 is used.

+Note that both png_get_asm_flagmask() and png_get_mmx_flagmask() return

+all valid, settable optimization bits for the version of the library that's

+currently in use.  In the case of shared (dynamically linked) libraries,

+this may include optimizations that did not exist at the time the code was

+written and compiled.  It is also possible, of course, to enable only known,

+specific optimizations; for example:

+    #if defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)

+       flags = PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  \

+             | PNG_ASM_FLAG_MMX_READ_INTERLACE    \

+             | PNG_ASM_FLAG_MMX_READ_FILTER_SUB   \

+             | PNG_ASM_FLAG_MMX_READ_FILTER_UP    \

+             | PNG_ASM_FLAG_MMX_READ_FILTER_AVG   \

+             | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;

+       png_set_asm_flags(png_ptr, flags);

+    #endif

+This method would enable only the MMX read-optimizations available at the

+time of libpng 1.2.0's release, regardless of whether a later version of

+the DLL were actually being used.  (Also note that these functions did not

+exist in versions older than 1.2.0, so any attempt to run a dynamically

+linked app on such an older version would fail.)

+To determine whether the processor supports MMX instructions at all, use

+the png_mmx_support() function:

+    #if defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)

+       mmxsupport = png_mmx_support();

+    #endif

+It returns -1 if MMX support is not compiled into libpng, 0 if MMX code

+is compiled but MMX is not supported by the processor, or 1 if MMX support

+is fully available.  Note that png_mmx_support(), png_get_mmx_flagmask(),

+and png_get_asm_flagmask() all may be called without allocating and ini-

+tializing any PNG structures (for example, as part of a usage screen or

+"about" box).

+The following code can be used to prevent an application from using the

+thread_unsafe features, even if libpng was built with PNG_THREAD_UNSAFE_OK

+defined:

+#if defined(PNG_USE_PNGGCCRD) && defined(PNG_ASSEMBLER_CODE_SUPPORTED) \

+  && defined(PNG_THREAD_UNSAFE_OK)

+    /* Disable thread-unsafe features of pnggccrd */

+    if (png_access_version() >= 10200)

+    {

+      png_uint_32 mmx_disable_mask = 0;

+      png_uint_32 asm_flags;

+      mmx_disable_mask |= ( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  \

+                          | PNG_ASM_FLAG_MMX_READ_FILTER_SUB   \

+                          | PNG_ASM_FLAG_MMX_READ_FILTER_AVG   \

+                          | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH );

+      asm_flags = png_get_asm_flags(png_ptr);

+      png_set_asm_flags(png_ptr, asm_flags & ~mmx_disable_mask);

+    }

+#endif

+For more extensive examples of runtime querying, enabling and disabling

+of optimized features, see contrib/gregbook/readpng2.c in the libpng

+source-code distribution.

+.SH VII.  MNG support

+The MNG specification (available at http://www.libpng.org/pub/mng) allows

+certain extensions to PNG for PNG images that are embedded in MNG datastreams.

+Libpng can support some of these extensions.  To enable them, use the

+png_permit_mng_features() function:

+   feature_set = png_permit_mng_features(png_ptr, mask)

+   mask is a png_uint_32 containing the logical OR of the

+        features you want to enable.  These include

+        PNG_FLAG_MNG_EMPTY_PLTE

+        PNG_FLAG_MNG_FILTER_64

+        PNG_ALL_MNG_FEATURES

+   feature_set is a png_uint_32 that is the logical AND of

+      your mask with the set of MNG features that is

+      supported by the version of libpng that you are using.

+It is an error to use this function when reading or writing a standalone

+PNG file with the PNG 8-byte signature.  The PNG datastream must be wrapped

+in a MNG datastream.  As a minimum, it must have the MNG 8-byte signature

+and the MHDR and MEND chunks.  Libpng does not provide support for these

+or any other MNG chunks; your application must provide its own support for

+them.  You may wish to consider using libmng (available at

+http://www.libmng.com) instead.

+.SH VIII.  Changes to Libpng from version 0.88

+It should be noted that versions of libpng later than 0.96 are not

+distributed by the original libpng author, Guy Schalnat, nor by

+Andreas Dilger, who had taken over from Guy during 1996 and 1997, and

+distributed versions 0.89 through 0.96, but rather by another member

+of the original PNG Group, Glenn Randers-Pehrson.  Guy and Andreas are

+still alive and well, but they have moved on to other things.

+The old libpng functions png_read_init(), png_write_init(),

+png_info_init(), png_read_destroy(), and png_write_destroy() have been

+moved to PNG_INTERNAL in version 0.95 to discourage their use.  These

+functions will be removed from libpng version 2.0.0.

+The preferred method of creating and initializing the libpng structures is

+via the png_create_read_struct(), png_create_write_struct(), and

+png_create_info_struct() because they isolate the size of the structures

+from the application, allow version error checking, and also allow the

+use of custom error handling routines during the initialization, which

+the old functions do not.  The functions png_read_destroy() and

+png_write_destroy() do not actually free the memory that libpng

+allocated for these structs, but just reset the data structures, so they

+can be used instead of png_destroy_read_struct() and

+png_destroy_write_struct() if you feel there is too much system overhead

+allocating and freeing the png_struct for each image read.

+Setting the error callbacks via png_set_message_fn() before

+png_read_init() as was suggested in libpng-0.88 is no longer supported

+because this caused applications that do not use custom error functions

+to fail if the png_ptr was not initialized to zero.  It is still possible

+to set the error callbacks AFTER png_read_init(), or to change them with

+png_set_error_fn(), which is essentially the same function, but with a new

+name to force compilation errors with applications that try to use the old

+method.

+Starting with version 1.0.7, you can find out which version of the library

+you are using at run-time:

+   png_uint_32 libpng_vn = png_access_version_number();

+The number libpng_vn is constructed from the major version, minor

+version with leading zero, and release number with leading zero,

+(e.g., libpng_vn for version 1.0.7 is 10007).

+You can also check which version of png.h you used when compiling your

+application:

+   png_uint_32 application_vn = PNG_LIBPNG_VER;

+.SH IX. Y2K Compliance in libpng

+December 3, 2004

+Since the PNG Development group is an ad-hoc body, we can't make

+an official declaration.

+This is your unofficial assurance that libpng from version 0.71 and

+upward through 1.2.8 are Y2K compliant.  It is my belief that earlier

+versions were also Y2K compliant.

+Libpng only has three year fields.  One is a 2-byte unsigned integer that

+will hold years up to 65535.  The other two hold the date in text

+format, and will hold years up to 9999.

+The integer is

+    "png_uint_16 year" in png_time_struct.

+The strings are

+    "png_charp time_buffer" in png_struct and

+    "near_time_buffer", which is a local character string in png.c.

+There are seven time-related functions:

+    png_convert_to_rfc_1123() in png.c

+      (formerly png_convert_to_rfc_1152() in error)

+    png_convert_from_struct_tm() in pngwrite.c, called

+      in pngwrite.c

+    png_convert_from_time_t() in pngwrite.c

+    png_get_tIME() in pngget.c

+    png_handle_tIME() in pngrutil.c, called in pngread.c

+    png_set_tIME() in pngset.c

+    png_write_tIME() in pngwutil.c, called in pngwrite.c

+All appear to handle dates properly in a Y2K environment.  The

+png_convert_from_time_t() function calls gmtime() to convert from system

+clock time, which returns (year - 1900), which we properly convert to

+the full 4-digit year.  There is a possibility that applications using

+libpng are not passing 4-digit years into the png_convert_to_rfc_1123()

+function, or that they are incorrectly passing only a 2-digit year

+instead of "year - 1900" into the png_convert_from_struct_tm() function,

+but this is not under our control.  The libpng documentation has always

+stated that it works with 4-digit years, and the APIs have been

+documented as such.

+The tIME chunk itself is also Y2K compliant.  It uses a 2-byte unsigned

+integer to hold the year, and can hold years as large as 65535.

+zlib, upon which libpng depends, is also Y2K compliant.  It contains

+no date-related code.

+   Glenn Randers-Pehrson

+   libpng maintainer

+   PNG Development Group

+.SH NOTE

+Note about libpng version numbers:

+Due to various miscommunications, unforeseen code incompatibilities

+and occasional factors outside the authors' control, version numbering

+on the library has not always been consistent and straightforward.

+The following table summarizes matters since version 0.89c, which was

+the first widely used release:

+ source             png.h  png.h  shared-lib

+ version            string   int  version

+ -------            ------  ----- ----------

+ 0.89c ("beta 3")  0.89       89  1.0.89

+ 0.90  ("beta 4")  0.90       90  0.90

+ 0.95  ("beta 5")  0.95       95  0.95

+ 0.96  ("beta 6")  0.96       96  0.96

+ 0.97b ("beta 7")  1.00.97    97  1.0.1

+ 0.97c             0.97       97  2.0.97

+ 0.98              0.98       98  2.0.98

+ 0.99              0.99       98  2.0.99

+ 0.99a-m           0.99       99  2.0.99

+ 1.00              1.00      100  2.1.0

+ 1.0.0             1.0.0     100  2.1.0

+ 1.0.0   (from here on, the  100  2.1.0

+ 1.0.1    png.h string is  10001  2.1.0

+ 1.0.1a-e identical to the 10002  from here on, the

+ 1.0.2    source version)  10002  shared library is 2.V

+ 1.0.2a-b                  10003  where V is the source

+ 1.0.1                     10001  code version except as

+ 1.0.1a-e                  10002  2.1.0.1a-e   noted.

+ 1.0.2                     10002  2.1.0.2

+ 1.0.2a-b                  10003  2.1.0.2a-b

+ 1.0.3                     10003  2.1.0.3

+ 1.0.3a-d                  10004  2.1.0.3a-d

+ 1.0.4                     10004  2.1.0.4

+ 1.0.4a-f                  10005  2.1.0.4a-f

+ 1.0.5 (+ 2 patches)       10005  2.1.0.5

+ 1.0.5a-d                  10006  2.1.0.5a-d

+ 1.0.5e-r                  10100  2.1.0.5e-r

+ 1.0.5s-v                  10006  2.1.0.5s-v

+ 1.0.6 (+ 3 patches)       10006  2.1.0.6

+ 1.0.6d-g                  10007  2.1.0.6d-g

+ 1.0.6h                    10007  10.6h

+ 1.0.6i                    10007  10.6i

+ 1.0.6j                    10007  2.1.0.6j

+ 1.0.7beta11-14    DLLNUM  10007  2.1.0.7beta11-14

+ 1.0.7beta15-18       1    10007  2.1.0.7beta15-18

+ 1.0.7rc1-2           1    10007  2.1.0.7rc1-2

+ 1.0.7                1    10007  2.1.0.7

+ 1.0.8beta1-4         1    10008  2.1.0.8beta1-4

+ 1.0.8rc1             1    10008  2.1.0.8rc1

+ 1.0.8                1    10008  2.1.0.8

+ 1.0.9beta1-6         1    10009  2.1.0.9beta1-6

+ 1.0.9rc1             1    10009  2.1.0.9rc1

+ 1.0.9beta7-10        1    10009  2.1.0.9beta7-10

+ 1.0.9rc2             1    10009  2.1.0.9rc2

+ 1.0.9                1    10009  2.1.0.9

+ 1.0.10beta1          1    10010  2.1.0.10beta1

+ 1.0.10rc1            1    10010  2.1.0.10rc1

+ 1.0.10               1    10010  2.1.0.10

+ 1.0.11beta1-3        1    10011  2.1.0.11beta1-3

+ 1.0.11rc1            1    10011  2.1.0.11rc1

+ 1.0.11               1    10011  2.1.0.11

+ 1.0.12beta1-2        2    10012  2.1.0.12beta1-2

+ 1.0.12rc1            2    10012  2.1.0.12rc1

+ 1.0.12               2    10012  2.1.0.12

+ 1.1.0a-f             -    10100  2.1.1.0a-f abandoned

+ 1.2.0beta1-2         2    10200  2.1.2.0beta1-2

+ 1.2.0beta3-5         3    10200  3.1.2.0beta3-5

+ 1.2.0rc1             3    10200  3.1.2.0rc1

+ 1.2.0                3    10200  3.1.2.0

+ 1.2.1beta-4          3    10201  3.1.2.1beta1-4

+ 1.2.1rc1-2           3    10201  3.1.2.1rc1-2

+ 1.2.1                3    10201  3.1.2.1

+ 1.2.2beta1-6        12    10202  12.so.0.1.2.2beta1-6

+ 1.0.13beta1         10    10013  10.so.0.1.0.13beta1

+ 1.0.13rc1           10    10013  10.so.0.1.0.13rc1

+ 1.2.2rc1            12    10202  12.so.0.1.2.2rc1

+ 1.0.13              10    10013  10.so.0.1.0.13

+ 1.2.2               12    10202  12.so.0.1.2.2

+ 1.2.3rc1-6          12    10203  12.so.0.1.2.3rc1-6

+ 1.2.3               12    10203  12.so.0.1.2.3

+ 1.2.4beta1-3        13    10204  12.so.0.1.2.4beta1-3

+ 1.2.4rc1            13    10204  12.so.0.1.2.4rc1

+ 1.0.14              10    10014  10.so.0.1.0.14

+ 1.2.4               13    10204  12.so.0.1.2.4

+ 1.2.5beta1-2        13    10205  12.so.0.1.2.5beta1-2

+ 1.0.15rc1           10    10015  10.so.0.1.0.15rc1

+ 1.0.15              10    10015  10.so.0.1.0.15

+ 1.2.5               13    10205  12.so.0.1.2.5

+ 1.2.6beta1-4        13    10206  12.so.0.1.2.6beta1-4

+ 1.2.6rc1-5          13    10206  12.so.0.1.2.6rc1-5

+ 1.0.16              10    10016  10.so.0.1.0.16

+ 1.2.6               13    10206  12.so.0.1.2.6

+ 1.2.7beta1-2        13    10207  12.so.0.1.2.7beta1-2

+ 1.0.17rc1           10    10017  12.so.0.1.0.17rc1

+ 1.2.7rc1            13    10207  12.so.0.1.2.7rc1

+ 1.0.17              10    10017  12.so.0.1.0.17

+ 1.2.7               13    10207  12.so.0.1.2.7

+ 1.2.8beta1-5        13    10208  12.so.0.1.2.8beta1-5

+ 1.0.18rc1-5         10    10018  12.so.0.1.0.18rc1-5

+ 1.2.8rc1-5          13    10208  12.so.0.1.2.8rc1-5

+ 1.0.18              10    10018  12.so.0.1.0.18

+ 1.2.8               13    10208  12.so.0.1.2.8

+Henceforth the source version will match the shared-library minor

+and patch numbers; the shared-library major version number will be

+used for changes in backward compatibility, as it is intended.  The

+PNG_PNGLIB_VER macro, which is not used within libpng but is available

+for applications, is an unsigned integer of the form xyyzz corresponding

+to the source version x.y.z (leading zeros in y and z).  Beta versions

+were given the previous public release number plus a letter, until

+version 1.0.6j; from then on they were given the upcoming public

+release number plus "betaNN" or "rcN".

+.SH "SEE ALSO"

+libpngpf(3), png(5)

+.LP

+.IR libpng :

+.IP

+http://libpng.sourceforge.net (follow the [DOWNLOAD] link)

+http://www.libpng.org/pub/png

+.LP

+.IR zlib :

+.IP

+(generally) at the same location as

+.I libpng

+or at

+.br

+ftp://ftp.info-zip.org/pub/infozip/zlib

+.LP

+.IR PNG specification: RFC 2083

+.IP

+(generally) at the same location as

+.I libpng

+or at

+.br

+ftp://ds.internic.net/rfc/rfc2083.txt

+.br

+or (as a W3C Recommendation) at

+.br

+http://www.w3.org/TR/REC-png.html

+.LP

+In the case of any inconsistency between the PNG specification

+and this library, the specification takes precedence.

+.SH AUTHORS

+This man page: Glenn Randers-Pehrson

+<glennrp at users.sourceforge.net>

+The contributing authors would like to thank all those who helped

+with testing, bug fixes, and patience.  This wouldn't have been

+possible without all of you.

+Thanks to Frank J. T. Wojcik for helping with the documentation.

+Libpng version 1.2.8 - December 3, 2004:

+Initially created in 1995 by Guy Eric Schalnat, then of Group 42, Inc.

+Currently maintained by Glenn Randers-Pehrson (glennrp at users.sourceforge.net).

+Supported by the PNG development group

+.br

+png-implement at ccrc.wustl.edu (subscription required; write to

+majordomo at ccrc.wustl.edu with "subscribe png-implement" in the message).

+.SH COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:

+(This copy of the libpng notices is provided for your convenience.  In case of

+any discrepancy between this copy and the notices in the file png.h that is

+included in the libpng distribution, the latter shall prevail.)

+If you modify libpng you may insert additional notices immediately following

+this sentence.

+libpng version 1.2.6, December 3, 2004, is

+Copyright (c) 2004 Glenn Randers-Pehrson, and is

+distributed according to the same disclaimer and license as libpng-1.2.5

+with the following individual added to the list of Contributing Authors

+   Cosmin Truta

+libpng versions 1.0.7, July 1, 2000, through 1.2.5 - October 3, 2002, are

+Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are

+distributed according to the same disclaimer and license as libpng-1.0.6

+with the following individuals added to the list of Contributing Authors

+   Simon-Pierre Cadieux

+   Eric S. Raymond

+   Gilles Vollant

+and with the following additions to the disclaimer:

+   There is no warranty against interference with your

+   enjoyment of the library or against infringement.

+   There is no warranty that our efforts or the library

+   will fulfill any of your particular purposes or needs.

+   This library is provided with all faults, and the entire

+   risk of satisfactory quality, performance, accuracy, and

+   effort is with the user.

+libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are

+Copyright (c) 1998, 1999 Glenn Randers-Pehrson

+Distributed according to the same disclaimer and license as libpng-0.96,

+with the following individuals added to the list of Contributing Authors:

+   Tom Lane

+   Glenn Randers-Pehrson

+   Willem van Schaik

+libpng versions 0.89, June 1996, through 0.96, May 1997, are

+Copyright (c) 1996, 1997 Andreas Dilger

+Distributed according to the same disclaimer and license as libpng-0.88,

+with the following individuals added to the list of Contributing Authors:

+   John Bowler

+   Kevin Bracey

+   Sam Bushell

+   Magnus Holmgren

+   Greg Roelofs

+   Tom Tanner

+libpng versions 0.5, May 1995, through 0.88, January 1996, are

+Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.

+For the purposes of this copyright and license, "Contributing Authors"

+is defined as the following set of individuals:

+   Andreas Dilger

+   Dave Martindale

+   Guy Eric Schalnat

+   Paul Schmidt

+   Tim Wegner

+The PNG Reference Library is supplied "AS IS".  The Contributing Authors

+and Group 42, Inc. disclaim all warranties, expressed or implied,

+including, without limitation, the warranties of merchantability and of

+fitness for any purpose.  The Contributing Authors and Group 42, Inc.

+assume no liability for direct, indirect, incidental, special, exemplary,

+or consequential damages, which may result from the use of the PNG

+Reference Library, even if advised of the possibility of such damage.

+Permission is hereby granted to use, copy, modify, and distribute this

+source code, or portions hereof, for any purpose, without fee, subject

+to the following restrictions:

+1. The origin of this source code must not be misrepresented.

+2. Altered versions must be plainly marked as such and

+   must not be misrepresented as being the original source.

+3. This Copyright notice may not be removed or altered from

+   any source or altered source distribution.

+The Contributing Authors and Group 42, Inc. specifically permit, without

+fee, and encourage the use of this source code as a component to

+supporting the PNG file format in commercial products.  If you use this

+source code in a product, acknowledgment is not required but would be

+appreciated.

+A "png_get_copyright" function is available, for convenient use in "about"

+boxes and the like:

+   printf("%s",png_get_copyright(NULL));

+Also, the PNG logo (in PNG format, of course) is supplied in the

+files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).

+Libpng is OSI Certified Open Source Software.  OSI Certified Open Source is a

+certification mark of the Open Source Initiative.

+Glenn Randers-Pehrson

+glennrp at users.sourceforge.net

+December 3, 2004

+.\" end of man page

--- /dev/null

+++ b/src/gfx/libpng/libpng.txt

@@ -1,0 +1,2959 @@

+libpng.txt - A description on how to use and modify libpng

+ libpng version 1.2.8 - December 3, 2004

+ Updated and distributed by Glenn Randers-Pehrson

+ <glennrp at users.sourceforge.net>

+ Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ For conditions of distribution and use, see copyright

+ notice in png.h.

+ based on:

+ libpng 1.0 beta 6  version 0.96 May 28, 1997

+ Updated and distributed by Andreas Dilger

+ Copyright (c) 1996, 1997 Andreas Dilger

+ libpng 1.0 beta 2 - version 0.88  January 26, 1996

+ For conditions of distribution and use, see copyright

+ notice in png.h. Copyright (c) 1995, 1996 Guy Eric

+ Schalnat, Group 42, Inc.

+ Updated/rewritten per request in the libpng FAQ

+ Copyright (c) 1995, 1996 Frank J. T. Wojcik

+ December 18, 1995 & January 20, 1996

+I. Introduction

+This file describes how to use and modify the PNG reference library

+(known as libpng) for your own use.  There are five sections to this

+file: introduction, structures, reading, writing, and modification and

+configuration notes for various special platforms.  In addition to this

+file, example.c is a good starting point for using the library, as

+it is heavily commented and should include everything most people

+will need.  We assume that libpng is already installed; see the

+INSTALL file for instructions on how to install libpng.

+Libpng was written as a companion to the PNG specification, as a way

+of reducing the amount of time and effort it takes to support the PNG

+file format in application programs.

+The PNG specification (second edition), November 2003, is available as

+a W3C Recommendation and as an ISO Standard (ISO/IEC 15948:2003 (E)) at

+<http://www.w3.org/TR/2003/REC-PNG-20031110/

+The W3C and ISO documents have identical technical content.

+The PNG-1.2 specification is available at

+<http://www.libpng.org/pub/png/documents/>

+The PNG-1.0 specification is available

+as RFC 2083 <http://www.libpng.org/pub/png/documents/> and as a

+W3C Recommendation <http://www.w3.org/TR/REC.png.html>. Some

+additional chunks are described in the special-purpose public chunks

+documents at <http://www.libpng.org/pub/png/documents/>.

+Other information

+about PNG, and the latest version of libpng, can be found at the PNG home

+page, <http://www.libpng.org/pub/png/>.

+Most users will not have to modify the library significantly; advanced

+users may want to modify it more.  All attempts were made to make it as

+complete as possible, while keeping the code easy to understand.

+Currently, this library only supports C.  Support for other languages

+is being considered.

+Libpng has been designed to handle multiple sessions at one time,

+to be easily modifiable, to be portable to the vast majority of

+machines (ANSI, K&R, 16-, 32-, and 64-bit) available, and to be easy

+to use.  The ultimate goal of libpng is to promote the acceptance of

+the PNG file format in whatever way possible.  While there is still

+work to be done (see the TODO file), libpng should cover the

+majority of the needs of its users.

+Libpng uses zlib for its compression and decompression of PNG files.

+Further information about zlib, and the latest version of zlib, can

+be found at the zlib home page, <http://www.info-zip.org/pub/infozip/zlib/>.

+The zlib compression utility is a general purpose utility that is

+useful for more than PNG files, and can be used without libpng.

+See the documentation delivered with zlib for more details.

+You can usually find the source files for the zlib utility wherever you

+find the libpng source files.

+Libpng is thread safe, provided the threads are using different

+instances of the structures.  Each thread should have its own

+png_struct and png_info instances, and thus its own image.

+Libpng does not protect itself against two threads using the

+same instance of a structure.  Note: thread safety may be defeated

+by use of some of the MMX assembler code in pnggccrd.c, which is only

+compiled when the user defines PNG_THREAD_UNSAFE_OK.

+II. Structures

+There are two main structures that are important to libpng, png_struct

+and png_info.  The first, png_struct, is an internal structure that

+will not, for the most part, be used by a user except as the first

+variable passed to every libpng function call.

+The png_info structure is designed to provide information about the

+PNG file.  At one time, the fields of png_info were intended to be

+directly accessible to the user.  However, this tended to cause problems

+with applications using dynamically loaded libraries, and as a result

+a set of interface functions for png_info (the png_get_*() and png_set_*()

+functions) was developed.  The fields of png_info are still available for

+older applications, but it is suggested that applications use the new

+interfaces if at all possible.

+Applications that do make direct access to the members of png_struct (except

+for png_ptr->jmpbuf) must be recompiled whenever the library is updated,

+and applications that make direct access to the members of png_info must

+be recompiled if they were compiled or loaded with libpng version 1.0.6,

+in which the members were in a different order.  In version 1.0.7, the

+members of the png_info structure reverted to the old order, as they were

+in versions 0.97c through 1.0.5.  Starting with version 2.0.0, both

+structures are going to be hidden, and the contents of the structures will

+only be accessible through the png_get/png_set functions.

+The png.h header file is an invaluable reference for programming with libpng.

+And while I'm on the topic, make sure you include the libpng header file:

+#include <png.h>

+III. Reading

+We'll now walk you through the possible functions to call when reading

+in a PNG file sequentially, briefly explaining the syntax and purpose

+of each one.  See example.c and png.h for more detail.  While

+progressive reading is covered in the next section, you will still

+need some of the functions discussed in this section to read a PNG

+file.

+Setup

+You will want to do the I/O initialization(*) before you get into libpng,

+so if it doesn't work, you don't have much to undo.  Of course, you

+will also want to insure that you are, in fact, dealing with a PNG

+file.  Libpng provides a simple check to see if a file is a PNG file.

+To use it, pass in the first 1 to 8 bytes of the file to the function

+png_sig_cmp(), and it will return 0 if the bytes match the corresponding

+bytes of the PNG signature, or nonzero otherwise.  Of course, the more bytes

+you pass in, the greater the accuracy of the prediction.

+If you are intending to keep the file pointer open for use in libpng,

+you must ensure you don't read more than 8 bytes from the beginning

+of the file, and you also have to make a call to png_set_sig_bytes_read()

+with the number of bytes you read from the beginning.  Libpng will

+then only check the bytes (if any) that your program didn't read.

+(*): If you are not using the standard I/O functions, you will need

+to replace them with custom functions.  See the discussion under

+Customizing libpng.

+    FILE *fp = fopen(file_name, "rb");

+    if (!fp)

+    {

+        return (ERROR);

+    }

+    fread(header, 1, number, fp);

+    is_png = !png_sig_cmp(header, 0, number);

+    if (!is_png)

+    {

+        return (NOT_PNG);

+    }

+Next, png_struct and png_info need to be allocated and initialized.  In

+order to ensure that the size of these structures is correct even with a

+dynamically linked libpng, there are functions to initialize and

+allocate the structures.  We also pass the library version, optional

+pointers to error handling functions, and a pointer to a data struct for

+use by the error functions, if necessary (the pointer and functions can

+be NULL if the default error handlers are to be used).  See the section

+on Changes to Libpng below regarding the old initialization functions.

+The structure allocation functions quietly return NULL if they fail to

+create the structure, so your application should check for that.

+    png_structp png_ptr = png_create_read_struct

+       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,

+        user_error_fn, user_warning_fn);

+    if (!png_ptr)

+        return (ERROR);

+    png_infop info_ptr = png_create_info_struct(png_ptr);

+    if (!info_ptr)

+    {

+        png_destroy_read_struct(&png_ptr,

+           (png_infopp)NULL, (png_infopp)NULL);

+        return (ERROR);

+    }

+    png_infop end_info = png_create_info_struct(png_ptr);

+    if (!end_info)

+    {

+        png_destroy_read_struct(&png_ptr, &info_ptr,

+          (png_infopp)NULL);

+        return (ERROR);

+    }

+If you want to use your own memory allocation routines,

+define PNG_USER_MEM_SUPPORTED and use

+png_create_read_struct_2() instead of png_create_read_struct():

+    png_structp png_ptr = png_create_read_struct_2

+       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,

+        user_error_fn, user_warning_fn, (png_voidp)

+        user_mem_ptr, user_malloc_fn, user_free_fn);

+The error handling routines passed to png_create_read_struct()

+and the memory alloc/free routines passed to png_create_struct_2()

+are only necessary if you are not using the libpng supplied error

+handling and memory alloc/free functions.

+When libpng encounters an error, it expects to longjmp back

+to your routine.  Therefore, you will need to call setjmp and pass

+your png_jmpbuf(png_ptr).  If you read the file from different

+routines, you will need to update the jmpbuf field every time you enter

+a new routine that will call a png_*() function.

+See your documentation of setjmp/longjmp for your compiler for more

+information on setjmp/longjmp.  See the discussion on libpng error

+handling in the Customizing Libpng section below for more information

+on the libpng error handling.  If an error occurs, and libpng longjmp's

+back to your setjmp, you will want to call png_destroy_read_struct() to

+free any memory.

+    if (setjmp(png_jmpbuf(png_ptr)))

+    {

+        png_destroy_read_struct(&png_ptr, &info_ptr,

+           &end_info);

+        fclose(fp);

+        return (ERROR);

+    }

+If you would rather avoid the complexity of setjmp/longjmp issues,

+you can compile libpng with PNG_SETJMP_NOT_SUPPORTED, in which case

+errors will result in a call to PNG_ABORT() which defaults to abort().

+Now you need to set up the input code.  The default for libpng is to

+use the C function fread().  If you use this, you will need to pass a

+valid FILE * in the function png_init_io().  Be sure that the file is

+opened in binary mode.  If you wish to handle reading data in another

+way, you need not call the png_init_io() function, but you must then

+implement the libpng I/O methods discussed in the Customizing Libpng

+section below.

+    png_init_io(png_ptr, fp);

+If you had previously opened the file and read any of the signature from

+the beginning in order to see if this was a PNG file, you need to let

+libpng know that there are some bytes missing from the start of the file.

+    png_set_sig_bytes(png_ptr, number);

+Setting up callback code

+You can set up a callback function to handle any unknown chunks in the

+input stream. You must supply the function

+    read_chunk_callback(png_ptr ptr,

+         png_unknown_chunkp chunk);

+    {

+       /* The unknown chunk structure contains your

+          chunk data: */

+           png_byte name[5];

+           png_byte *data;

+           png_size_t size;

+       /* Note that libpng has already taken care of

+          the CRC handling */

+       /* put your code here.  Return one of the

+          following: */

+       return (-n); /* chunk had an error */

+       return (0); /* did not recognize */

+       return (n); /* success */

+    }

+(You can give your function another name that you like instead of

+"read_chunk_callback")

+To inform libpng about your function, use

+    png_set_read_user_chunk_fn(png_ptr, user_chunk_ptr,

+        read_chunk_callback);

+This names not only the callback function, but also a user pointer that

+you can retrieve with

+    png_get_user_chunk_ptr(png_ptr);

+At this point, you can set up a callback function that will be

+called after each row has been read, which you can use to control

+a progress meter or the like.  It's demonstrated in pngtest.c.

+You must supply a function

+    void read_row_callback(png_ptr ptr, png_uint_32 row,

+       int pass);

+    {

+      /* put your code here */

+    }

+(You can give it another name that you like instead of "read_row_callback")

+To inform libpng about your function, use

+    png_set_read_status_fn(png_ptr, read_row_callback);

+Width and height limits

+The PNG specification allows the width and height of an image to be as

+large as 2^31-1 (0x7fffffff), or about 2.147 billion rows and columns.

+Since very few applications really need to process such large images,

+we have imposed an arbitrary 1-million limit on rows and columns.

+Larger images will be rejected immediately with a png_error() call. If

+you wish to override this limit, you can use

+   png_set_user_limits(png_ptr, width_max, height_max);

+to set your own limits, or use width_max = height_max = 0x7fffffffL

+to allow all valid dimensions (libpng may reject some very large images

+anyway because of potential buffer overflow conditions).

+You should put this statement after you create the PNG structure and

+before calling png_read_info(), png_read_png(), or png_process_data().

+If you need to retrieve the limits that are being applied, use

+   width_max = png_get_user_width_max(png_ptr);

+   height_max = png_get_user_height_max(png_ptr);

+Unknown-chunk handling

+Now you get to set the way the library processes unknown chunks in the

+input PNG stream. Both known and unknown chunks will be read.  Normal

+behavior is that known chunks will be parsed into information in

+various info_ptr members; unknown chunks will be discarded. To change

+this, you can call:

+    png_set_keep_unknown_chunks(png_ptr, keep,

+        chunk_list, num_chunks);

+    keep       - 0: do not handle as unknown

+                 1: do not keep

+                 2: keep only if safe-to-copy

+                 3: keep even if unsafe-to-copy

+               You can use these definitions:

+                 PNG_HANDLE_CHUNK_AS_DEFAULT   0

+                 PNG_HANDLE_CHUNK_NEVER        1

+                 PNG_HANDLE_CHUNK_IF_SAFE      2

+                 PNG_HANDLE_CHUNK_ALWAYS       3

+    chunk_list - list of chunks affected (a byte string,

+                 five bytes per chunk, NULL or '\0' if

+                 num_chunks is 0)

+    num_chunks - number of chunks affected; if 0, all

+                 unknown chunks are affected.  If nonzero,

+                 only the chunks in the list are affected

+Unknown chunks declared in this way will be saved as raw data onto a

+list of png_unknown_chunk structures.  If a chunk that is normally

+known to libpng is named in the list, it will be handled as unknown,

+according to the "keep" directive.  If a chunk is named in successive

+instances of png_set_keep_unknown_chunks(), the final instance will

+take precedence.  The IHDR and IEND chunks should not be named in

+chunk_list; if they are, libpng will process them normally anyway.

+The high-level read interface

+At this point there are two ways to proceed; through the high-level

+read interface, or through a sequence of low-level read operations.

+You can use the high-level interface if (a) you are willing to read

+the entire image into memory, and (b) the input transformations

+you want to do are limited to the following set:

+    PNG_TRANSFORM_IDENTITY      No transformation

+    PNG_TRANSFORM_STRIP_16      Strip 16-bit samples to

+                                8 bits

+    PNG_TRANSFORM_STRIP_ALPHA   Discard the alpha channel

+    PNG_TRANSFORM_PACKING       Expand 1, 2 and 4-bit

+                                samples to bytes

+    PNG_TRANSFORM_PACKSWAP      Change order of packed

+                                pixels to LSB first

+    PNG_TRANSFORM_EXPAND        Perform set_expand()

+    PNG_TRANSFORM_INVERT_MONO   Invert monochrome images

+    PNG_TRANSFORM_SHIFT         Normalize pixels to the

+                                sBIT depth

+    PNG_TRANSFORM_BGR           Flip RGB to BGR, RGBA

+                                to BGRA

+    PNG_TRANSFORM_SWAP_ALPHA    Flip RGBA to ARGB or GA

+                                to AG

+    PNG_TRANSFORM_INVERT_ALPHA  Change alpha from opacity

+                                to transparency

+    PNG_TRANSFORM_SWAP_ENDIAN   Byte-swap 16-bit samples

+(This excludes setting a background color, doing gamma transformation,

+dithering, and setting filler.)  If this is the case, simply do this:

+    png_read_png(png_ptr, info_ptr, png_transforms, NULL)

+where png_transforms is an integer containing the logical OR of

+some set of transformation flags.  This call is equivalent to png_read_info(),

+followed the set of transformations indicated by the transform mask,

+then png_read_image(), and finally png_read_end().

+(The final parameter of this call is not yet used.  Someday it might point

+to transformation parameters required by some future input transform.)

+You must use png_transforms and not call any png_set_transform() functions

+when you use png_read_png().

+After you have called png_read_png(), you can retrieve the image data

+with

+   row_pointers = png_get_rows(png_ptr, info_ptr);

+where row_pointers is an array of pointers to the pixel data for each row:

+   png_bytep row_pointers[height];

+If you know your image size and pixel size ahead of time, you can allocate

+row_pointers prior to calling png_read_png() with

+   if (height > PNG_UINT_32_MAX/png_sizeof(png_byte))

+      png_error (png_ptr,

+         "Image is too tall to process in memory");

+   if (width > PNG_UINT_32_MAX/pixel_size)

+      png_error (png_ptr,

+         "Image is too wide to process in memory");

+   row_pointers = png_malloc(png_ptr,

+      height*png_sizeof(png_bytep));

+   for (int i=0; i<height, i++)

+      row_pointers[i]=png_malloc(png_ptr,

+         width*pixel_size);

+   png_set_rows(png_ptr, info_ptr, &row_pointers);

+Alternatively you could allocate your image in one big block and define

+row_pointers[i] to point into the proper places in your block.

+If you use png_set_rows(), the application is responsible for freeing

+row_pointers (and row_pointers[i], if they were separately allocated).

+If you don't allocate row_pointers ahead of time, png_read_png() will

+do it, and it'll be free'ed when you call png_destroy_*().

+The low-level read interface

+If you are going the low-level route, you are now ready to read all

+the file information up to the actual image data.  You do this with a

+call to png_read_info().

+    png_read_info(png_ptr, info_ptr);

+This will process all chunks up to but not including the image data.

+Querying the info structure

+Functions are used to get the information from the info_ptr once it

+has been read.  Note that these fields may not be completely filled

+in until png_read_end() has read the chunk data following the image.

+    png_get_IHDR(png_ptr, info_ptr, &width, &height,

+       &bit_depth, &color_type, &interlace_type,

+       &compression_type, &filter_method);

+    width          - holds the width of the image

+                     in pixels (up to 2^31).

+    height         - holds the height of the image

+                     in pixels (up to 2^31).

+    bit_depth      - holds the bit depth of one of the

+                     image channels.  (valid values are

+                     1, 2, 4, 8, 16 and depend also on

+                     the color_type.  See also

+                     significant bits (sBIT) below).

+    color_type     - describes which color/alpha channels

+                         are present.

+                     PNG_COLOR_TYPE_GRAY

+                        (bit depths 1, 2, 4, 8, 16)

+                     PNG_COLOR_TYPE_GRAY_ALPHA

+                        (bit depths 8, 16)

+                     PNG_COLOR_TYPE_PALETTE

+                        (bit depths 1, 2, 4, 8)

+                     PNG_COLOR_TYPE_RGB

+                        (bit_depths 8, 16)

+                     PNG_COLOR_TYPE_RGB_ALPHA

+                        (bit_depths 8, 16)

+                     PNG_COLOR_MASK_PALETTE

+                     PNG_COLOR_MASK_COLOR

+                     PNG_COLOR_MASK_ALPHA

+    filter_method  - (must be PNG_FILTER_TYPE_BASE

+                     for PNG 1.0, and can also be

+                     PNG_INTRAPIXEL_DIFFERENCING if

+                     the PNG datastream is embedded in

+                     a MNG-1.0 datastream)

+    compression_type - (must be PNG_COMPRESSION_TYPE_BASE

+                     for PNG 1.0)

+    interlace_type - (PNG_INTERLACE_NONE or

+                     PNG_INTERLACE_ADAM7)

+    Any or all of interlace_type, compression_type, of

+    filter_method can be NULL if you are

+    not interested in their values.

+    channels = png_get_channels(png_ptr, info_ptr);

+    channels       - number of channels of info for the

+                     color type (valid values are 1 (GRAY,

+                     PALETTE), 2 (GRAY_ALPHA), 3 (RGB),

+                     4 (RGB_ALPHA or RGB + filler byte))

+    rowbytes = png_get_rowbytes(png_ptr, info_ptr);

+    rowbytes       - number of bytes needed to hold a row

+    signature = png_get_signature(png_ptr, info_ptr);

+    signature      - holds the signature read from the

+                     file (if any).  The data is kept in

+                     the same offset it would be if the

+                     whole signature were read (i.e. if an

+                     application had already read in 4

+                     bytes of signature before starting

+                     libpng, the remaining 4 bytes would

+                     be in signature[4] through signature[7]

+                     (see png_set_sig_bytes())).

+    width            = png_get_image_width(png_ptr,

+                         info_ptr);

+    height           = png_get_image_height(png_ptr,

+                         info_ptr);

+    bit_depth        = png_get_bit_depth(png_ptr,

+                         info_ptr);

+    color_type       = png_get_color_type(png_ptr,

+                         info_ptr);

+    filter_method    = png_get_filter_type(png_ptr,

+                         info_ptr);

+    compression_type = png_get_compression_type(png_ptr,

+                         info_ptr);

+    interlace_type   = png_get_interlace_type(png_ptr,

+                         info_ptr);

+These are also important, but their validity depends on whether the chunk

+has been read.  The png_get_valid(png_ptr, info_ptr, PNG_INFO_<chunk>) and

+png_get_<chunk>(png_ptr, info_ptr, ...) functions return non-zero if the

+data has been read, or zero if it is missing.  The parameters to the

+png_get_<chunk> are set directly if they are simple data types, or a pointer

+into the info_ptr is returned for any complex types.

+    png_get_PLTE(png_ptr, info_ptr, &palette,

+                     &num_palette);

+    palette        - the palette for the file

+                     (array of png_color)

+    num_palette    - number of entries in the palette

+    png_get_gAMA(png_ptr, info_ptr, &gamma);

+    gamma          - the gamma the file is written

+                     at (PNG_INFO_gAMA)

+    png_get_sRGB(png_ptr, info_ptr, &srgb_intent);

+    srgb_intent    - the rendering intent (PNG_INFO_sRGB)

+                     The presence of the sRGB chunk

+                     means that the pixel data is in the

+                     sRGB color space.  This chunk also

+                     implies specific values of gAMA and

+                     cHRM.

+    png_get_iCCP(png_ptr, info_ptr, &name,

+       &compression_type, &profile, &proflen);

+    name            - The profile name.

+    compression     - The compression type; always

+                      PNG_COMPRESSION_TYPE_BASE for PNG 1.0.

+                      You may give NULL to this argument to

+                      ignore it.

+    profile         - International Color Consortium color

+                      profile data. May contain NULs.

+    proflen         - length of profile data in bytes.

+    png_get_sBIT(png_ptr, info_ptr, &sig_bit);

+    sig_bit        - the number of significant bits for

+                     (PNG_INFO_sBIT) each of the gray,

+                     red, green, and blue channels,

+                     whichever are appropriate for the

+                     given color type (png_color_16)

+    png_get_tRNS(png_ptr, info_ptr, &trans, &num_trans,

+                     &trans_values);

+    trans          - array of transparent entries for

+                     palette (PNG_INFO_tRNS)

+    trans_values   - graylevel or color sample values of

+                     the single transparent color for

+                     non-paletted images (PNG_INFO_tRNS)

+    num_trans      - number of transparent entries

+                     (PNG_INFO_tRNS)

+    png_get_hIST(png_ptr, info_ptr, &hist);

+                     (PNG_INFO_hIST)

+    hist           - histogram of palette (array of

+                     png_uint_16)

+    png_get_tIME(png_ptr, info_ptr, &mod_time);

+    mod_time       - time image was last modified

+                    (PNG_VALID_tIME)

+    png_get_bKGD(png_ptr, info_ptr, &background);

+    background     - background color (PNG_VALID_bKGD)

+                     valid 16-bit red, green and blue

+                     values, regardless of color_type

+    num_comments   = png_get_text(png_ptr, info_ptr,

+                     &text_ptr, &num_text);

+    num_comments   - number of comments

+    text_ptr       - array of png_text holding image

+                     comments

+    text_ptr[i].compression - type of compression used

+                 on "text" PNG_TEXT_COMPRESSION_NONE

+                           PNG_TEXT_COMPRESSION_zTXt

+                           PNG_ITXT_COMPRESSION_NONE

+                           PNG_ITXT_COMPRESSION_zTXt

+    text_ptr[i].key   - keyword for comment.  Must contain

+                         1-79 characters.

+    text_ptr[i].text  - text comments for current

+                         keyword.  Can be empty.

+    text_ptr[i].text_length - length of text string,

+                 after decompression, 0 for iTXt

+    text_ptr[i].itxt_length - length of itxt string,

+                 after decompression, 0 for tEXt/zTXt

+    text_ptr[i].lang  - language of comment (empty

+                         string for unknown).

+    text_ptr[i].lang_key  - keyword in UTF-8

+                         (empty string for unknown).

+    num_text       - number of comments (same as

+                     num_comments; you can put NULL here

+                     to avoid the duplication)

+    Note while png_set_text() will accept text, language,

+    and translated keywords that can be NULL pointers, the

+    structure returned by png_get_text will always contain

+    regular zero-terminated C strings.  They might be

+    empty strings but they will never be NULL pointers.

+    num_spalettes = png_get_sPLT(png_ptr, info_ptr,

+       &palette_ptr);

+    palette_ptr    - array of palette structures holding

+                     contents of one or more sPLT chunks

+                     read.

+    num_spalettes  - number of sPLT chunks read.

+    png_get_oFFs(png_ptr, info_ptr, &offset_x, &offset_y,

+       &unit_type);

+    offset_x       - positive offset from the left edge

+                     of the screen

+    offset_y       - positive offset from the top edge

+                     of the screen

+    unit_type      - PNG_OFFSET_PIXEL, PNG_OFFSET_MICROMETER

+    png_get_pHYs(png_ptr, info_ptr, &res_x, &res_y,

+       &unit_type);

+    res_x          - pixels/unit physical resolution in

+                     x direction

+    res_y          - pixels/unit physical resolution in

+                     x direction

+    unit_type      - PNG_RESOLUTION_UNKNOWN,

+                     PNG_RESOLUTION_METER

+    png_get_sCAL(png_ptr, info_ptr, &unit, &width,

+       &height)

+    unit        - physical scale units (an integer)

+    width       - width of a pixel in physical scale units

+    height      - height of a pixel in physical scale units

+                 (width and height are doubles)

+    png_get_sCAL_s(png_ptr, info_ptr, &unit, &width,

+       &height)

+    unit        - physical scale units (an integer)

+    width       - width of a pixel in physical scale units

+    height      - height of a pixel in physical scale units

+                 (width and height are strings like "2.54")

+    num_unknown_chunks = png_get_unknown_chunks(png_ptr,

+       info_ptr, &unknowns)

+    unknowns          - array of png_unknown_chunk

+                        structures holding unknown chunks

+    unknowns[i].name  - name of unknown chunk

+    unknowns[i].data  - data of unknown chunk

+    unknowns[i].size  - size of unknown chunk's data

+    unknowns[i].location - position of chunk in file

+    The value of "i" corresponds to the order in which the

+    chunks were read from the PNG file or inserted with the

+    png_set_unknown_chunks() function.

+The data from the pHYs chunk can be retrieved in several convenient

+forms:

+    res_x = png_get_x_pixels_per_meter(png_ptr,

+       info_ptr)

+    res_y = png_get_y_pixels_per_meter(png_ptr,

+       info_ptr)

+    res_x_and_y = png_get_pixels_per_meter(png_ptr,

+       info_ptr)

+    res_x = png_get_x_pixels_per_inch(png_ptr,

+       info_ptr)

+    res_y = png_get_y_pixels_per_inch(png_ptr,

+       info_ptr)

+    res_x_and_y = png_get_pixels_per_inch(png_ptr,

+       info_ptr)

+    aspect_ratio = png_get_pixel_aspect_ratio(png_ptr,

+       info_ptr)

+   (Each of these returns 0 [signifying "unknown"] if

+       the data is not present or if res_x is 0;

+       res_x_and_y is 0 if res_x != res_y)

+The data from the oFFs chunk can be retrieved in several convenient

+forms:

+    x_offset = png_get_x_offset_microns(png_ptr, info_ptr);

+    y_offset = png_get_y_offset_microns(png_ptr, info_ptr);

+    x_offset = png_get_x_offset_inches(png_ptr, info_ptr);

+    y_offset = png_get_y_offset_inches(png_ptr, info_ptr);

+   (Each of these returns 0 [signifying "unknown" if both

+       x and y are 0] if the data is not present or if the

+       chunk is present but the unit is the pixel)

+For more information, see the png_info definition in png.h and the

+PNG specification for chunk contents.  Be careful with trusting

+rowbytes, as some of the transformations could increase the space

+needed to hold a row (expand, filler, gray_to_rgb, etc.).

+See png_read_update_info(), below.

+A quick word about text_ptr and num_text.  PNG stores comments in

+keyword/text pairs, one pair per chunk, with no limit on the number

+of text chunks, and a 2^31 byte limit on their size.  While there are

+suggested keywords, there is no requirement to restrict the use to these

+strings.  It is strongly suggested that keywords and text be sensible

+to humans (that's the point), so don't use abbreviations.  Non-printing

+symbols are not allowed.  See the PNG specification for more details.

+There is also no requirement to have text after the keyword.

+Keywords should be limited to 79 Latin-1 characters without leading or

+trailing spaces, but non-consecutive spaces are allowed within the

+keyword.  It is possible to have the same keyword any number of times.

+The text_ptr is an array of png_text structures, each holding a

+pointer to a language string, a pointer to a keyword and a pointer to

+a text string.  The text string, language code, and translated

+keyword may be empty or NULL pointers.  The keyword/text

+pairs are put into the array in the order that they are received.

+However, some or all of the text chunks may be after the image, so, to

+make sure you have read all the text chunks, don't mess with these

+until after you read the stuff after the image.  This will be

+mentioned again below in the discussion that goes with png_read_end().

+Input transformations

+After you've read the header information, you can set up the library

+to handle any special transformations of the image data.  The various

+ways to transform the data will be described in the order that they

+should occur.  This is important, as some of these change the color

+type and/or bit depth of the data, and some others only work on

+certain color types and bit depths.  Even though each transformation

+checks to see if it has data that it can do something with, you should

+make sure to only enable a transformation if it will be valid for the

+data.  For example, don't swap red and blue on grayscale data.

+The colors used for the background and transparency values should be

+supplied in the same format/depth as the current image data.  They

+are stored in the same format/depth as the image data in a bKGD or tRNS

+chunk, so this is what libpng expects for this data.  The colors are

+transformed to keep in sync with the image data when an application

+calls the png_read_update_info() routine (see below).

+Data will be decoded into the supplied row buffers packed into bytes

+unless the library has been told to transform it into another format.

+For example, 4 bit/pixel paletted or grayscale data will be returned

+2 pixels/byte with the leftmost pixel in the high-order bits of the

+byte, unless png_set_packing() is called.  8-bit RGB data will be stored

+in RGB RGB RGB format unless png_set_filler() or png_set_add_alpha()

+is called to insert filler bytes, either before or after each RGB triplet.

+16-bit RGB data will be returned RRGGBB RRGGBB, with the most significant

+byte of the color value first, unless png_set_strip_16() is called to

+transform it to regular RGB RGB triplets, or png_set_filler() or

+png_set_add alpha() is called to insert filler bytes, either before or

+after each RRGGBB triplet.  Similarly, 8-bit or 16-bit grayscale data can

+be modified with

+png_set_filler(), png_set_add_alpha(), or png_set_strip_16().

+The following code transforms grayscale images of less than 8 to 8 bits,

+changes paletted images to RGB, and adds a full alpha channel if there is

+transparency information in a tRNS chunk.  This is most useful on

+grayscale images with bit depths of 2 or 4 or if there is a multiple-image

+viewing application that wishes to treat all images in the same way.

+    if (color_type == PNG_COLOR_TYPE_PALETTE)

+        png_set_palette_to_rgb(png_ptr);

+    if (color_type == PNG_COLOR_TYPE_GRAY &&

+        bit_depth < 8) png_set_gray_1_2_4_to_8(png_ptr);

+    if (png_get_valid(png_ptr, info_ptr,

+        PNG_INFO_tRNS)) png_set_tRNS_to_alpha(png_ptr);

+These three functions are actually aliases for png_set_expand(), added

+in libpng version 1.0.4, with the function names expanded to improve code

+readability.  In some future version they may actually do different

+things.

+PNG can have files with 16 bits per channel.  If you only can handle

+8 bits per channel, this will strip the pixels down to 8 bit.

+    if (bit_depth == 16)

+        png_set_strip_16(png_ptr);

+If, for some reason, you don't need the alpha channel on an image,

+and you want to remove it rather than combining it with the background

+(but the image author certainly had in mind that you *would* combine

+it with the background, so that's what you should probably do):

+    if (color_type & PNG_COLOR_MASK_ALPHA)

+        png_set_strip_alpha(png_ptr);

+In PNG files, the alpha channel in an image

+is the level of opacity.  If you need the alpha channel in an image to

+be the level of transparency instead of opacity, you can invert the

+alpha channel (or the tRNS chunk data) after it's read, so that 0 is

+fully opaque and 255 (in 8-bit or paletted images) or 65535 (in 16-bit

+images) is fully transparent, with

+    png_set_invert_alpha(png_ptr);

+PNG files pack pixels of bit depths 1, 2, and 4 into bytes as small as

+they can, resulting in, for example, 8 pixels per byte for 1 bit

+files.  This code expands to 1 pixel per byte without changing the

+values of the pixels:

+    if (bit_depth < 8)

+        png_set_packing(png_ptr);

+PNG files have possible bit depths of 1, 2, 4, 8, and 16.  All pixels

+stored in a PNG image have been "scaled" or "shifted" up to the next

+higher possible bit depth (e.g. from 5 bits/sample in the range [0,31] to

+8 bits/sample in the range [0, 255]).  However, it is also possible to

+convert the PNG pixel data back to the original bit depth of the image.

+This call reduces the pixels back down to the original bit depth:

+    png_color_8p sig_bit;

+    if (png_get_sBIT(png_ptr, info_ptr, &sig_bit))

+        png_set_shift(png_ptr, sig_bit);

+PNG files store 3-color pixels in red, green, blue order.  This code

+changes the storage of the pixels to blue, green, red:

+    if (color_type == PNG_COLOR_TYPE_RGB ||

+        color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+        png_set_bgr(png_ptr);

+PNG files store RGB pixels packed into 3 or 6 bytes. This code expands them

+into 4 or 8 bytes for windowing systems that need them in this format:

+    if (color_type == PNG_COLOR_TYPE_RGB)

+        png_set_filler(png_ptr, filler, PNG_FILLER_BEFORE);

+where "filler" is the 8 or 16-bit number to fill with, and the location is

+either PNG_FILLER_BEFORE or PNG_FILLER_AFTER, depending upon whether

+you want the filler before the RGB or after.  This transformation

+does not affect images that already have full alpha channels.  To add an

+opaque alpha channel, use filler=0xff or 0xffff and PNG_FILLER_AFTER which

+will generate RGBA pixels.

+Note that png_set_filler() does not change the color type.  If you want

+to do that, you can add a true alpha channel with

+    if (color_type == PNG_COLOR_TYPE_RGB ||

+           color_type == PNG_COLOR_TYPE_GRAY)

+    png_set_add_alpha(png_ptr, filler, PNG_FILLER_AFTER);

+where "filler" contains the alpha value to assign to each pixel.

+This function was added in libpng-1.2.7.

+If you are reading an image with an alpha channel, and you need the

+data as ARGB instead of the normal PNG format RGBA:

+    if (color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+        png_set_swap_alpha(png_ptr);

+For some uses, you may want a grayscale image to be represented as

+RGB.  This code will do that conversion:

+    if (color_type == PNG_COLOR_TYPE_GRAY ||

+        color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

+          png_set_gray_to_rgb(png_ptr);

+Conversely, you can convert an RGB or RGBA image to grayscale or grayscale

+with alpha.

+    if (color_type == PNG_COLOR_TYPE_RGB ||

+        color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+          png_set_rgb_to_gray_fixed(png_ptr, error_action,

+             int red_weight, int green_weight);

+    error_action = 1: silently do the conversion

+    error_action = 2: issue a warning if the original

+                      image has any pixel where

+                      red != green or red != blue

+    error_action = 3: issue an error and abort the

+                      conversion if the original

+                      image has any pixel where

+                      red != green or red != blue

+    red_weight:       weight of red component times 100000

+    green_weight:     weight of green component times 100000

+                      If either weight is negative, default

+                      weights (21268, 71514) are used.

+If you have set error_action = 1 or 2, you can

+later check whether the image really was gray, after processing

+the image rows, with the png_get_rgb_to_gray_status(png_ptr) function.

+It will return a png_byte that is zero if the image was gray or

+1 if there were any non-gray pixels.  bKGD and sBIT data

+will be silently converted to grayscale, using the green channel

+data, regardless of the error_action setting.

+With red_weight+green_weight<=100000,

+the normalized graylevel is computed:

+    int rw = red_weight * 65536;

+    int gw = green_weight * 65536;

+    int bw = 65536 - (rw + gw);

+    gray = (rw*red + gw*green + bw*blue)/65536;

+The default values approximate those recommended in the Charles

+Poynton's Color FAQ, <http://www.inforamp.net/~poynton/>

+Copyright (c) 1998-01-04 Charles Poynton <poynton at inforamp.net>

+    Y = 0.212671 * R + 0.715160 * G + 0.072169 * B

+Libpng approximates this with

+    Y = 0.21268 * R    + 0.7151 * G    + 0.07217 * B

+which can be expressed with integers as

+    Y = (6969 * R + 23434 * G + 2365 * B)/32768

+The calculation is done in a linear colorspace, if the image gamma

+is known.

+If you have a grayscale and you are using png_set_expand_depth(),

+png_set_expand(), or png_set_gray_to_rgb to change to truecolor or to

+a higher bit-depth, you must either supply the background color as a gray

+value at the original file bit-depth (need_expand = 1) or else supply the

+background color as an RGB triplet at the final, expanded bit depth

+(need_expand = 0).  Similarly, if you are reading a paletted image, you

+must either supply the background color as a palette index (need_expand = 1)

+or as an RGB triplet that may or may not be in the palette (need_expand = 0).

+    png_color_16 my_background;

+    png_color_16p image_background;

+    if (png_get_bKGD(png_ptr, info_ptr, &image_background))

+        png_set_background(png_ptr, image_background,

+          PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);

+    else

+        png_set_background(png_ptr, &my_background,

+          PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);

+The png_set_background() function tells libpng to composite images

+with alpha or simple transparency against the supplied background

+color.  If the PNG file contains a bKGD chunk (PNG_INFO_bKGD valid),

+you may use this color, or supply another color more suitable for

+the current display (e.g., the background color from a web page).  You

+need to tell libpng whether the color is in the gamma space of the

+display (PNG_BACKGROUND_GAMMA_SCREEN for colors you supply), the file

+(PNG_BACKGROUND_GAMMA_FILE for colors from the bKGD chunk), or one

+that is neither of these gammas (PNG_BACKGROUND_GAMMA_UNIQUE - I don't

+know why anyone would use this, but it's here).

+To properly display PNG images on any kind of system, the application needs

+to know what the display gamma is.  Ideally, the user will know this, and

+the application will allow them to set it.  One method of allowing the user

+to set the display gamma separately for each system is to check for a

+SCREEN_GAMMA or DISPLAY_GAMMA environment variable, which will hopefully be

+correctly set.

+Note that display_gamma is the overall gamma correction required to produce

+pleasing results, which depends on the lighting conditions in the surrounding

+environment.  In a dim or brightly lit room, no compensation other than

+the physical gamma exponent of the monitor is needed, while in a dark room

+a slightly smaller exponent is better.

+   double gamma, screen_gamma;

+   if (/* We have a user-defined screen

+       gamma value */)

+   {

+      screen_gamma = user_defined_screen_gamma;

+   }

+   /* One way that applications can share the same

+      screen gamma value */

+   else if ((gamma_str = getenv("SCREEN_GAMMA"))

+      != NULL)

+   {

+      screen_gamma = (double)atof(gamma_str);

+   }

+   /* If we don't have another value */

+   else

+   {

+      screen_gamma = 2.2; /* A good guess for a

+           PC monitor in a bright office or a dim room */

+      screen_gamma = 2.0; /* A good guess for a

+           PC monitor in a dark room */

+      screen_gamma = 1.7 or 1.0;  /* A good

+           guess for Mac systems */

+   }

+The png_set_gamma() function handles gamma transformations of the data.

+Pass both the file gamma and the current screen_gamma.  If the file does

+not have a gamma value, you can pass one anyway if you have an idea what

+it is (usually 0.45455 is a good guess for GIF images on PCs).  Note

+that file gammas are inverted from screen gammas.  See the discussions

+on gamma in the PNG specification for an excellent description of what

+gamma is, and why all applications should support it.  It is strongly

+recommended that PNG viewers support gamma correction.

+   if (png_get_gAMA(png_ptr, info_ptr, &gamma))

+      png_set_gamma(png_ptr, screen_gamma, gamma);

+   else

+      png_set_gamma(png_ptr, screen_gamma, 0.45455);

+If you need to reduce an RGB file to a paletted file, or if a paletted

+file has more entries then will fit on your screen, png_set_dither()

+will do that.  Note that this is a simple match dither that merely

+finds the closest color available.  This should work fairly well with

+optimized palettes, and fairly badly with linear color cubes.  If you

+pass a palette that is larger then maximum_colors, the file will

+reduce the number of colors in the palette so it will fit into

+maximum_colors.  If there is a histogram, it will use it to make

+more intelligent choices when reducing the palette.  If there is no

+histogram, it may not do as good a job.

+   if (color_type & PNG_COLOR_MASK_COLOR)

+   {

+      if (png_get_valid(png_ptr, info_ptr,

+         PNG_INFO_PLTE))

+      {

+         png_uint_16p histogram = NULL;

+         png_get_hIST(png_ptr, info_ptr,

+            &histogram);

+         png_set_dither(png_ptr, palette, num_palette,

+            max_screen_colors, histogram, 1);

+      }

+      else

+      {

+         png_color std_color_cube[MAX_SCREEN_COLORS] =

+            { ... colors ... };

+         png_set_dither(png_ptr, std_color_cube,

+            MAX_SCREEN_COLORS, MAX_SCREEN_COLORS,

+            NULL,0);

+      }

+   }

+PNG files describe monochrome as black being zero and white being one.

+The following code will reverse this (make black be one and white be

+zero):

+   if (bit_depth == 1 && color_type == PNG_COLOR_TYPE_GRAY)

+      png_set_invert_mono(png_ptr);

+This function can also be used to invert grayscale and gray-alpha images:

+   if (color_type == PNG_COLOR_TYPE_GRAY ||

+        color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

+      png_set_invert_mono(png_ptr);

+PNG files store 16 bit pixels in network byte order (big-endian,

+ie. most significant bits first).  This code changes the storage to the

+other way (little-endian, i.e. least significant bits first, the

+way PCs store them):

+    if (bit_depth == 16)

+        png_set_swap(png_ptr);

+If you are using packed-pixel images (1, 2, or 4 bits/pixel), and you

+need to change the order the pixels are packed into bytes, you can use:

+    if (bit_depth < 8)

+       png_set_packswap(png_ptr);

+Finally, you can write your own transformation function if none of

+the existing ones meets your needs.  This is done by setting a callback

+with

+    png_set_read_user_transform_fn(png_ptr,

+       read_transform_fn);

+You must supply the function

+    void read_transform_fn(png_ptr ptr, row_info_ptr

+       row_info, png_bytep data)

+See pngtest.c for a working example.  Your function will be called

+after all of the other transformations have been processed.

+You can also set up a pointer to a user structure for use by your

+callback function, and you can inform libpng that your transform

+function will change the number of channels or bit depth with the

+function

+    png_set_user_transform_info(png_ptr, user_ptr,

+       user_depth, user_channels);

+The user's application, not libpng, is responsible for allocating and

+freeing any memory required for the user structure.

+You can retrieve the pointer via the function

+png_get_user_transform_ptr().  For example:

+    voidp read_user_transform_ptr =

+       png_get_user_transform_ptr(png_ptr);

+The last thing to handle is interlacing; this is covered in detail below,

+but you must call the function here if you want libpng to handle expansion

+of the interlaced image.

+    number_of_passes = png_set_interlace_handling(png_ptr);

+After setting the transformations, libpng can update your png_info

+structure to reflect any transformations you've requested with this

+call.  This is most useful to update the info structure's rowbytes

+field so you can use it to allocate your image memory.  This function

+will also update your palette with the correct screen_gamma and

+background if these have been given with the calls above.

+    png_read_update_info(png_ptr, info_ptr);

+After you call png_read_update_info(), you can allocate any

+memory you need to hold the image.  The row data is simply

+raw byte data for all forms of images.  As the actual allocation

+varies among applications, no example will be given.  If you

+are allocating one large chunk, you will need to build an

+array of pointers to each row, as it will be needed for some

+of the functions below.

+Reading image data

+After you've allocated memory, you can read the image data.

+The simplest way to do this is in one function call.  If you are

+allocating enough memory to hold the whole image, you can just

+call png_read_image() and libpng will read in all the image data

+and put it in the memory area supplied.  You will need to pass in

+an array of pointers to each row.

+This function automatically handles interlacing, so you don't need

+to call png_set_interlace_handling() or call this function multiple

+times, or any of that other stuff necessary with png_read_rows().

+   png_read_image(png_ptr, row_pointers);

+where row_pointers is:

+   png_bytep row_pointers[height];

+You can point to void or char or whatever you use for pixels.

+If you don't want to read in the whole image at once, you can

+use png_read_rows() instead.  If there is no interlacing (check

+interlace_type == PNG_INTERLACE_NONE), this is simple:

+    png_read_rows(png_ptr, row_pointers, NULL,

+       number_of_rows);

+where row_pointers is the same as in the png_read_image() call.

+If you are doing this just one row at a time, you can do this with

+a single row_pointer instead of an array of row_pointers:

+    png_bytep row_pointer = row;

+    png_read_row(png_ptr, row_pointer, NULL);

+If the file is interlaced (interlace_type != 0 in the IHDR chunk), things

+get somewhat harder.  The only current (PNG Specification version 1.2)

+interlacing type for PNG is (interlace_type == PNG_INTERLACE_ADAM7)

+is a somewhat complicated 2D interlace scheme, known as Adam7, that

+breaks down an image into seven smaller images of varying size, based

+on an 8x8 grid.

+libpng can fill out those images or it can give them to you "as is".

+If you want them filled out, there are two ways to do that.  The one

+mentioned in the PNG specification is to expand each pixel to cover

+those pixels that have not been read yet (the "rectangle" method).

+This results in a blocky image for the first pass, which gradually

+smooths out as more pixels are read.  The other method is the "sparkle"

+method, where pixels are drawn only in their final locations, with the

+rest of the image remaining whatever colors they were initialized to

+before the start of the read.  The first method usually looks better,

+but tends to be slower, as there are more pixels to put in the rows.

+If you don't want libpng to handle the interlacing details, just call

+png_read_rows() seven times to read in all seven images.  Each of the

+images is a valid image by itself, or they can all be combined on an

+8x8 grid to form a single image (although if you intend to combine them

+you would be far better off using the libpng interlace handling).

+The first pass will return an image 1/8 as wide as the entire image

+(every 8th column starting in column 0) and 1/8 as high as the original

+(every 8th row starting in row 0), the second will be 1/8 as wide

+(starting in column 4) and 1/8 as high (also starting in row 0).  The

+third pass will be 1/4 as wide (every 4th pixel starting in column 0) and

+1/8 as high (every 8th row starting in row 4), and the fourth pass will

+be 1/4 as wide and 1/4 as high (every 4th column starting in column 2,

+and every 4th row starting in row 0).  The fifth pass will return an

+image 1/2 as wide, and 1/4 as high (starting at column 0 and row 2),

+while the sixth pass will be 1/2 as wide and 1/2 as high as the original

+(starting in column 1 and row 0).  The seventh and final pass will be as

+wide as the original, and 1/2 as high, containing all of the odd

+numbered scanlines.  Phew!

+If you want libpng to expand the images, call this before calling

+png_start_read_image() or png_read_update_info():

+    if (interlace_type == PNG_INTERLACE_ADAM7)

+        number_of_passes

+           = png_set_interlace_handling(png_ptr);

+This will return the number of passes needed.  Currently, this

+is seven, but may change if another interlace type is added.

+This function can be called even if the file is not interlaced,

+where it will return one pass.

+If you are not going to display the image after each pass, but are

+going to wait until the entire image is read in, use the sparkle

+effect.  This effect is faster and the end result of either method

+is exactly the same.  If you are planning on displaying the image

+after each pass, the "rectangle" effect is generally considered the

+better looking one.

+If you only want the "sparkle" effect, just call png_read_rows() as

+normal, with the third parameter NULL.  Make sure you make pass over

+the image number_of_passes times, and you don't change the data in the

+rows between calls.  You can change the locations of the data, just

+not the data.  Each pass only writes the pixels appropriate for that

+pass, and assumes the data from previous passes is still valid.

+    png_read_rows(png_ptr, row_pointers, NULL,

+       number_of_rows);

+If you only want the first effect (the rectangles), do the same as

+before except pass the row buffer in the third parameter, and leave

+the second parameter NULL.

+    png_read_rows(png_ptr, NULL, row_pointers,

+       number_of_rows);

+Finishing a sequential read

+After you are finished reading the image through either the high- or

+low-level interfaces, you can finish reading the file.  If you are

+interested in comments or time, which may be stored either before or

+after the image data, you should pass the separate png_info struct if

+you want to keep the comments from before and after the image

+separate.  If you are not interested, you can pass NULL.

+   png_read_end(png_ptr, end_info);

+When you are done, you can free all memory allocated by libpng like this:

+   png_destroy_read_struct(&png_ptr, &info_ptr,

+       &end_info);

+It is also possible to individually free the info_ptr members that

+point to libpng-allocated storage with the following function:

+    png_free_data(png_ptr, info_ptr, mask, seq)

+    mask - identifies data to be freed, a mask

+           containing the logical OR of one or

+           more of

+             PNG_FREE_PLTE, PNG_FREE_TRNS,

+             PNG_FREE_HIST, PNG_FREE_ICCP,

+             PNG_FREE_PCAL, PNG_FREE_ROWS,

+             PNG_FREE_SCAL, PNG_FREE_SPLT,

+             PNG_FREE_TEXT, PNG_FREE_UNKN,

+           or simply PNG_FREE_ALL

+    seq  - sequence number of item to be freed

+           (-1 for all items)

+This function may be safely called when the relevant storage has

+already been freed, or has not yet been allocated, or was allocated

+by the user and not by libpng,  and will in those

+cases do nothing.  The "seq" parameter is ignored if only one item

+of the selected data type, such as PLTE, is allowed.  If "seq" is not

+-1, and multiple items are allowed for the data type identified in

+the mask, such as text or sPLT, only the n'th item in the structure

+is freed, where n is "seq".

+The default behavior is only to free data that was allocated internally

+by libpng.  This can be changed, so that libpng will not free the data,

+or so that it will free data that was allocated by the user with png_malloc()

+or png_zalloc() and passed in via a png_set_*() function, with

+    png_data_freer(png_ptr, info_ptr, freer, mask)

+    mask   - which data elements are affected

+             same choices as in png_free_data()

+    freer  - one of

+               PNG_DESTROY_WILL_FREE_DATA

+               PNG_SET_WILL_FREE_DATA

+               PNG_USER_WILL_FREE_DATA

+This function only affects data that has already been allocated.

+You can call this function after reading the PNG data but before calling

+any png_set_*() functions, to control whether the user or the png_set_*()

+function is responsible for freeing any existing data that might be present,

+and again after the png_set_*() functions to control whether the user

+or png_destroy_*() is supposed to free the data.  When the user assumes

+responsibility for libpng-allocated data, the application must use

+png_free() to free it, and when the user transfers responsibility to libpng

+for data that the user has allocated, the user must have used png_malloc()

+or png_zalloc() to allocate it.

+If you allocated your row_pointers in a single block, as suggested above in

+the description of the high level read interface, you must not transfer

+responsibility for freeing it to the png_set_rows or png_read_destroy function,

+because they would also try to free the individual row_pointers[i].

+If you allocated text_ptr.text, text_ptr.lang, and text_ptr.translated_keyword

+separately, do not transfer responsibility for freeing text_ptr to libpng,

+because when libpng fills a png_text structure it combines these members with

+the key member, and png_free_data() will free only text_ptr.key.  Similarly,

+if you transfer responsibility for free'ing text_ptr from libpng to your

+application, your application must not separately free those members.

+The png_free_data() function will turn off the "valid" flag for anything

+it frees.  If you need to turn the flag off for a chunk that was freed by your

+application instead of by libpng, you can use

+    png_set_invalid(png_ptr, info_ptr, mask);

+    mask - identifies the chunks to be made invalid,

+           containing the logical OR of one or

+           more of

+             PNG_INFO_gAMA, PNG_INFO_sBIT,

+             PNG_INFO_cHRM, PNG_INFO_PLTE,

+             PNG_INFO_tRNS, PNG_INFO_bKGD,

+             PNG_INFO_hIST, PNG_INFO_pHYs,

+             PNG_INFO_oFFs, PNG_INFO_tIME,

+             PNG_INFO_pCAL, PNG_INFO_sRGB,

+             PNG_INFO_iCCP, PNG_INFO_sPLT,

+             PNG_INFO_sCAL, PNG_INFO_IDAT

+For a more compact example of reading a PNG image, see the file example.c.

+Reading PNG files progressively

+The progressive reader is slightly different then the non-progressive

+reader.  Instead of calling png_read_info(), png_read_rows(), and

+png_read_end(), you make one call to png_process_data(), which calls

+callbacks when it has the info, a row, or the end of the image.  You

+set up these callbacks with png_set_progressive_read_fn().  You don't

+have to worry about the input/output functions of libpng, as you are

+giving the library the data directly in png_process_data().  I will

+assume that you have read the section on reading PNG files above,

+so I will only highlight the differences (although I will show

+all of the code).

+png_structp png_ptr;

+png_infop info_ptr;

+ /*  An example code fragment of how you would

+     initialize the progressive reader in your

+     application. */

+ int

+ initialize_png_reader()

+ {

+    png_ptr = png_create_read_struct

+        (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,

+         user_error_fn, user_warning_fn);

+    if (!png_ptr)

+        return (ERROR);

+    info_ptr = png_create_info_struct(png_ptr);

+    if (!info_ptr)

+    {

+        png_destroy_read_struct(&png_ptr, (png_infopp)NULL,

+           (png_infopp)NULL);

+        return (ERROR);

+    }

+    if (setjmp(png_jmpbuf(png_ptr)))

+    {

+        png_destroy_read_struct(&png_ptr, &info_ptr,

+           (png_infopp)NULL);

+        return (ERROR);

+    }

+    /* This one's new.  You can provide functions

+       to be called when the header info is valid,

+       when each row is completed, and when the image

+       is finished.  If you aren't using all functions,

+       you can specify NULL parameters.  Even when all

+       three functions are NULL, you need to call

+       png_set_progressive_read_fn().  You can use

+       any struct as the user_ptr (cast to a void pointer

+       for the function call), and retrieve the pointer

+       from inside the callbacks using the function

+          png_get_progressive_ptr(png_ptr);

+       which will return a void pointer, which you have

+       to cast appropriately.

+     */

+    png_set_progressive_read_fn(png_ptr, (void *)user_ptr,

+        info_callback, row_callback, end_callback);

+    return 0;

+ }

+ /* A code fragment that you call as you receive blocks

+   of data */

+ int

+ process_data(png_bytep buffer, png_uint_32 length)

+ {

+    if (setjmp(png_jmpbuf(png_ptr)))

+    {

+        png_destroy_read_struct(&png_ptr, &info_ptr,

+           (png_infopp)NULL);

+        return (ERROR);

+    }

+    /* This one's new also.  Simply give it a chunk

+       of data from the file stream (in order, of

+       course).  On machines with segmented memory

+       models machines, don't give it any more than

+       64K.  The library seems to run fine with sizes

+       of 4K. Although you can give it much less if

+       necessary (I assume you can give it chunks of

+       1 byte, I haven't tried less then 256 bytes

+       yet).  When this function returns, you may

+       want to display any rows that were generated

+       in the row callback if you don't already do

+       so there.

+     */

+    png_process_data(png_ptr, info_ptr, buffer, length);

+    return 0;

+ }

+ /* This function is called (as set by

+    png_set_progressive_read_fn() above) when enough data

+    has been supplied so all of the header has been

+    read.

+ */

+ void

+ info_callback(png_structp png_ptr, png_infop info)

+ {

+    /* Do any setup here, including setting any of

+       the transformations mentioned in the Reading

+       PNG files section.  For now, you _must_ call

+       either png_start_read_image() or

+       png_read_update_info() after all the

+       transformations are set (even if you don't set

+       any).  You may start getting rows before

+       png_process_data() returns, so this is your

+       last chance to prepare for that.

+     */

+ }

+ /* This function is called when each row of image

+    data is complete */

+ void

+ row_callback(png_structp png_ptr, png_bytep new_row,

+    png_uint_32 row_num, int pass)

+ {

+    /* If the image is interlaced, and you turned

+       on the interlace handler, this function will

+       be called for every row in every pass.  Some

+       of these rows will not be changed from the

+       previous pass.  When the row is not changed,

+       the new_row variable will be NULL.  The rows

+       and passes are called in order, so you don't

+       really need the row_num and pass, but I'm

+       supplying them because it may make your life

+       easier.

+       For the non-NULL rows of interlaced images,

+       you must call png_progressive_combine_row()

+       passing in the row and the old row.  You can

+       call this function for NULL rows (it will just

+       return) and for non-interlaced images (it just

+       does the memcpy for you) if it will make the

+       code easier.  Thus, you can just do this for

+       all cases:

+     */

+        png_progressive_combine_row(png_ptr, old_row,

+          new_row);

+    /* where old_row is what was displayed for

+       previously for the row.  Note that the first

+       pass (pass == 0, really) will completely cover

+       the old row, so the rows do not have to be

+       initialized.  After the first pass (and only

+       for interlaced images), you will have to pass

+       the current row, and the function will combine

+       the old row and the new row.

+    */

+ }

+ void

+ end_callback(png_structp png_ptr, png_infop info)

+ {

+    /* This function is called after the whole image

+       has been read, including any chunks after the

+       image (up to and including the IEND).  You

+       will usually have the same info chunk as you

+       had in the header, although some data may have

+       been added to the comments and time fields.

+       Most people won't do much here, perhaps setting

+       a flag that marks the image as finished.

+     */

+ }

+IV. Writing

+Much of this is very similar to reading.  However, everything of

+importance is repeated here, so you won't have to constantly look

+back up in the reading section to understand writing.

+Setup

+You will want to do the I/O initialization before you get into libpng,

+so if it doesn't work, you don't have anything to undo. If you are not

+using the standard I/O functions, you will need to replace them with

+custom writing functions.  See the discussion under Customizing libpng.

+    FILE *fp = fopen(file_name, "wb");

+    if (!fp)

+    {

+       return (ERROR);

+    }

+Next, png_struct and png_info need to be allocated and initialized.

+As these can be both relatively large, you may not want to store these

+on the stack, unless you have stack space to spare.  Of course, you

+will want to check if they return NULL.  If you are also reading,

+you won't want to name your read structure and your write structure

+both "png_ptr"; you can call them anything you like, such as

+"read_ptr" and "write_ptr".  Look at pngtest.c, for example.

+    png_structp png_ptr = png_create_write_struct

+       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,

+        user_error_fn, user_warning_fn);

+    if (!png_ptr)

+       return (ERROR);

+    png_infop info_ptr = png_create_info_struct(png_ptr);

+    if (!info_ptr)

+    {

+       png_destroy_write_struct(&png_ptr,

+         (png_infopp)NULL);

+       return (ERROR);

+    }

+If you want to use your own memory allocation routines,

+define PNG_USER_MEM_SUPPORTED and use

+png_create_write_struct_2() instead of png_create_write_struct():

+    png_structp png_ptr = png_create_write_struct_2

+       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,

+        user_error_fn, user_warning_fn, (png_voidp)

+        user_mem_ptr, user_malloc_fn, user_free_fn);

+After you have these structures, you will need to set up the

+error handling.  When libpng encounters an error, it expects to

+longjmp() back to your routine.  Therefore, you will need to call

+setjmp() and pass the png_jmpbuf(png_ptr).  If you

+write the file from different routines, you will need to update

+the png_jmpbuf(png_ptr) every time you enter a new routine that will

+call a png_*() function.  See your documentation of setjmp/longjmp

+for your compiler for more information on setjmp/longjmp.  See

+the discussion on libpng error handling in the Customizing Libpng

+section below for more information on the libpng error handling.

+    if (setjmp(png_jmpbuf(png_ptr)))

+    {

+       png_destroy_write_struct(&png_ptr, &info_ptr);

+       fclose(fp);

+       return (ERROR);

+    }

+    ...

+    return;

+If you would rather avoid the complexity of setjmp/longjmp issues,

+you can compile libpng with PNG_SETJMP_NOT_SUPPORTED, in which case

+errors will result in a call to PNG_ABORT() which defaults to abort().

+Now you need to set up the output code.  The default for libpng is to

+use the C function fwrite().  If you use this, you will need to pass a

+valid FILE * in the function png_init_io().  Be sure that the file is

+opened in binary mode.  Again, if you wish to handle writing data in

+another way, see the discussion on libpng I/O handling in the Customizing

+Libpng section below.

+    png_init_io(png_ptr, fp);

+Write callbacks

+At this point, you can set up a callback function that will be

+called after each row has been written, which you can use to control

+a progress meter or the like.  It's demonstrated in pngtest.c.

+You must supply a function

+    void write_row_callback(png_ptr, png_uint_32 row,

+       int pass);

+    {

+      /* put your code here */

+    }

+(You can give it another name that you like instead of "write_row_callback")

+To inform libpng about your function, use

+    png_set_write_status_fn(png_ptr, write_row_callback);

+You now have the option of modifying how the compression library will

+run.  The following functions are mainly for testing, but may be useful

+in some cases, like if you need to write PNG files extremely fast and

+are willing to give up some compression, or if you want to get the

+maximum possible compression at the expense of slower writing.  If you

+have no special needs in this area, let the library do what it wants by

+not calling this function at all, as it has been tuned to deliver a good

+speed/compression ratio. The second parameter to png_set_filter() is

+the filter method, for which the only valid values are 0 (as of the

+July 1999 PNG specification, version 1.2) or 64 (if you are writing

+a PNG datastream that is to be embedded in a MNG datastream).  The third

+parameter is a flag that indicates which filter type(s) are to be tested

+for each scanline.  See the PNG specification for details on the specific filter

+types.

+    /* turn on or off filtering, and/or choose

+       specific filters.  You can use either a single

+       PNG_FILTER_VALUE_NAME or the logical OR of one

+       or more PNG_FILTER_NAME masks. */

+    png_set_filter(png_ptr, 0,

+       PNG_FILTER_NONE  | PNG_FILTER_VALUE_NONE |

+       PNG_FILTER_SUB   | PNG_FILTER_VALUE_SUB  |

+       PNG_FILTER_UP    | PNG_FILTER_VALUE_UP   |

+       PNG_FILTER_AVE   | PNG_FILTER_VALUE_AVE  |

+       PNG_FILTER_PAETH | PNG_FILTER_VALUE_PAETH|

+       PNG_ALL_FILTERS);

+If an application

+wants to start and stop using particular filters during compression,

+it should start out with all of the filters (to ensure that the previous

+row of pixels will be stored in case it's needed later), and then add

+and remove them after the start of compression.

+If you are writing a PNG datastream that is to be embedded in a MNG

+datastream, the second parameter can be either 0 or 64.

+The png_set_compression_*() functions interface to the zlib compression

+library, and should mostly be ignored unless you really know what you are

+doing.  The only generally useful call is png_set_compression_level()

+which changes how much time zlib spends on trying to compress the image

+data.  See the Compression Library (zlib.h and algorithm.txt, distributed

+with zlib) for details on the compression levels.

+    /* set the zlib compression level */

+    png_set_compression_level(png_ptr,

+        Z_BEST_COMPRESSION);

+    /* set other zlib parameters */

+    png_set_compression_mem_level(png_ptr, 8);

+    png_set_compression_strategy(png_ptr,

+        Z_DEFAULT_STRATEGY);

+    png_set_compression_window_bits(png_ptr, 15);

+    png_set_compression_method(png_ptr, 8);

+    png_set_compression_buffer_size(png_ptr, 8192)

+extern PNG_EXPORT(void,png_set_zbuf_size)

+Setting the contents of info for output

+You now need to fill in the png_info structure with all the data you

+wish to write before the actual image.  Note that the only thing you

+are allowed to write after the image is the text chunks and the time

+chunk (as of PNG Specification 1.2, anyway).  See png_write_end() and

+the latest PNG specification for more information on that.  If you

+wish to write them before the image, fill them in now, and flag that

+data as being valid.  If you want to wait until after the data, don't

+fill them until png_write_end().  For all the fields in png_info and

+their data types, see png.h.  For explanations of what the fields

+contain, see the PNG specification.

+Some of the more important parts of the png_info are:

+    png_set_IHDR(png_ptr, info_ptr, width, height,

+       bit_depth, color_type, interlace_type,

+       compression_type, filter_method)

+    width          - holds the width of the image

+                     in pixels (up to 2^31).

+    height         - holds the height of the image

+                     in pixels (up to 2^31).

+    bit_depth      - holds the bit depth of one of the

+                     image channels.

+                     (valid values are 1, 2, 4, 8, 16

+                     and depend also on the

+                     color_type.  See also significant

+                     bits (sBIT) below).

+    color_type     - describes which color/alpha

+                     channels are present.

+                     PNG_COLOR_TYPE_GRAY

+                        (bit depths 1, 2, 4, 8, 16)

+                     PNG_COLOR_TYPE_GRAY_ALPHA

+                        (bit depths 8, 16)

+                     PNG_COLOR_TYPE_PALETTE

+                        (bit depths 1, 2, 4, 8)

+                     PNG_COLOR_TYPE_RGB

+                        (bit_depths 8, 16)

+                     PNG_COLOR_TYPE_RGB_ALPHA

+                        (bit_depths 8, 16)

+                     PNG_COLOR_MASK_PALETTE

+                     PNG_COLOR_MASK_COLOR

+                     PNG_COLOR_MASK_ALPHA

+    interlace_type - PNG_INTERLACE_NONE or

+                     PNG_INTERLACE_ADAM7

+    compression_type - (must be

+                     PNG_COMPRESSION_TYPE_DEFAULT)

+    filter_method  - (must be PNG_FILTER_TYPE_DEFAULT

+                     or, if you are writing a PNG to

+                     be embedded in a MNG datastream,

+                     can also be

+                     PNG_INTRAPIXEL_DIFFERENCING)

+    png_set_PLTE(png_ptr, info_ptr, palette,

+       num_palette);

+    palette        - the palette for the file

+                     (array of png_color)

+    num_palette    - number of entries in the palette

+    png_set_gAMA(png_ptr, info_ptr, gamma);

+    gamma          - the gamma the image was created

+                     at (PNG_INFO_gAMA)

+    png_set_sRGB(png_ptr, info_ptr, srgb_intent);

+    srgb_intent    - the rendering intent

+                     (PNG_INFO_sRGB) The presence of

+                     the sRGB chunk means that the pixel

+                     data is in the sRGB color space.

+                     This chunk also implies specific

+                     values of gAMA and cHRM.  Rendering

+                     intent is the CSS-1 property that

+                     has been defined by the International

+                     Color Consortium

+                     (http://www.color.org).

+                     It can be one of

+                     PNG_sRGB_INTENT_SATURATION,

+                     PNG_sRGB_INTENT_PERCEPTUAL,

+                     PNG_sRGB_INTENT_ABSOLUTE, or

+                     PNG_sRGB_INTENT_RELATIVE.

+    png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr,

+       srgb_intent);

+    srgb_intent    - the rendering intent

+                     (PNG_INFO_sRGB) The presence of the

+                     sRGB chunk means that the pixel

+                     data is in the sRGB color space.

+                     This function also causes gAMA and

+                     cHRM chunks with the specific values

+                     that are consistent with sRGB to be

+                     written.

+    png_set_iCCP(png_ptr, info_ptr, name, compression_type,

+                      profile, proflen);

+    name            - The profile name.

+    compression     - The compression type; always

+                      PNG_COMPRESSION_TYPE_BASE for PNG 1.0.

+                      You may give NULL to this argument to

+                      ignore it.

+    profile         - International Color Consortium color

+                      profile data. May contain NULs.

+    proflen         - length of profile data in bytes.

+    png_set_sBIT(png_ptr, info_ptr, sig_bit);

+    sig_bit        - the number of significant bits for

+                     (PNG_INFO_sBIT) each of the gray, red,

+                     green, and blue channels, whichever are

+                     appropriate for the given color type

+                     (png_color_16)

+    png_set_tRNS(png_ptr, info_ptr, trans, num_trans,

+       trans_values);

+    trans          - array of transparent entries for

+                     palette (PNG_INFO_tRNS)

+    trans_values   - graylevel or color sample values of

+                     the single transparent color for

+                     non-paletted images (PNG_INFO_tRNS)

+    num_trans      - number of transparent entries

+                     (PNG_INFO_tRNS)

+    png_set_hIST(png_ptr, info_ptr, hist);

+                    (PNG_INFO_hIST)

+    hist           - histogram of palette (array of

+                     png_uint_16)

+    png_set_tIME(png_ptr, info_ptr, mod_time);

+    mod_time       - time image was last modified

+                     (PNG_VALID_tIME)

+    png_set_bKGD(png_ptr, info_ptr, background);

+    background     - background color (PNG_VALID_bKGD)

+    png_set_text(png_ptr, info_ptr, text_ptr, num_text);

+    text_ptr       - array of png_text holding image

+                     comments

+    text_ptr[i].compression - type of compression used

+                 on "text" PNG_TEXT_COMPRESSION_NONE

+                           PNG_TEXT_COMPRESSION_zTXt

+                           PNG_ITXT_COMPRESSION_NONE

+                           PNG_ITXT_COMPRESSION_zTXt

+    text_ptr[i].key   - keyword for comment.  Must contain

+                 1-79 characters.

+    text_ptr[i].text  - text comments for current

+                         keyword.  Can be NULL or empty.

+    text_ptr[i].text_length - length of text string,

+                 after decompression, 0 for iTXt

+    text_ptr[i].itxt_length - length of itxt string,

+                 after decompression, 0 for tEXt/zTXt

+    text_ptr[i].lang  - language of comment (NULL or

+                         empty for unknown).

+    text_ptr[i].translated_keyword  - keyword in UTF-8 (NULL

+                         or empty for unknown).

+    num_text       - number of comments

+    png_set_sPLT(png_ptr, info_ptr, &palette_ptr,

+       num_spalettes);

+    palette_ptr    - array of png_sPLT_struct structures

+                     to be added to the list of palettes

+                     in the info structure.

+    num_spalettes  - number of palette structures to be

+                     added.

+    png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y,

+        unit_type);

+    offset_x  - positive offset from the left

+                     edge of the screen

+    offset_y  - positive offset from the top

+                     edge of the screen

+    unit_type - PNG_OFFSET_PIXEL, PNG_OFFSET_MICROMETER

+    png_set_pHYs(png_ptr, info_ptr, res_x, res_y,

+        unit_type);

+    res_x       - pixels/unit physical resolution

+                  in x direction

+    res_y       - pixels/unit physical resolution

+                  in y direction

+    unit_type   - PNG_RESOLUTION_UNKNOWN,

+                  PNG_RESOLUTION_METER

+    png_set_sCAL(png_ptr, info_ptr, unit, width, height)

+    unit        - physical scale units (an integer)

+    width       - width of a pixel in physical scale units

+    height      - height of a pixel in physical scale units

+                  (width and height are doubles)

+    png_set_sCAL_s(png_ptr, info_ptr, unit, width, height)

+    unit        - physical scale units (an integer)

+    width       - width of a pixel in physical scale units

+    height      - height of a pixel in physical scale units

+                 (width and height are strings like "2.54")

+    png_set_unknown_chunks(png_ptr, info_ptr, &unknowns,

+       num_unknowns)

+    unknowns          - array of png_unknown_chunk

+                        structures holding unknown chunks

+    unknowns[i].name  - name of unknown chunk

+    unknowns[i].data  - data of unknown chunk

+    unknowns[i].size  - size of unknown chunk's data

+    unknowns[i].location - position to write chunk in file

+                           0: do not write chunk

+                           PNG_HAVE_IHDR: before PLTE

+                           PNG_HAVE_PLTE: before IDAT

+                           PNG_AFTER_IDAT: after IDAT

+The "location" member is set automatically according to

+what part of the output file has already been written.

+You can change its value after calling png_set_unknown_chunks()

+as demonstrated in pngtest.c.  Within each of the "locations",

+the chunks are sequenced according to their position in the

+structure (that is, the value of "i", which is the order in which

+the chunk was either read from the input file or defined with

+png_set_unknown_chunks).

+A quick word about text and num_text.  text is an array of png_text

+structures.  num_text is the number of valid structures in the array.

+Each png_text structure holds a language code, a keyword, a text value,

+and a compression type.

+The compression types have the same valid numbers as the compression

+types of the image data.  Currently, the only valid number is zero.

+However, you can store text either compressed or uncompressed, unlike

+images, which always have to be compressed.  So if you don't want the

+text compressed, set the compression type to PNG_TEXT_COMPRESSION_NONE.

+Because tEXt and zTXt chunks don't have a language field, if you

+specify PNG_TEXT_COMPRESSION_NONE or PNG_TEXT_COMPRESSION_zTXt

+any language code or translated keyword will not be written out.

+Until text gets around 1000 bytes, it is not worth compressing it.

+After the text has been written out to the file, the compression type

+is set to PNG_TEXT_COMPRESSION_NONE_WR or PNG_TEXT_COMPRESSION_zTXt_WR,

+so that it isn't written out again at the end (in case you are calling

+png_write_end() with the same struct.

+The keywords that are given in the PNG Specification are:

+    Title            Short (one line) title or

+                     caption for image

+    Author           Name of image's creator

+    Description      Description of image (possibly long)

+    Copyright        Copyright notice

+    Creation Time    Time of original image creation

+                     (usually RFC 1123 format, see below)

+    Software         Software used to create the image

+    Disclaimer       Legal disclaimer

+    Warning          Warning of nature of content

+    Source           Device used to create the image

+    Comment          Miscellaneous comment; conversion

+                     from other image format

+The keyword-text pairs work like this.  Keywords should be short

+simple descriptions of what the comment is about.  Some typical

+keywords are found in the PNG specification, as is some recommendations

+on keywords.  You can repeat keywords in a file.  You can even write

+some text before the image and some after.  For example, you may want

+to put a description of the image before the image, but leave the

+disclaimer until after, so viewers working over modem connections

+don't have to wait for the disclaimer to go over the modem before

+they start seeing the image.  Finally, keywords should be full

+words, not abbreviations.  Keywords and text are in the ISO 8859-1

+(Latin-1) character set (a superset of regular ASCII) and can not

+contain NUL characters, and should not contain control or other

+unprintable characters.  To make the comments widely readable, stick

+with basic ASCII, and avoid machine specific character set extensions

+like the IBM-PC character set.  The keyword must be present, but

+you can leave off the text string on non-compressed pairs.

+Compressed pairs must have a text string, as only the text string

+is compressed anyway, so the compression would be meaningless.

+PNG supports modification time via the png_time structure.  Two

+conversion routines are provided, png_convert_from_time_t() for

+time_t and png_convert_from_struct_tm() for struct tm.  The

+time_t routine uses gmtime().  You don't have to use either of

+these, but if you wish to fill in the png_time structure directly,

+you should provide the time in universal time (GMT) if possible

+instead of your local time.  Note that the year number is the full

+year (e.g. 1998, rather than 98 - PNG is year 2000 compliant!), and

+that months start with 1.

+If you want to store the time of the original image creation, you should

+use a plain tEXt chunk with the "Creation Time" keyword.  This is

+necessary because the "creation time" of a PNG image is somewhat vague,

+depending on whether you mean the PNG file, the time the image was

+created in a non-PNG format, a still photo from which the image was

+scanned, or possibly the subject matter itself.  In order to facilitate

+machine-readable dates, it is recommended that the "Creation Time"

+tEXt chunk use RFC 1123 format dates (e.g. "22 May 1997 18:07:10 GMT"),

+although this isn't a requirement.  Unlike the tIME chunk, the

+"Creation Time" tEXt chunk is not expected to be automatically changed

+by the software.  To facilitate the use of RFC 1123 dates, a function

+png_convert_to_rfc1123(png_timep) is provided to convert from PNG

+time to an RFC 1123 format string.

+Writing unknown chunks

+You can use the png_set_unknown_chunks function to queue up chunks

+for writing.  You give it a chunk name, raw data, and a size; that's

+all there is to it.  The chunks will be written by the next following

+png_write_info_before_PLTE, png_write_info, or png_write_end function.

+Any chunks previously read into the info structure's unknown-chunk

+list will also be written out in a sequence that satisfies the PNG

+specification's ordering rules.

+The high-level write interface

+At this point there are two ways to proceed; through the high-level

+write interface, or through a sequence of low-level write operations.

+You can use the high-level interface if your image data is present

+in the info structure.  All defined output

+transformations are permitted, enabled by the following masks.

+    PNG_TRANSFORM_IDENTITY      No transformation

+    PNG_TRANSFORM_PACKING       Pack 1, 2 and 4-bit samples

+    PNG_TRANSFORM_PACKSWAP      Change order of packed

+                                pixels to LSB first

+    PNG_TRANSFORM_INVERT_MONO   Invert monochrome images

+    PNG_TRANSFORM_SHIFT         Normalize pixels to the

+                                sBIT depth

+    PNG_TRANSFORM_BGR           Flip RGB to BGR, RGBA

+                                to BGRA

+    PNG_TRANSFORM_SWAP_ALPHA    Flip RGBA to ARGB or GA

+                                to AG

+    PNG_TRANSFORM_INVERT_ALPHA  Change alpha from opacity

+                                to transparency

+    PNG_TRANSFORM_SWAP_ENDIAN   Byte-swap 16-bit samples

+    PNG_TRANSFORM_STRIP_FILLER  Strip out filler bytes.

+If you have valid image data in the info structure (you can use

+png_set_rows() to put image data in the info structure), simply do this:

+    png_write_png(png_ptr, info_ptr, png_transforms, NULL)

+where png_transforms is an integer containing the logical OR of some set of

+transformation flags.  This call is equivalent to png_write_info(),

+followed the set of transformations indicated by the transform mask,

+then png_write_image(), and finally png_write_end().

+(The final parameter of this call is not yet used.  Someday it might point

+to transformation parameters required by some future output transform.)

+You must use png_transforms and not call any png_set_transform() functions

+when you use png_write_png().

+The low-level write interface

+If you are going the low-level route instead, you are now ready to

+write all the file information up to the actual image data.  You do

+this with a call to png_write_info().

+    png_write_info(png_ptr, info_ptr);

+Note that there is one transformation you may need to do before

+png_write_info().  In PNG files, the alpha channel in an image is the

+level of opacity.  If your data is supplied as a level of

+transparency, you can invert the alpha channel before you write it, so

+that 0 is fully transparent and 255 (in 8-bit or paletted images) or

+65535 (in 16-bit images) is fully opaque, with

+    png_set_invert_alpha(png_ptr);

+This must appear before png_write_info() instead of later with the

+other transformations because in the case of paletted images the tRNS

+chunk data has to be inverted before the tRNS chunk is written.  If

+your image is not a paletted image, the tRNS data (which in such cases

+represents a single color to be rendered as transparent) won't need to

+be changed, and you can safely do this transformation after your

+png_write_info() call.

+If you need to write a private chunk that you want to appear before

+the PLTE chunk when PLTE is present, you can write the PNG info in

+two steps, and insert code to write your own chunk between them:

+    png_write_info_before_PLTE(png_ptr, info_ptr);

+    png_set_unknown_chunks(png_ptr, info_ptr, ...);

+    png_write_info(png_ptr, info_ptr);

+After you've written the file information, you can set up the library

+to handle any special transformations of the image data.  The various

+ways to transform the data will be described in the order that they

+should occur.  This is important, as some of these change the color

+type and/or bit depth of the data, and some others only work on

+certain color types and bit depths.  Even though each transformation

+checks to see if it has data that it can do something with, you should

+make sure to only enable a transformation if it will be valid for the

+data.  For example, don't swap red and blue on grayscale data.

+PNG files store RGB pixels packed into 3 or 6 bytes.  This code tells

+the library to strip input data that has 4 or 8 bytes per pixel down

+to 3 or 6 bytes (or strip 2 or 4-byte grayscale+filler data to 1 or 2

+bytes per pixel).

+    png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);

+where the 0 is unused, and the location is either PNG_FILLER_BEFORE or

+PNG_FILLER_AFTER, depending upon whether the filler byte in the pixel

+is stored XRGB or RGBX.

+PNG files pack pixels of bit depths 1, 2, and 4 into bytes as small as

+they can, resulting in, for example, 8 pixels per byte for 1 bit files.

+If the data is supplied at 1 pixel per byte, use this code, which will

+correctly pack the pixels into a single byte:

+    png_set_packing(png_ptr);

+PNG files reduce possible bit depths to 1, 2, 4, 8, and 16.  If your

+data is of another bit depth, you can write an sBIT chunk into the

+file so that decoders can recover the original data if desired.

+    /* Set the true bit depth of the image data */

+    if (color_type & PNG_COLOR_MASK_COLOR)

+    {

+        sig_bit.red = true_bit_depth;

+        sig_bit.green = true_bit_depth;

+        sig_bit.blue = true_bit_depth;

+    }

+    else

+    {

+        sig_bit.gray = true_bit_depth;

+    }

+    if (color_type & PNG_COLOR_MASK_ALPHA)

+    {

+        sig_bit.alpha = true_bit_depth;

+    }

+    png_set_sBIT(png_ptr, info_ptr, &sig_bit);

+If the data is stored in the row buffer in a bit depth other than

+one supported by PNG (e.g. 3 bit data in the range 0-7 for a 4-bit PNG),

+this will scale the values to appear to be the correct bit depth as

+is required by PNG.

+    png_set_shift(png_ptr, &sig_bit);

+PNG files store 16 bit pixels in network byte order (big-endian,

+ie. most significant bits first).  This code would be used if they are

+supplied the other way (little-endian, i.e. least significant bits

+first, the way PCs store them):

+    if (bit_depth > 8)

+       png_set_swap(png_ptr);

+If you are using packed-pixel images (1, 2, or 4 bits/pixel), and you

+need to change the order the pixels are packed into bytes, you can use:

+    if (bit_depth < 8)

+       png_set_packswap(png_ptr);

+PNG files store 3 color pixels in red, green, blue order.  This code

+would be used if they are supplied as blue, green, red:

+    png_set_bgr(png_ptr);

+PNG files describe monochrome as black being zero and white being

+one. This code would be used if the pixels are supplied with this reversed

+(black being one and white being zero):

+    png_set_invert_mono(png_ptr);

+Finally, you can write your own transformation function if none of

+the existing ones meets your needs.  This is done by setting a callback

+with

+    png_set_write_user_transform_fn(png_ptr,

+       write_transform_fn);

+You must supply the function

+    void write_transform_fn(png_ptr ptr, row_info_ptr

+       row_info, png_bytep data)

+See pngtest.c for a working example.  Your function will be called

+before any of the other transformations are processed.

+You can also set up a pointer to a user structure for use by your

+callback function.

+    png_set_user_transform_info(png_ptr, user_ptr, 0, 0);

+The user_channels and user_depth parameters of this function are ignored

+when writing; you can set them to zero as shown.

+You can retrieve the pointer via the function png_get_user_transform_ptr().

+For example:

+    voidp write_user_transform_ptr =

+       png_get_user_transform_ptr(png_ptr);

+It is possible to have libpng flush any pending output, either manually,

+or automatically after a certain number of lines have been written.  To

+flush the output stream a single time call:

+    png_write_flush(png_ptr);

+and to have libpng flush the output stream periodically after a certain

+number of scanlines have been written, call:

+    png_set_flush(png_ptr, nrows);

+Note that the distance between rows is from the last time png_write_flush()

+was called, or the first row of the image if it has never been called.

+So if you write 50 lines, and then png_set_flush 25, it will flush the

+output on the next scanline, and every 25 lines thereafter, unless

+png_write_flush() is called before 25 more lines have been written.

+If nrows is too small (less than about 10 lines for a 640 pixel wide

+RGB image) the image compression may decrease noticeably (although this

+may be acceptable for real-time applications).  Infrequent flushing will

+only degrade the compression performance by a few percent over images

+that do not use flushing.

+Writing the image data

+That's it for the transformations.  Now you can write the image data.

+The simplest way to do this is in one function call.  If you have the

+whole image in memory, you can just call png_write_image() and libpng

+will write the image.  You will need to pass in an array of pointers to

+each row.  This function automatically handles interlacing, so you don't

+need to call png_set_interlace_handling() or call this function multiple

+times, or any of that other stuff necessary with png_write_rows().

+    png_write_image(png_ptr, row_pointers);

+where row_pointers is:

+    png_byte *row_pointers[height];

+You can point to void or char or whatever you use for pixels.

+If you don't want to write the whole image at once, you can

+use png_write_rows() instead.  If the file is not interlaced,

+this is simple:

+    png_write_rows(png_ptr, row_pointers,

+       number_of_rows);

+row_pointers is the same as in the png_write_image() call.

+If you are just writing one row at a time, you can do this with

+a single row_pointer instead of an array of row_pointers:

+    png_bytep row_pointer = row;

+    png_write_row(png_ptr, row_pointer);

+When the file is interlaced, things can get a good deal more

+complicated.  The only currently (as of the PNG Specification

+version 1.2, dated July 1999) defined interlacing scheme for PNG files

+is the "Adam7" interlace scheme, that breaks down an

+image into seven smaller images of varying size.  libpng will build

+these images for you, or you can do them yourself.  If you want to

+build them yourself, see the PNG specification for details of which

+pixels to write when.

+If you don't want libpng to handle the interlacing details, just

+use png_set_interlace_handling() and call png_write_rows() the

+correct number of times to write all seven sub-images.

+If you want libpng to build the sub-images, call this before you start

+writing any rows:

+    number_of_passes =

+       png_set_interlace_handling(png_ptr);

+This will return the number of passes needed.  Currently, this

+is seven, but may change if another interlace type is added.

+Then write the complete image number_of_passes times.

+    png_write_rows(png_ptr, row_pointers,

+       number_of_rows);

+As some of these rows are not used, and thus return immediately,

+you may want to read about interlacing in the PNG specification,

+and only update the rows that are actually used.

+Finishing a sequential write

+After you are finished writing the image, you should finish writing

+the file.  If you are interested in writing comments or time, you should

+pass an appropriately filled png_info pointer.  If you are not interested,

+you can pass NULL.

+    png_write_end(png_ptr, info_ptr);

+When you are done, you can free all memory used by libpng like this:

+    png_destroy_write_struct(&png_ptr, &info_ptr);

+It is also possible to individually free the info_ptr members that

+point to libpng-allocated storage with the following function:

+    png_free_data(png_ptr, info_ptr, mask, seq)

+    mask  - identifies data to be freed, a mask

+            containing the logical OR of one or

+            more of

+              PNG_FREE_PLTE, PNG_FREE_TRNS,

+              PNG_FREE_HIST, PNG_FREE_ICCP,

+              PNG_FREE_PCAL, PNG_FREE_ROWS,

+              PNG_FREE_SCAL, PNG_FREE_SPLT,

+              PNG_FREE_TEXT, PNG_FREE_UNKN,

+            or simply PNG_FREE_ALL

+    seq   - sequence number of item to be freed

+            (-1 for all items)

+This function may be safely called when the relevant storage has

+already been freed, or has not yet been allocated, or was allocated

+by the user  and not by libpng,  and will in those

+cases do nothing.  The "seq" parameter is ignored if only one item

+of the selected data type, such as PLTE, is allowed.  If "seq" is not

+-1, and multiple items are allowed for the data type identified in

+the mask, such as text or sPLT, only the n'th item in the structure

+is freed, where n is "seq".

+If you allocated data such as a palette that you passed

+in to libpng with png_set_*, you must not free it until just before the call to

+png_destroy_write_struct().

+The default behavior is only to free data that was allocated internally

+by libpng.  This can be changed, so that libpng will not free the data,

+or so that it will free data that was allocated by the user with png_malloc()

+or png_zalloc() and passed in via a png_set_*() function, with

+    png_data_freer(png_ptr, info_ptr, freer, mask)

+    mask   - which data elements are affected

+             same choices as in png_free_data()

+    freer  - one of

+               PNG_DESTROY_WILL_FREE_DATA

+               PNG_SET_WILL_FREE_DATA

+               PNG_USER_WILL_FREE_DATA

+For example, to transfer responsibility for some data from a read structure

+to a write structure, you could use

+    png_data_freer(read_ptr, read_info_ptr,

+       PNG_USER_WILL_FREE_DATA,

+       PNG_FREE_PLTE|PNG_FREE_tRNS|PNG_FREE_hIST)

+    png_data_freer(write_ptr, write_info_ptr,

+       PNG_DESTROY_WILL_FREE_DATA,

+       PNG_FREE_PLTE|PNG_FREE_tRNS|PNG_FREE_hIST)

+thereby briefly reassigning responsibility for freeing to the user but

+immediately afterwards reassigning it once more to the write_destroy

+function.  Having done this, it would then be safe to destroy the read

+structure and continue to use the PLTE, tRNS, and hIST data in the write

+structure.

+This function only affects data that has already been allocated.

+You can call this function before calling after the png_set_*() functions

+to control whether the user or png_destroy_*() is supposed to free the data.

+When the user assumes responsibility for libpng-allocated data, the

+application must use

+png_free() to free it, and when the user transfers responsibility to libpng

+for data that the user has allocated, the user must have used png_malloc()

+or png_zalloc() to allocate it.

+If you allocated text_ptr.text, text_ptr.lang, and text_ptr.translated_keyword

+separately, do not transfer responsibility for freeing text_ptr to libpng,

+because when libpng fills a png_text structure it combines these members with

+the key member, and png_free_data() will free only text_ptr.key.  Similarly,

+if you transfer responsibility for free'ing text_ptr from libpng to your

+application, your application must not separately free those members.

+For a more compact example of writing a PNG image, see the file example.c.

+V. Modifying/Customizing libpng:

+There are three issues here.  The first is changing how libpng does

+standard things like memory allocation, input/output, and error handling.

+The second deals with more complicated things like adding new chunks,

+adding new transformations, and generally changing how libpng works.

+Both of those are compile-time issues; that is, they are generally

+determined at the time the code is written, and there is rarely a need

+to provide the user with a means of changing them.  The third is a

+run-time issue:  choosing between and/or tuning one or more alternate

+versions of computationally intensive routines; specifically, optimized

+assembly-language (and therefore compiler- and platform-dependent)

+versions.

+Memory allocation, input/output, and error handling

+All of the memory allocation, input/output, and error handling in libpng

+goes through callbacks that are user-settable.  The default routines are

+in pngmem.c, pngrio.c, pngwio.c, and pngerror.c, respectively.  To change

+these functions, call the appropriate png_set_*_fn() function.

+Memory allocation is done through the functions png_malloc()

+and png_free().  These currently just call the standard C functions.  If

+your pointers can't access more then 64K at a time, you will want to set

+MAXSEG_64K in zlib.h.  Since it is unlikely that the method of handling

+memory allocation on a platform will change between applications, these

+functions must be modified in the library at compile time.  If you prefer

+to use a different method of allocating and freeing data, you can use

+png_create_read_struct_2() or png_create_write_struct_2() to register

+your own functions as described above.

+These functions also provide a void pointer that can be retrieved via

+    mem_ptr=png_get_mem_ptr(png_ptr);

+Your replacement memory functions must have prototypes as follows:

+    png_voidp malloc_fn(png_structp png_ptr,

+       png_size_t size);

+    void free_fn(png_structp png_ptr, png_voidp ptr);

+Your malloc_fn() must return NULL in case of failure.  The png_malloc()

+function will normally call png_error() if it receives a NULL from the

+system memory allocator or from your replacement malloc_fn().

+Input/Output in libpng is done through png_read() and png_write(),

+which currently just call fread() and fwrite().  The FILE * is stored in

+png_struct and is initialized via png_init_io().  If you wish to change

+the method of I/O, the library supplies callbacks that you can set

+through the function png_set_read_fn() and png_set_write_fn() at run

+time, instead of calling the png_init_io() function.  These functions

+also provide a void pointer that can be retrieved via the function

+png_get_io_ptr().  For example:

+    png_set_read_fn(png_structp read_ptr,

+        voidp read_io_ptr, png_rw_ptr read_data_fn)

+    png_set_write_fn(png_structp write_ptr,

+        voidp write_io_ptr, png_rw_ptr write_data_fn,

+        png_flush_ptr output_flush_fn);

+    voidp read_io_ptr = png_get_io_ptr(read_ptr);

+    voidp write_io_ptr = png_get_io_ptr(write_ptr);

+The replacement I/O functions must have prototypes as follows:

+    void user_read_data(png_structp png_ptr,

+        png_bytep data, png_size_t length);

+    void user_write_data(png_structp png_ptr,

+        png_bytep data, png_size_t length);

+    void user_flush_data(png_structp png_ptr);

+Supplying NULL for the read, write, or flush functions sets them back

+to using the default C stream functions.  It is an error to read from

+a write stream, and vice versa.

+Error handling in libpng is done through png_error() and png_warning().

+Errors handled through png_error() are fatal, meaning that png_error()

+should never return to its caller.  Currently, this is handled via

+setjmp() and longjmp() (unless you have compiled libpng with

+PNG_SETJMP_NOT_SUPPORTED, in which case it is handled via PNG_ABORT()),

+but you could change this to do things like exit() if you should wish.

+On non-fatal errors, png_warning() is called

+to print a warning message, and then control returns to the calling code.

+By default png_error() and png_warning() print a message on stderr via

+fprintf() unless the library is compiled with PNG_NO_CONSOLE_IO defined

+(because you don't want the messages) or PNG_NO_STDIO defined (because

+fprintf() isn't available).  If you wish to change the behavior of the error

+functions, you will need to set up your own message callbacks.  These

+functions are normally supplied at the time that the png_struct is created.

+It is also possible to redirect errors and warnings to your own replacement

+functions after png_create_*_struct() has been called by calling:

+    png_set_error_fn(png_structp png_ptr,

+        png_voidp error_ptr, png_error_ptr error_fn,

+        png_error_ptr warning_fn);

+    png_voidp error_ptr = png_get_error_ptr(png_ptr);

+If NULL is supplied for either error_fn or warning_fn, then the libpng

+default function will be used, calling fprintf() and/or longjmp() if a

+problem is encountered.  The replacement error functions should have

+parameters as follows:

+    void user_error_fn(png_structp png_ptr,

+        png_const_charp error_msg);

+    void user_warning_fn(png_structp png_ptr,

+        png_const_charp warning_msg);

+The motivation behind using setjmp() and longjmp() is the C++ throw and

+catch exception handling methods.  This makes the code much easier to write,

+as there is no need to check every return code of every function call.

+However, there are some uncertainties about the status of local variables

+after a longjmp, so the user may want to be careful about doing anything after

+setjmp returns non-zero besides returning itself.  Consult your compiler

+documentation for more details.  For an alternative approach, you may wish

+to use the "cexcept" facility (see http://cexcept.sourceforge.net).

+Custom chunks

+If you need to read or write custom chunks, you may need to get deeper

+into the libpng code.  The library now has mechanisms for storing

+and writing chunks of unknown type; you can even declare callbacks

+for custom chunks.  Hoewver, this may not be good enough if the

+library code itself needs to know about interactions between your

+chunk and existing `intrinsic' chunks.

+If you need to write a new intrinsic chunk, first read the PNG

+specification. Acquire a first level of

+understanding of how it works.  Pay particular attention to the

+sections that describe chunk names, and look at how other chunks were

+designed, so you can do things similarly.  Second, check out the

+sections of libpng that read and write chunks.  Try to find a chunk

+that is similar to yours and use it as a template.  More details can

+be found in the comments inside the code.  It is best to handle unknown

+chunks in a generic method, via callback functions, instead of by

+modifying libpng functions.

+If you wish to write your own transformation for the data, look through

+the part of the code that does the transformations, and check out some of

+the simpler ones to get an idea of how they work.  Try to find a similar

+transformation to the one you want to add and copy off of it.  More details

+can be found in the comments inside the code itself.

+Configuring for 16 bit platforms

+You will want to look into zconf.h to tell zlib (and thus libpng) that

+it cannot allocate more then 64K at a time.  Even if you can, the memory

+won't be accessible.  So limit zlib and libpng to 64K by defining MAXSEG_64K.

+Configuring for DOS

+For DOS users who only have access to the lower 640K, you will

+have to limit zlib's memory usage via a png_set_compression_mem_level()

+call.  See zlib.h or zconf.h in the zlib library for more information.

+Configuring for Medium Model

+Libpng's support for medium model has been tested on most of the popular

+compilers.  Make sure MAXSEG_64K gets defined, USE_FAR_KEYWORD gets

+defined, and FAR gets defined to far in pngconf.h, and you should be

+all set.  Everything in the library (except for zlib's structure) is

+expecting far data.  You must use the typedefs with the p or pp on

+the end for pointers (or at least look at them and be careful).  Make

+note that the rows of data are defined as png_bytepp, which is an

+unsigned char far * far *.

+Configuring for gui/windowing platforms:

+You will need to write new error and warning functions that use the GUI

+interface, as described previously, and set them to be the error and

+warning functions at the time that png_create_*_struct() is called,

+in order to have them available during the structure initialization.

+They can be changed later via png_set_error_fn().  On some compilers,

+you may also have to change the memory allocators (png_malloc, etc.).

+Configuring for compiler xxx:

+All includes for libpng are in pngconf.h.  If you need to add/change/delete

+an include, this is the place to do it.  The includes that are not

+needed outside libpng are protected by the PNG_INTERNAL definition,

+which is only defined for those routines inside libpng itself.  The

+files in libpng proper only include png.h, which includes pngconf.h.

+Configuring zlib:

+There are special functions to configure the compression.  Perhaps the

+most useful one changes the compression level, which currently uses

+input compression values in the range 0 - 9.  The library normally

+uses the default compression level (Z_DEFAULT_COMPRESSION = 6).  Tests

+have shown that for a large majority of images, compression values in

+the range 3-6 compress nearly as well as higher levels, and do so much

+faster.  For online applications it may be desirable to have maximum speed

+(Z_BEST_SPEED = 1).  With versions of zlib after v0.99, you can also

+specify no compression (Z_NO_COMPRESSION = 0), but this would create

+files larger than just storing the raw bitmap.  You can specify the

+compression level by calling:

+    png_set_compression_level(png_ptr, level);

+Another useful one is to reduce the memory level used by the library.

+The memory level defaults to 8, but it can be lowered if you are

+short on memory (running DOS, for example, where you only have 640K).

+Note that the memory level does have an effect on compression; among

+other things, lower levels will result in sections of incompressible

+data being emitted in smaller stored blocks, with a correspondingly

+larger relative overhead of up to 15% in the worst case.

+    png_set_compression_mem_level(png_ptr, level);

+The other functions are for configuring zlib.  They are not recommended

+for normal use and may result in writing an invalid PNG file.  See

+zlib.h for more information on what these mean.

+    png_set_compression_strategy(png_ptr,

+        strategy);

+    png_set_compression_window_bits(png_ptr,

+        window_bits);

+    png_set_compression_method(png_ptr, method);

+    png_set_compression_buffer_size(png_ptr, size);

+Controlling row filtering

+If you want to control whether libpng uses filtering or not, which

+filters are used, and how it goes about picking row filters, you

+can call one of these functions.  The selection and configuration

+of row filters can have a significant impact on the size and

+encoding speed and a somewhat lesser impact on the decoding speed

+of an image.  Filtering is enabled by default for RGB and grayscale

+images (with and without alpha), but not for paletted images nor

+for any images with bit depths less than 8 bits/pixel.

+The 'method' parameter sets the main filtering method, which is

+currently only '0' in the PNG 1.2 specification.  The 'filters'

+parameter sets which filter(s), if any, should be used for each

+scanline.  Possible values are PNG_ALL_FILTERS and PNG_NO_FILTERS

+to turn filtering on and off, respectively.

+Individual filter types are PNG_FILTER_NONE, PNG_FILTER_SUB,

+PNG_FILTER_UP, PNG_FILTER_AVG, PNG_FILTER_PAETH, which can be bitwise

+ORed together with '|' to specify one or more filters to use.

+These filters are described in more detail in the PNG specification.

+If you intend to change the filter type during the course of writing

+the image, you should start with flags set for all of the filters

+you intend to use so that libpng can initialize its internal

+structures appropriately for all of the filter types.  (Note that this

+means the first row must always be adaptively filtered, because libpng

+currently does not allocate the filter buffers until png_write_row()

+is called for the first time.)

+    filters = PNG_FILTER_NONE | PNG_FILTER_SUB

+              PNG_FILTER_UP | PNG_FILTER_AVE |

+              PNG_FILTER_PAETH | PNG_ALL_FILTERS;

+    png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE,

+       filters);

+              The second parameter can also be

+              PNG_INTRAPIXEL_DIFFERENCING if you are

+              writing a PNG to be embedded in a MNG

+              datastream.  This parameter must be the

+              same as the value of filter_method used

+              in png_set_IHDR().

+It is also possible to influence how libpng chooses from among the

+available filters.  This is done in one or both of two ways - by

+telling it how important it is to keep the same filter for successive

+rows, and by telling it the relative computational costs of the filters.

+    double weights[3] = {1.5, 1.3, 1.1},

+       costs[PNG_FILTER_VALUE_LAST] =

+       {1.0, 1.3, 1.3, 1.5, 1.7};

+    png_set_filter_heuristics(png_ptr,

+       PNG_FILTER_HEURISTIC_WEIGHTED, 3,

+       weights, costs);

+The weights are multiplying factors that indicate to libpng that the

+row filter should be the same for successive rows unless another row filter

+is that many times better than the previous filter.  In the above example,

+if the previous 3 filters were SUB, SUB, NONE, the SUB filter could have a

+"sum of absolute differences" 1.5 x 1.3 times higher than other filters

+and still be chosen, while the NONE filter could have a sum 1.1 times

+higher than other filters and still be chosen.  Unspecified weights are

+taken to be 1.0, and the specified weights should probably be declining

+like those above in order to emphasize recent filters over older filters.

+The filter costs specify for each filter type a relative decoding cost

+to be considered when selecting row filters.  This means that filters

+with higher costs are less likely to be chosen over filters with lower

+costs, unless their "sum of absolute differences" is that much smaller.

+The costs do not necessarily reflect the exact computational speeds of

+the various filters, since this would unduly influence the final image

+size.

+Note that the numbers above were invented purely for this example and

+are given only to help explain the function usage.  Little testing has

+been done to find optimum values for either the costs or the weights.

+Removing unwanted object code

+There are a bunch of #define's in pngconf.h that control what parts of

+libpng are compiled.  All the defines end in _SUPPORTED.  If you are

+never going to use a capability, you can change the #define to #undef

+before recompiling libpng and save yourself code and data space, or

+you can turn off individual capabilities with defines that begin with

+PNG_NO_.

+You can also turn all of the transforms and ancillary chunk capabilities

+off en masse with compiler directives that define

+PNG_NO_READ[or WRITE]_TRANSFORMS, or PNG_NO_READ[or WRITE]_ANCILLARY_CHUNKS,

+or all four,

+along with directives to turn on any of the capabilities that you do

+want.  The PNG_NO_READ[or WRITE]_TRANSFORMS directives disable

+the extra transformations but still leave the library fully capable of reading

+and writing PNG files with all known public chunks

+Use of the PNG_NO_READ[or WRITE]_ANCILLARY_CHUNKS directive

+produces a library that is incapable of reading or writing ancillary chunks.

+If you are not using the progressive reading capability, you can

+turn that off with PNG_NO_PROGRESSIVE_READ (don't confuse

+this with the INTERLACING capability, which you'll still have).

+All the reading and writing specific code are in separate files, so the

+linker should only grab the files it needs.  However, if you want to

+make sure, or if you are building a stand alone library, all the

+reading files start with pngr and all the writing files start with

+pngw.  The files that don't match either (like png.c, pngtrans.c, etc.)

+are used for both reading and writing, and always need to be included.

+The progressive reader is in pngpread.c

+If you are creating or distributing a dynamically linked library (a .so

+or DLL file), you should not remove or disable any parts of the library,

+as this will cause applications linked with different versions of the

+library to fail if they call functions not available in your library.

+The size of the library itself should not be an issue, because only

+those sections that are actually used will be loaded into memory.

+Requesting debug printout

+The macro definition PNG_DEBUG can be used to request debugging

+printout.  Set it to an integer value in the range 0 to 3.  Higher

+numbers result in increasing amounts of debugging information.  The

+information is printed to the "stderr" file, unless another file

+name is specified in the PNG_DEBUG_FILE macro definition.

+When PNG_DEBUG > 0, the following functions (macros) become available:

+   png_debug(level, message)

+   png_debug1(level, message, p1)

+   png_debug2(level, message, p1, p2)

+in which "level" is compared to PNG_DEBUG to decide whether to print

+the message, "message" is the formatted string to be printed,

+and p1 and p2 are parameters that are to be embedded in the string

+according to printf-style formatting directives.  For example,

+   png_debug1(2, "foo=%d\n", foo);

+is expanded to

+   if(PNG_DEBUG > 2)

+     fprintf(PNG_DEBUG_FILE, "foo=%d\n", foo);

+When PNG_DEBUG is defined but is zero, the macros aren't defined, but you

+can still use PNG_DEBUG to control your own debugging:

+   #ifdef PNG_DEBUG

+       fprintf(stderr, ...

+   #endif

+When PNG_DEBUG = 1, the macros are defined, but only png_debug statements

+having level = 0 will be printed.  There aren't any such statements in

+this version of libpng, but if you insert some they will be printed.

+VI.  Runtime optimization

+A new feature in libpng 1.2.0 is the ability to dynamically switch between

+standard and optimized versions of some routines.  Currently these are

+limited to three computationally intensive tasks when reading PNG files:

+decoding row filters, expanding interlacing, and combining interlaced or

+transparent row data with previous row data.  Currently the optimized

+versions are available only for x86 (Intel, AMD, etc.) platforms with

+MMX support, though this may change in future versions.  (For example,

+the non-MMX assembler optimizations for zlib might become similarly

+runtime-selectable in future releases, in which case libpng could be

+extended to support them.  Alternatively, the compile-time choice of

+floating-point versus integer routines for gamma correction might become

+runtime-selectable.)

+Because such optimizations tend to be very platform- and compiler-dependent,

+both in how they are written and in how they perform, the new runtime code

+in libpng has been written to allow programs to query, enable, and disable

+either specific optimizations or all such optimizations.  For example, to

+enable all possible optimizations (bearing in mind that some "optimizations"

+may actually run more slowly in rare cases):

+    #if defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)

+       png_uint_32 mask, flags;

+       flags = png_get_asm_flags(png_ptr);

+       mask = png_get_asm_flagmask(PNG_SELECT_READ | PNG_SELECT_WRITE);

+       png_set_asm_flags(png_ptr, flags | mask);

+    #endif

+To enable only optimizations relevant to reading PNGs, use PNG_SELECT_READ

+by itself when calling png_get_asm_flagmask(); similarly for optimizing

+only writing.  To disable all optimizations:

+    #if defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)

+       flags = png_get_asm_flags(png_ptr);

+       mask = png_get_asm_flagmask(PNG_SELECT_READ | PNG_SELECT_WRITE);

+       png_set_asm_flags(png_ptr, flags & ~mask);

+    #endif

+To enable or disable only MMX-related features, use png_get_mmx_flagmask()

+in place of png_get_asm_flagmask().  The mmx version takes one additional

+parameter:

+    #if defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)

+       int selection = PNG_SELECT_READ | PNG_SELECT_WRITE;

+       int compilerID;

+       mask = png_get_mmx_flagmask(selection, &compilerID);

+    #endif

+On return, compilerID will indicate which version of the MMX assembler

+optimizations was compiled.  Currently two flavors exist:  Microsoft

+Visual C++ (compilerID == 1) and GNU C (a.k.a. gcc/gas, compilerID == 2).

+On non-x86 platforms or on systems compiled without MMX optimizations, a

+value of -1 is used.

+Note that both png_get_asm_flagmask() and png_get_mmx_flagmask() return

+all valid, settable optimization bits for the version of the library that's

+currently in use.  In the case of shared (dynamically linked) libraries,

+this may include optimizations that did not exist at the time the code was

+written and compiled.  It is also possible, of course, to enable only known,

+specific optimizations; for example:

+    #if defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)

+       flags = PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  \

+             | PNG_ASM_FLAG_MMX_READ_INTERLACE    \

+             | PNG_ASM_FLAG_MMX_READ_FILTER_SUB   \

+             | PNG_ASM_FLAG_MMX_READ_FILTER_UP    \

+             | PNG_ASM_FLAG_MMX_READ_FILTER_AVG   \

+             | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;

+       png_set_asm_flags(png_ptr, flags);

+    #endif

+This method would enable only the MMX read-optimizations available at the

+time of libpng 1.2.0's release, regardless of whether a later version of

+the DLL were actually being used.  (Also note that these functions did not

+exist in versions older than 1.2.0, so any attempt to run a dynamically

+linked app on such an older version would fail.)

+To determine whether the processor supports MMX instructions at all, use

+the png_mmx_support() function:

+    #if defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)

+       mmxsupport = png_mmx_support();

+    #endif

+It returns -1 if MMX support is not compiled into libpng, 0 if MMX code

+is compiled but MMX is not supported by the processor, or 1 if MMX support

+is fully available.  Note that png_mmx_support(), png_get_mmx_flagmask(),

+and png_get_asm_flagmask() all may be called without allocating and ini-

+tializing any PNG structures (for example, as part of a usage screen or

+"about" box).

+The following code can be used to prevent an application from using the

+thread_unsafe features, even if libpng was built with PNG_THREAD_UNSAFE_OK

+defined:

+#if defined(PNG_USE_PNGGCCRD) && defined(PNG_ASSEMBLER_CODE_SUPPORTED) \

+  && defined(PNG_THREAD_UNSAFE_OK)

+    /* Disable thread-unsafe features of pnggccrd */

+    if (png_access_version() >= 10200)

+    {

+      png_uint_32 mmx_disable_mask = 0;

+      png_uint_32 asm_flags;

+      mmx_disable_mask |= ( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  \

+                          | PNG_ASM_FLAG_MMX_READ_FILTER_SUB   \

+                          | PNG_ASM_FLAG_MMX_READ_FILTER_AVG   \

+                          | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH );

+      asm_flags = png_get_asm_flags(png_ptr);

+      png_set_asm_flags(png_ptr, asm_flags & ~mmx_disable_mask);

+    }

+#endif

+For more extensive examples of runtime querying, enabling and disabling

+of optimized features, see contrib/gregbook/readpng2.c in the libpng

+source-code distribution.

+VII.  MNG support

+The MNG specification (available at http://www.libpng.org/pub/mng) allows

+certain extensions to PNG for PNG images that are embedded in MNG datastreams.

+Libpng can support some of these extensions.  To enable them, use the

+png_permit_mng_features() function:

+   feature_set = png_permit_mng_features(png_ptr, mask)

+   mask is a png_uint_32 containing the logical OR of the

+        features you want to enable.  These include

+        PNG_FLAG_MNG_EMPTY_PLTE

+        PNG_FLAG_MNG_FILTER_64

+        PNG_ALL_MNG_FEATURES

+   feature_set is a png_uint_32 that is the logical AND of

+      your mask with the set of MNG features that is

+      supported by the version of libpng that you are using.

+It is an error to use this function when reading or writing a standalone

+PNG file with the PNG 8-byte signature.  The PNG datastream must be wrapped

+in a MNG datastream.  As a minimum, it must have the MNG 8-byte signature

+and the MHDR and MEND chunks.  Libpng does not provide support for these

+or any other MNG chunks; your application must provide its own support for

+them.  You may wish to consider using libmng (available at

+http://www.libmng.com) instead.

+VIII.  Changes to Libpng from version 0.88

+It should be noted that versions of libpng later than 0.96 are not

+distributed by the original libpng author, Guy Schalnat, nor by

+Andreas Dilger, who had taken over from Guy during 1996 and 1997, and

+distributed versions 0.89 through 0.96, but rather by another member

+of the original PNG Group, Glenn Randers-Pehrson.  Guy and Andreas are

+still alive and well, but they have moved on to other things.

+The old libpng functions png_read_init(), png_write_init(),

+png_info_init(), png_read_destroy(), and png_write_destroy() have been

+moved to PNG_INTERNAL in version 0.95 to discourage their use.  These

+functions will be removed from libpng version 2.0.0.

+The preferred method of creating and initializing the libpng structures is

+via the png_create_read_struct(), png_create_write_struct(), and

+png_create_info_struct() because they isolate the size of the structures

+from the application, allow version error checking, and also allow the

+use of custom error handling routines during the initialization, which

+the old functions do not.  The functions png_read_destroy() and

+png_write_destroy() do not actually free the memory that libpng

+allocated for these structs, but just reset the data structures, so they

+can be used instead of png_destroy_read_struct() and

+png_destroy_write_struct() if you feel there is too much system overhead

+allocating and freeing the png_struct for each image read.

+Setting the error callbacks via png_set_message_fn() before

+png_read_init() as was suggested in libpng-0.88 is no longer supported

+because this caused applications that do not use custom error functions

+to fail if the png_ptr was not initialized to zero.  It is still possible

+to set the error callbacks AFTER png_read_init(), or to change them with

+png_set_error_fn(), which is essentially the same function, but with a new

+name to force compilation errors with applications that try to use the old

+method.

+Starting with version 1.0.7, you can find out which version of the library

+you are using at run-time:

+   png_uint_32 libpng_vn = png_access_version_number();

+The number libpng_vn is constructed from the major version, minor

+version with leading zero, and release number with leading zero,

+(e.g., libpng_vn for version 1.0.7 is 10007).

+You can also check which version of png.h you used when compiling your

+application:

+   png_uint_32 application_vn = PNG_LIBPNG_VER;

+IX. Y2K Compliance in libpng

+December 3, 2004

+Since the PNG Development group is an ad-hoc body, we can't make

+an official declaration.

+This is your unofficial assurance that libpng from version 0.71 and

+upward through 1.2.8 are Y2K compliant.  It is my belief that earlier

+versions were also Y2K compliant.

+Libpng only has three year fields.  One is a 2-byte unsigned integer that

+will hold years up to 65535.  The other two hold the date in text

+format, and will hold years up to 9999.

+The integer is

+    "png_uint_16 year" in png_time_struct.

+The strings are

+    "png_charp time_buffer" in png_struct and

+    "near_time_buffer", which is a local character string in png.c.

+There are seven time-related functions:

+    png_convert_to_rfc_1123() in png.c

+      (formerly png_convert_to_rfc_1152() in error)

+    png_convert_from_struct_tm() in pngwrite.c, called

+      in pngwrite.c

+    png_convert_from_time_t() in pngwrite.c

+    png_get_tIME() in pngget.c

+    png_handle_tIME() in pngrutil.c, called in pngread.c

+    png_set_tIME() in pngset.c

+    png_write_tIME() in pngwutil.c, called in pngwrite.c

+All appear to handle dates properly in a Y2K environment.  The

+png_convert_from_time_t() function calls gmtime() to convert from system

+clock time, which returns (year - 1900), which we properly convert to

+the full 4-digit year.  There is a possibility that applications using

+libpng are not passing 4-digit years into the png_convert_to_rfc_1123()

+function, or that they are incorrectly passing only a 2-digit year

+instead of "year - 1900" into the png_convert_from_struct_tm() function,

+but this is not under our control.  The libpng documentation has always

+stated that it works with 4-digit years, and the APIs have been

+documented as such.

+The tIME chunk itself is also Y2K compliant.  It uses a 2-byte unsigned

+integer to hold the year, and can hold years as large as 65535.

+zlib, upon which libpng depends, is also Y2K compliant.  It contains

+no date-related code.

+   Glenn Randers-Pehrson

+   libpng maintainer

+   PNG Development Group

--- /dev/null

+++ b/src/gfx/libpng/libpngpf.3.man

@@ -1,0 +1,1096 @@

+.TH LIBPNGPF 3 "December 3, 2004"

+.SH NAME

+libpng \- Portable Network Graphics (PNG) Reference Library 1.2.8

+(private functions)

+.SH SYNOPSIS

+\fB\fB#include <png.h>\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_build_gamma_table (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_build_grayscale_palette (int \fP\fI\fP\fIbit_depth\fP\fB\fP\fB, png_colorp \fI\fIpalette\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_calculate_crc (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIptr\fP\fB\fP\fB, png_size_t \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_check_chunk_name (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_bytep \fI\fIchunk_name\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBpng_size_t png_check_keyword (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_charp \fP\fI\fP\fIkey\fP\fB\fP\fB, png_charpp \fI\fInew_key\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_combine_row (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIrow\fP\fB\fP\fB, int \fI\fImask\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_correct_palette (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_colorp \fP\fI\fP\fIpalette\fP\fB\fP\fB, int \fI\fInum_palette\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBint png_crc_error (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBint png_crc_finish (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIskip\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_crc_read (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIbuf\fP\fB\fP\fB, png_size_t \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBpng_voidp png_create_struct (int \fI\fItype\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBpng_voidp png_create_struct_2 (int \fP\fI\fP\fItype\fP\fB\fP\fB, png_malloc_ptr \fP\fI\fP\fImalloc_fn\fP\fB\fP\fB, png_voidp \fI\fImem_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBpng_charp png_decompress_chunk (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, int \fP\fI\fP\fIcomp_type\fP\fB\fP\fB, png_charp \fP\fI\fP\fIchunkdata\fP\fB\fP\fB, png_size_t \fP\fI\fP\fIchunklength\fP\fB\fP\fB, png_size_t \fP\fI\fP\fIprefix_length\fP\fB\fP\fB, png_size_t \fI\fI*data_length\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_destroy_struct (png_voidp \fI\fIstruct_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_destroy_struct_2 (png_voidp \fP\fI\fP\fIstruct_ptr\fP\fB\fP\fB, png_free_ptr \fP\fI\fP\fIfree_fn\fP\fB\fP\fB, png_voidp \fI\fImem_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_background (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIrow\fP\fB\fP\fB, png_color_16p \fP\fI\fP\fItrans_values\fP\fB\fP\fB, png_color_16p \fP\fI\fP\fIbackground\fP\fB\fP\fB, png_color_16p \fP\fI\fP\fIbackground_1\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIgamma_table\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIgamma_from_1\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIgamma_to_1\fP\fB\fP\fB, png_uint_16pp \fP\fI\fP\fIgamma_16\fP\fB\fP\fB, png_uint_16pp \fP\fI\fP\fIgamma_16_from_1\fP\fB\fP\fB, png_uint_16pp \fP\fI\fP\fIgamma_16_to_1\fP\fB\fP\fB, int \fI\fIgamma_shift\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_bgr (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fI\fIrow\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_chop (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fI\fIrow\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_dither (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIrow\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIpalette_lookup\fP\fB\fP\fB, png_bytep \fI\fIdither_lookup\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_expand (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIrow\fP\fB\fP\fB, png_color_16p \fI\fItrans_value\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_expand_palette (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIrow\fP\fB\fP\fB, png_colorp \fP\fI\fP\fIpalette\fP\fB\fP\fB, png_bytep \fP\fI\fP\fItrans\fP\fB\fP\fB, int \fI\fInum_trans\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_gamma (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIrow\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIgamma_table\fP\fB\fP\fB, png_uint_16pp \fP\fI\fP\fIgamma_16_table\fP\fB\fP\fB, int \fI\fIgamma_shift\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_gray_to_rgb (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fI\fIrow\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_invert (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fI\fIrow\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_pack (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIrow\fP\fB\fP\fB, png_uint_32 \fI\fIbit_depth\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_packswap (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fI\fIrow\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_read_filler (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIrow\fP\fB\fP\fB, png_uint_32 \fP\fI\fP\fIfiller\fP\fB\fP\fB, png_uint_32 \fI\fIflags\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_read_interlace (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIrow\fP\fB\fP\fB, int \fP\fI\fP\fIpass\fP\fB\fP\fB, png_uint_32 \fI\fItransformations\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_read_invert_alpha (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fI\fIrow\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_read_swap_alpha (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fI\fIrow\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_read_transformations (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBint png_do_rgb_to_gray (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fI\fIrow\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_shift (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIrow\fP\fB\fP\fB, png_color_8p \fI\fIbit_depth\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_strip_filler (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIrow\fP\fB\fP\fB, png_uint_32 \fI\fIflags\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_swap (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fI\fIrow\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_unpack (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fI\fIrow\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_unshift (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIrow\fP\fB\fP\fB, png_color_8p \fI\fIsig_bits\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_write_interlace (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIrow\fP\fB\fP\fB, int \fI\fIpass\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_write_invert_alpha (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fI\fIrow\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_write_swap_alpha (png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fI\fIrow\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_do_write_transformations (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid *png_far_to_near (png_structp png_ptr,png_voidp \fP\fI\fP\fIptr\fP\fB\fP\fB, int \fI\fIcheck\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_flush (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBpng_int_32 png_get_int_32 (png_bytep \fI\fIbuf\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBpng_uint_16 png_get_uint_16 (png_bytep \fI\fIbuf\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBpng_uint_32 png_get_uint_31 (png_bytep \fI\fIbuf\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBpng_uint_32 png_get_uint_32 (png_bytep \fI\fIbuf\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_bKGD (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_cHRM (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_gAMA (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_hIST (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_IEND (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_IHDR (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_iCCP (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_iTXt (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_oFFs (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_pCAL (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_pHYs (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_PLTE (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_sBIT (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_sCAL (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_sPLT (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_sRGB (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_tEXt (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_tIME (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_tRNS (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_unknown (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_handle_zTXt (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_info_destroy (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fI\fIinfo_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_init_mmx_flags (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_init_read_transformations (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_process_IDAT_data (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIbuffer\fP\fB\fP\fB, png_size_t \fI\fIbuffer_length\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_process_some_data (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fI\fIinfo_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_push_check_crc (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_push_crc_finish (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_push_crc_skip (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_push_fill_buffer (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIbuffer\fP\fB\fP\fB, png_size_t \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_push_handle_tEXt (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_push_handle_unknown (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_push_handle_zTXt (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_push_have_end (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fI\fIinfo_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_push_have_info (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fI\fIinfo_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_push_have_row (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_bytep \fI\fIrow\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_push_process_row (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_push_read_chunk (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fI\fIinfo_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_push_read_end (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fI\fIinfo_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_push_read_IDAT (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_push_read_sig (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fI\fIinfo_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_push_read_tEXt (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fI\fIinfo_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_push_read_zTXt (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fI\fIinfo_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_push_restore_buffer (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIbuffer\fP\fB\fP\fB, png_size_t \fI\fIbuffer_length\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_push_save_buffer (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_read_data (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIdata\fP\fB\fP\fB, png_size_t \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_read_filter_row (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_row_infop \fP\fI\fP\fIrow_info\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIrow\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIprev_row\fP\fB\fP\fB, int \fI\fIfilter\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_read_finish_row (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_read_push_finish_row (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_read_start_row (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_read_transform_info (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fI\fIinfo_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_reset_crc (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_save_int_32 (png_bytep \fP\fI\fP\fIbuf\fP\fB\fP\fB, png_int_32 \fI\fIi\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_save_uint_16 (png_bytep \fP\fI\fP\fIbuf\fP\fB\fP\fB, unsigned int \fI\fIi\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_save_uint_32 (png_bytep \fP\fI\fP\fIbuf\fP\fB\fP\fB, png_uint_32 \fI\fIi\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBint png_set_text_2 (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_infop \fP\fI\fP\fIinfo_ptr\fP\fB\fP\fB, png_textp \fP\fI\fP\fItext_ptr\fP\fB\fP\fB, int \fI\fInum_text\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_cHRM (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, double \fP\fI\fP\fIwhite_x\fP\fB\fP\fB, double \fP\fI\fP\fIwhite_y\fP\fB\fP\fB, double \fP\fI\fP\fIred_x\fP\fB\fP\fB, double \fP\fI\fP\fIred_y\fP\fB\fP\fB, double \fP\fI\fP\fIgreen_x\fP\fB\fP\fB, double \fP\fI\fP\fIgreen_y\fP\fB\fP\fB, double \fP\fI\fP\fIblue_x\fP\fB\fP\fB, double \fI\fIblue_y\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_cHRM_fixed (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_uint_32 \fP\fI\fP\fIwhite_x\fP\fB\fP\fB, png_uint_32 \fP\fI\fP\fIwhite_y\fP\fB\fP\fB, png_uint_32 \fP\fI\fP\fIred_x\fP\fB\fP\fB, png_uint_32 \fP\fI\fP\fIred_y\fP\fB\fP\fB, png_uint_32 \fP\fI\fP\fIgreen_x\fP\fB\fP\fB, png_uint_32 \fP\fI\fP\fIgreen_y\fP\fB\fP\fB, png_uint_32 \fP\fI\fP\fIblue_x\fP\fB\fP\fB, png_uint_32 \fI\fIblue_y\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_data (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIdata\fP\fB\fP\fB, png_size_t \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_filtered_row (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_bytep \fI\fIfiltered_row\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_find_filter (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_row_infop \fI\fIrow_info\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_finish_row (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_gAMA (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, double \fI\fIfile_gamma\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_gAMA_fixed (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_uint_32 \fI\fIint_file_gamma\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_hIST (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_uint_16p \fP\fI\fP\fIhist\fP\fB\fP\fB, int \fI\fInum_hist\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_iCCP (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_charp \fP\fI\fP\fIname\fP\fB\fP\fB, int \fP\fI\fP\fIcompression_type\fP\fB\fP\fB, png_charp \fP\fI\fP\fIprofile\fP\fB\fP\fB, int \fI\fIproflen\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_IDAT (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_bytep \fP\fI\fP\fIdata\fP\fB\fP\fB, png_size_t \fI\fIlength\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_IEND (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_IHDR (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_uint_32 \fP\fI\fP\fIwidth\fP\fB\fP\fB, png_uint_32 \fP\fI\fP\fIheight\fP\fB\fP\fB, int \fP\fI\fP\fIbit_depth\fP\fB\fP\fB, int \fP\fI\fP\fIcolor_type\fP\fB\fP\fB, int \fP\fI\fP\fIcompression_type\fP\fB\fP\fB, int \fP\fI\fP\fIfilter_type\fP\fB\fP\fB, int \fI\fIinterlace_type\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_iTXt (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, int \fP\fI\fP\fIcompression\fP\fB\fP\fB, png_charp \fP\fI\fP\fIkey\fP\fB\fP\fB, png_charp \fP\fI\fP\fIlang\fP\fB\fP\fB, png_charp \fP\fI\fP\fItranslated_key\fP\fB\fP\fB, png_charp \fI\fItext\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_oFFs (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_uint_32 \fP\fI\fP\fIx_offset\fP\fB\fP\fB, png_uint_32 \fP\fI\fP\fIy_offset\fP\fB\fP\fB, int \fI\fIunit_type\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_pCAL (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_charp \fP\fI\fP\fIpurpose\fP\fB\fP\fB, png_int_32 \fP\fI\fP\fIX0\fP\fB\fP\fB, png_int_32 \fP\fI\fP\fIX1\fP\fB\fP\fB, int \fP\fI\fP\fItype\fP\fB\fP\fB, int \fP\fI\fP\fInparams\fP\fB\fP\fB, png_charp \fP\fI\fP\fIunits\fP\fB\fP\fB, png_charpp \fI\fIparams\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_pHYs (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_uint_32 \fP\fI\fP\fIx_pixels_per_unit\fP\fB\fP\fB, png_uint_32 \fP\fI\fP\fIy_pixels_per_unit\fP\fB\fP\fB, int \fI\fIunit_type\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_PLTE (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_colorp \fP\fI\fP\fIpalette\fP\fB\fP\fB, png_uint_32 \fI\fInum_pal\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_sBIT (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_color_8p \fP\fI\fP\fIsbit\fP\fB\fP\fB, int \fI\fIcolor_type\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_sCAL (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_charp \fP\fI\fP\fIunit\fP\fB\fP\fB, double \fP\fI\fP\fIwidth\fP\fB\fP\fB, double \fI\fIheight\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_sCAL_s (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_charp \fP\fI\fP\fIunit\fP\fB\fP\fB, png_charp \fP\fI\fP\fIwidth\fP\fB\fP\fB, png_charp \fI\fIheight\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_sig (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_sRGB (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, int \fI\fIintent\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_sPLT (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_spalette_p \fI\fIpalette\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_start_row (png_structp \fI\fIpng_ptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_tEXt (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_charp \fP\fI\fP\fIkey\fP\fB\fP\fB, png_charp \fP\fI\fP\fItext\fP\fB\fP\fB, png_size_t \fI\fItext_len\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_tIME (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_timep \fI\fImod_time\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_tRNS (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_bytep \fP\fI\fP\fItrans\fP\fB\fP\fB, png_color_16p \fP\fI\fP\fIvalues\fP\fB\fP\fB, int \fP\fI\fP\fInumber\fP\fB\fP\fB, int \fI\fIcolor_type\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_write_zTXt (png_structp \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, png_charp \fP\fI\fP\fIkey\fP\fB\fP\fB, png_charp \fP\fI\fP\fItext\fP\fB\fP\fB, png_size_t \fP\fI\fP\fItext_len\fP\fB\fP\fB, int \fI\fIcompression\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoidpf png_zalloc (voidpf \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, uInt \fP\fI\fP\fIitems\fP\fB\fP\fB, uInt \fI\fIsize\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+\fB\fBvoid png_zfree (voidpf \fP\fI\fP\fIpng_ptr\fP\fB\fP\fB, voidpf \fI\fIptr\fP\fB\fP\fB);\fP\fP

+\fI\fB

+\fI\fB\fI\fB

+\fI\fB

+.SH DESCRIPTION

+The functions listed above are used privately by libpng

+and are not recommended for use by applications.  They are

+not "exported" to applications using shared libraries.  They

+are listed alphabetically here as an aid to libpng maintainers.

+See png.h for more information on these functions.

+.SH SEE ALSO

+libpng(3), png(5)

+.SH AUTHOR

+Glenn Randers-Pehrson

--- /dev/null

+++ b/src/gfx/libpng/mkfile

@@ -1,0 +1,27 @@

+</$objtype/mkfile

+CFLAGS=$CFLAGS -p -I ../zlib -I/sys/include/npe -D__plan9__ -D__${objtype}__ -DSTDC

+LIB=libpng.$O.a

+CLEANFILES=libpng.$O.a

+OFILES=\

+	png.$O \

+	pngerror.$O \

+	pnggccrd.$O \

+	pngget.$O \

+	pngmem.$O \

+	pngpread.$O \

+	pngread.$O \

+	pngrio.$O \

+	pngrtran.$O \

+	pngrutil.$O \

+	pngset.$O \

+	pngtest.$O \

+	pngtrans.$O \

+	pngvcrd.$O \

+	pngwio.$O \

+	pngwrite.$O \

+	pngwtran.$O \

+	pngwutil.$O \

+</sys/src/cmd/mksyslib

--- /dev/null

+++ b/src/gfx/libpng/png.5.man

@@ -1,0 +1,74 @@

+.TH PNG 5 "December 3, 2004"

+.SH NAME

+png \- Portable Network Graphics (PNG) format

+.SH DESCRIPTION

+PNG (Portable Network Graphics) is an extensible file format for the

+lossless, portable, well-compressed storage of raster images. PNG provides

+a patent-free replacement for GIF and can also replace many

+common uses of TIFF. Indexed-color, grayscale, and truecolor images are

+supported, plus an optional alpha channel. Sample depths range from

+1 to 16 bits.

+.br

+PNG is designed to work well in online viewing applications, such as the

+World Wide Web, so it is fully streamable with a progressive display

+option. PNG is robust, providing both full file integrity checking and

+fast, simple detection of common transmission errors. Also, PNG can store

+gamma and chromaticity data for improved color matching on heterogeneous

+platforms.

+.SH "SEE ALSO"

+.IR libpng(3), zlib(3), deflate(5), and zlib(5)

+.LP

+PNG specification (second edition), November 2003:

+.IP

+.br

+  <http://www.w3.org/TR/2003/REC-PNG-20031110/

+PNG 1.2 specification, July 1999:

+.IP

+.br

+http://www.libpng.org/pub/png

+.LP

+PNG 1.0 specification, October 1996:

+.IP

+.br

+RFC 2083

+.IP

+.br

+ftp://ds.internic.net/rfc/rfc2083.txt

+.br

+or (as a W3C Recommendation) at

+.br

+http://www.w3.org/TR/REC-png.html

+.SH AUTHORS

+This man page: Glenn Randers-Pehrson

+.LP

+Portable Network Graphics (PNG) Specification (Second Edition)

+Information technology - Computer graphics and image processing -

+Portable Network Graphics (PNG): Functional specification.

+ISO/IEC 15948:2003 (E) (November 10, 2003): David Duce and others.

+.LP

+Portable Network Graphics (PNG) Specification Version 1.2 (July 8, 1999):

+Glenn Randers-Pehrson and others (png-list).

+.LP

+Portable Network Graphics (PNG) Specification Version 1.0 (October 1, 1996):

+Thomas Boutell and others (png-list).

+.LP

+.SH COPYRIGHT NOTICE

+.LP

+This man page is Copyright (c) 1998-2004 Glenn Randers-Pehrson.  See png.h

+for conditions of use and distribution.

+.LP

+The PNG Specification (Second Edition) is

+Copyright (c) 2003 W3C. (MIT, ERCIM, Keio), All Rights Reserved.

+.LP

+The PNG-1.2 specification is copyright (c) 1999 Glenn Randers-Pehrson.

+See the specification for conditions of use and distribution.

+.LP

+The PNG-1.0 specification is copyright (c) 1996 Massachusetts Institute of

+Technology.  See the specification for conditions of use and distribution.

+.LP

+.\" end of man page

--- /dev/null

+++ b/src/gfx/libpng/png.c

@@ -1,0 +1,828 @@

+/* png.c - location for general purpose libpng functions

+ *

+ * libpng version 1.2.8 - December 3, 2004

+ * For conditions of distribution and use, see copyright notice in png.h

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

+ */

+#define PNG_INTERNAL

+#define PNG_NO_EXTERN

+#include "png.h"

+/* Generate a compiler error if there is an old png.h in the search path. */

+typedef version_1_2_8 Your_png_h_is_not_version_1_2_8;

+/* Version information for C files.  This had better match the version

+ * string defined in png.h.  */

+#ifdef PNG_USE_GLOBAL_ARRAYS

+/* png_libpng_ver was changed to a function in version 1.0.5c */

+const char png_libpng_ver[18] = PNG_LIBPNG_VER_STRING;

+/* png_sig was changed to a function in version 1.0.5c */

+/* Place to hold the signature string for a PNG file. */

+const png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};

+/* Invoke global declarations for constant strings for known chunk types */

+PNG_IHDR;

+PNG_IDAT;

+PNG_IEND;

+PNG_PLTE;

+PNG_bKGD;

+PNG_cHRM;

+PNG_gAMA;

+PNG_hIST;

+PNG_iCCP;

+PNG_iTXt;

+PNG_oFFs;

+PNG_pCAL;

+PNG_sCAL;

+PNG_pHYs;

+PNG_sBIT;

+PNG_sPLT;

+PNG_sRGB;

+PNG_tEXt;

+PNG_tIME;

+PNG_tRNS;

+PNG_zTXt;

+/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */

+/* start of interlace block */

+const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};

+/* offset to next interlace block */

+const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};

+/* start of interlace block in the y direction */

+const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};

+/* offset to next interlace block in the y direction */

+const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};

+/* width of interlace block (used in assembler routines only) */

+#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW

+const int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1};

+#endif

+/* Height of interlace block.  This is not currently used - if you need

+ * it, uncomment it here and in png.h

+const int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};

+*/

+/* Mask to determine which pixels are valid in a pass */

+const int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};

+/* Mask to determine which pixels to overwrite while displaying */

+const int FARDATA png_pass_dsp_mask[]

+   = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};

+#endif /* PNG_USE_GLOBAL_ARRAYS */

+/* Tells libpng that we have already handled the first "num_bytes" bytes

+ * of the PNG file signature.  If the PNG data is embedded into another

+ * stream we can set num_bytes = 8 so that libpng will not attempt to read

+ * or write any of the magic bytes before it starts on the IHDR.

+ */

+void PNGAPI

+png_set_sig_bytes(png_structp png_ptr, int num_bytes)

+{

+   png_debug(1, "in png_set_sig_bytes\n");

+   if (num_bytes > 8)

+      png_error(png_ptr, "Too many bytes for PNG signature.");

+   png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);

+}

+/* Checks whether the supplied bytes match the PNG signature.  We allow

+ * checking less than the full 8-byte signature so that those apps that

+ * already read the first few bytes of a file to determine the file type

+ * can simply check the remaining bytes for extra assurance.  Returns

+ * an integer less than, equal to, or greater than zero if sig is found,

+ * respectively, to be less than, to match, or be greater than the correct

+ * PNG signature (this is the same behaviour as strcmp, memcmp, etc).

+ */

+int PNGAPI

+png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)

+{

+   png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};

+   if (num_to_check > 8)

+      num_to_check = 8;

+   else if (num_to_check < 1)

+      return (0);

+   if (start > 7)

+      return (0);

+   if (start + num_to_check > 8)

+      num_to_check = 8 - start;

+   return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));

+}

+/* (Obsolete) function to check signature bytes.  It does not allow one

+ * to check a partial signature.  This function might be removed in the

+ * future - use png_sig_cmp().  Returns true (nonzero) if the file is a PNG.

+ */

+int PNGAPI

+png_check_sig(png_bytep sig, int num)

+{

+  return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num));

+}

+/* Function to allocate memory for zlib and clear it to 0. */

+#ifdef PNG_1_0_X

+voidpf PNGAPI

+#else

+voidpf /* private */

+#endif

+png_zalloc(voidpf png_ptr, uInt items, uInt size)

+{

+   png_voidp ptr;

+   png_structp p=(void*)png_ptr;

+   png_uint_32 save_flags=p->flags;

+   png_uint_32 num_bytes;

+   if (items > PNG_UINT_32_MAX/size)

+   {

+     png_warning ((void*)png_ptr, "Potential overflow in png_zalloc()");

+     return (NULL);

+   }

+   num_bytes = (png_uint_32)items * size;

+   p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;

+   ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);

+   p->flags=save_flags;

+#if defined(PNG_1_0_X) && !defined(PNG_NO_ZALLOC_ZERO)

+   if (ptr == NULL)

+       return ((voidpf)ptr);

+   if (num_bytes > (png_uint_32)0x8000L)

+   {

+      png_memset(ptr, 0, (png_size_t)0x8000L);

+      png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,

+         (png_size_t)(num_bytes - (png_uint_32)0x8000L));

+   }

+   else

+   {

+      png_memset(ptr, 0, (png_size_t)num_bytes);

+   }

+#endif

+   return ((voidpf)ptr);

+}

+/* function to free memory for zlib */

+#ifdef PNG_1_0_X

+void PNGAPI

+#else

+void /* private */

+#endif

+png_zfree(voidpf png_ptr, voidpf ptr)

+{

+   png_free((png_structp)png_ptr, (png_voidp)ptr);

+}

+/* Reset the CRC variable to 32 bits of 1's.  Care must be taken

+ * in case CRC is > 32 bits to leave the top bits 0.

+ */

+void /* PRIVATE */

+png_reset_crc(png_structp png_ptr)

+{

+   png_ptr->crc = crc32(0, Z_NULL, 0);

+}

+/* Calculate the CRC over a section of data.  We can only pass as

+ * much data to this routine as the largest single buffer size.  We

+ * also check that this data will actually be used before going to the

+ * trouble of calculating it.

+ */

+void /* PRIVATE */

+png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)

+{

+   int need_crc = 1;

+   if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */

+   {

+      if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==

+          (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))

+         need_crc = 0;

+   }

+   else                                                    /* critical */

+   {

+      if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)

+         need_crc = 0;

+   }

+   if (need_crc)

+      png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);

+}

+/* Allocate the memory for an info_struct for the application.  We don't

+ * really need the png_ptr, but it could potentially be useful in the

+ * future.  This should be used in favour of malloc(png_sizeof(png_info))

+ * and png_info_init() so that applications that want to use a shared

+ * libpng don't have to be recompiled if png_info changes size.

+ */

+png_infop PNGAPI

+png_create_info_struct(png_structp png_ptr)

+{

+   png_infop info_ptr;

+   png_debug(1, "in png_create_info_struct\n");

+   if(png_ptr == NULL) return (NULL);

+#ifdef PNG_USER_MEM_SUPPORTED

+   info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,

+      png_ptr->malloc_fn, png_ptr->mem_ptr);

+#else

+   info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);

+#endif

+   if (info_ptr != NULL)

+      png_info_init_3(&info_ptr, png_sizeof(png_info));

+   return (info_ptr);

+}

+/* This function frees the memory associated with a single info struct.

+ * Normally, one would use either png_destroy_read_struct() or

+ * png_destroy_write_struct() to free an info struct, but this may be

+ * useful for some applications.

+ */

+void PNGAPI

+png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)

+{

+   png_infop info_ptr = NULL;

+   png_debug(1, "in png_destroy_info_struct\n");

+   if (info_ptr_ptr != NULL)

+      info_ptr = *info_ptr_ptr;

+   if (info_ptr != NULL)

+   {

+      png_info_destroy(png_ptr, info_ptr);

+#ifdef PNG_USER_MEM_SUPPORTED

+      png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,

+          png_ptr->mem_ptr);

+#else

+      png_destroy_struct((png_voidp)info_ptr);

+#endif

+      *info_ptr_ptr = NULL;

+   }

+}

+/* Initialize the info structure.  This is now an internal function (0.89)

+ * and applications using it are urged to use png_create_info_struct()

+ * instead.

+ */

+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)

+#undef png_info_init

+void PNGAPI

+png_info_init(png_infop info_ptr)

+{

+   /* We only come here via pre-1.0.12-compiled applications */

+   png_info_init_3(&info_ptr, 0);

+}

+#endif

+void PNGAPI

+png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)

+{

+   png_infop info_ptr = *ptr_ptr;

+   png_debug(1, "in png_info_init_3\n");

+   if(png_sizeof(png_info) > png_info_struct_size)

+     {

+       png_destroy_struct(info_ptr);

+       info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);

+       *ptr_ptr = info_ptr;

+     }

+   /* set everything to 0 */

+   png_memset(info_ptr, 0, png_sizeof (png_info));

+}

+#ifdef PNG_FREE_ME_SUPPORTED

+void PNGAPI

+png_data_freer(png_structp png_ptr, png_infop info_ptr,

+   int freer, png_uint_32 mask)

+{

+   png_debug(1, "in png_data_freer\n");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+   if(freer == PNG_DESTROY_WILL_FREE_DATA)

+      info_ptr->free_me |= mask;

+   else if(freer == PNG_USER_WILL_FREE_DATA)

+      info_ptr->free_me &= ~mask;

+   else

+      png_warning(png_ptr,

+         "Unknown freer parameter in png_data_freer.");

+}

+#endif

+void PNGAPI

+png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,

+   int num)

+{

+   png_debug(1, "in png_free_data\n");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+#if defined(PNG_TEXT_SUPPORTED)

+/* free text item num or (if num == -1) all text items */

+#ifdef PNG_FREE_ME_SUPPORTED

+if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)

+#else

+if (mask & PNG_FREE_TEXT)

+#endif

+{

+   if (num != -1)

+   {

+     if (info_ptr->text && info_ptr->text[num].key)

+     {

+         png_free(png_ptr, info_ptr->text[num].key);

+         info_ptr->text[num].key = NULL;

+     }

+   }

+   else

+   {

+       int i;

+       for (i = 0; i < info_ptr->num_text; i++)

+           png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);

+       png_free(png_ptr, info_ptr->text);

+       info_ptr->text = NULL;

+       info_ptr->num_text=0;

+   }

+}

+#endif

+#if defined(PNG_tRNS_SUPPORTED)

+/* free any tRNS entry */

+#ifdef PNG_FREE_ME_SUPPORTED

+if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)

+#else

+if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS))

+#endif

+{

+    png_free(png_ptr, info_ptr->trans);

+    info_ptr->valid &= ~PNG_INFO_tRNS;

+#ifndef PNG_FREE_ME_SUPPORTED

+    png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;

+#endif

+    info_ptr->trans = NULL;

+}

+#endif

+#if defined(PNG_sCAL_SUPPORTED)

+/* free any sCAL entry */

+#ifdef PNG_FREE_ME_SUPPORTED

+if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)

+#else

+if (mask & PNG_FREE_SCAL)

+#endif

+{

+#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)

+    png_free(png_ptr, info_ptr->scal_s_width);

+    png_free(png_ptr, info_ptr->scal_s_height);

+    info_ptr->scal_s_width = NULL;

+    info_ptr->scal_s_height = NULL;

+#endif

+    info_ptr->valid &= ~PNG_INFO_sCAL;

+}

+#endif

+#if defined(PNG_pCAL_SUPPORTED)

+/* free any pCAL entry */

+#ifdef PNG_FREE_ME_SUPPORTED

+if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)

+#else

+if (mask & PNG_FREE_PCAL)

+#endif

+{

+    png_free(png_ptr, info_ptr->pcal_purpose);

+    png_free(png_ptr, info_ptr->pcal_units);

+    info_ptr->pcal_purpose = NULL;

+    info_ptr->pcal_units = NULL;

+    if (info_ptr->pcal_params != NULL)

+    {

+        int i;

+        for (i = 0; i < (int)info_ptr->pcal_nparams; i++)

+        {

+          png_free(png_ptr, info_ptr->pcal_params[i]);

+          info_ptr->pcal_params[i]=NULL;

+        }

+        png_free(png_ptr, info_ptr->pcal_params);

+        info_ptr->pcal_params = NULL;

+    }

+    info_ptr->valid &= ~PNG_INFO_pCAL;

+}

+#endif

+#if defined(PNG_iCCP_SUPPORTED)

+/* free any iCCP entry */

+#ifdef PNG_FREE_ME_SUPPORTED

+if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)

+#else

+if (mask & PNG_FREE_ICCP)

+#endif

+{

+    png_free(png_ptr, info_ptr->iccp_name);

+    png_free(png_ptr, info_ptr->iccp_profile);

+    info_ptr->iccp_name = NULL;

+    info_ptr->iccp_profile = NULL;

+    info_ptr->valid &= ~PNG_INFO_iCCP;

+}

+#endif

+#if defined(PNG_sPLT_SUPPORTED)

+/* free a given sPLT entry, or (if num == -1) all sPLT entries */

+#ifdef PNG_FREE_ME_SUPPORTED

+if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)

+#else

+if (mask & PNG_FREE_SPLT)

+#endif

+{

+   if (num != -1)

+   {

+      if(info_ptr->splt_palettes)

+      {

+          png_free(png_ptr, info_ptr->splt_palettes[num].name);

+          png_free(png_ptr, info_ptr->splt_palettes[num].entries);

+          info_ptr->splt_palettes[num].name = NULL;

+          info_ptr->splt_palettes[num].entries = NULL;

+      }

+   }

+   else

+   {

+       if(info_ptr->splt_palettes_num)

+       {

+         int i;

+         for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)

+            png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);

+         png_free(png_ptr, info_ptr->splt_palettes);

+         info_ptr->splt_palettes = NULL;

+         info_ptr->splt_palettes_num = 0;

+       }

+       info_ptr->valid &= ~PNG_INFO_sPLT;

+   }

+}

+#endif

+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)

+#ifdef PNG_FREE_ME_SUPPORTED

+if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)

+#else

+if (mask & PNG_FREE_UNKN)

+#endif

+{

+   if (num != -1)

+   {

+       if(info_ptr->unknown_chunks)

+       {

+          png_free(png_ptr, info_ptr->unknown_chunks[num].data);

+          info_ptr->unknown_chunks[num].data = NULL;

+       }

+   }

+   else

+   {

+       int i;

+       if(info_ptr->unknown_chunks_num)

+       {

+         for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++)

+            png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);

+         png_free(png_ptr, info_ptr->unknown_chunks);

+         info_ptr->unknown_chunks = NULL;

+         info_ptr->unknown_chunks_num = 0;

+       }

+   }

+}

+#endif

+#if defined(PNG_hIST_SUPPORTED)

+/* free any hIST entry */

+#ifdef PNG_FREE_ME_SUPPORTED

+if ((mask & PNG_FREE_HIST)  & info_ptr->free_me)

+#else

+if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST))

+#endif

+{

+    png_free(png_ptr, info_ptr->hist);

+    info_ptr->hist = NULL;

+    info_ptr->valid &= ~PNG_INFO_hIST;

+#ifndef PNG_FREE_ME_SUPPORTED

+    png_ptr->flags &= ~PNG_FLAG_FREE_HIST;

+#endif

+}

+#endif

+/* free any PLTE entry that was internally allocated */

+#ifdef PNG_FREE_ME_SUPPORTED

+if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)

+#else

+if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE))

+#endif

+{

+    png_zfree((void*)png_ptr, (void*)info_ptr->palette);

+    info_ptr->palette = NULL;

+    info_ptr->valid &= ~PNG_INFO_PLTE;

+#ifndef PNG_FREE_ME_SUPPORTED

+    png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;

+#endif

+    info_ptr->num_palette = 0;

+}

+#if defined(PNG_INFO_IMAGE_SUPPORTED)

+/* free any image bits attached to the info structure */

+#ifdef PNG_FREE_ME_SUPPORTED

+if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)

+#else

+if (mask & PNG_FREE_ROWS)

+#endif

+{

+    if(info_ptr->row_pointers)

+    {

+       int row;

+       for (row = 0; row < (int)info_ptr->height; row++)

+       {

+          png_free(png_ptr, info_ptr->row_pointers[row]);

+          info_ptr->row_pointers[row]=NULL;

+       }

+       png_free(png_ptr, info_ptr->row_pointers);

+       info_ptr->row_pointers=NULL;

+    }

+    info_ptr->valid &= ~PNG_INFO_IDAT;

+}

+#endif

+#ifdef PNG_FREE_ME_SUPPORTED

+   if(num == -1)

+     info_ptr->free_me &= ~mask;

+   else

+     info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);

+#endif

+}

+/* This is an internal routine to free any memory that the info struct is

+ * pointing to before re-using it or freeing the struct itself.  Recall

+ * that png_free() checks for NULL pointers for us.

+ */

+void /* PRIVATE */

+png_info_destroy(png_structp png_ptr, png_infop info_ptr)

+{

+   png_debug(1, "in png_info_destroy\n");

+   png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);

+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)

+   if (png_ptr->num_chunk_list)

+   {

+       png_free(png_ptr, png_ptr->chunk_list);

+       png_ptr->chunk_list=NULL;

+       png_ptr->num_chunk_list=0;

+   }

+#endif

+   png_info_init_3(&info_ptr, png_sizeof(png_info));

+}

+/* This function returns a pointer to the io_ptr associated with the user

+ * functions.  The application should free any memory associated with this

+ * pointer before png_write_destroy() or png_read_destroy() are called.

+ */

+png_voidp PNGAPI

+png_get_io_ptr(png_structp png_ptr)

+{

+   return (png_ptr->io_ptr);

+}

+#if !defined(PNG_NO_STDIO)

+/* Initialize the default input/output functions for the PNG file.  If you

+ * use your own read or write routines, you can call either png_set_read_fn()

+ * or png_set_write_fn() instead of png_init_io().  If you have defined

+ * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't

+ * necessarily available.

+ */

+void PNGAPI

+png_init_io(png_structp png_ptr, png_FILE_p fp)

+{

+   png_debug(1, "in png_init_io\n");

+   png_ptr->io_ptr = (png_voidp)fp;

+}

+#endif

+#if defined(PNG_TIME_RFC1123_SUPPORTED)

+/* Convert the supplied time into an RFC 1123 string suitable for use in

+ * a "Creation Time" or other text-based time string.

+ */

+png_charp PNGAPI

+png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)

+{

+   static PNG_CONST char short_months[12][4] =

+        {"Jan", "Feb", "Mar", "Apr", "May", "Jun",

+         "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};

+   if (png_ptr->time_buffer == NULL)

+   {

+      png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*

+         png_sizeof(char)));

+   }

+#if defined(_WIN32_WCE)

+   {

+      wchar_t time_buf[29];

+      wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"),

+          ptime->day % 32, short_months[(ptime->month - 1) % 12],

+        ptime->year, ptime->hour % 24, ptime->minute % 60,

+          ptime->second % 61);

+      WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29,

+          NULL, NULL);

+   }

+#else

+#ifdef USE_FAR_KEYWORD

+   {

+      char near_time_buf[29];

+      sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000",

+          ptime->day % 32, short_months[(ptime->month - 1) % 12],

+          ptime->year, ptime->hour % 24, ptime->minute % 60,

+          ptime->second % 61);

+      png_memcpy(png_ptr->time_buffer, near_time_buf,

+          29*png_sizeof(char));

+   }

+#else

+   sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000",

+       ptime->day % 32, short_months[(ptime->month - 1) % 12],

+       ptime->year, ptime->hour % 24, ptime->minute % 60,

+       ptime->second % 61);

+#endif

+#endif /* _WIN32_WCE */

+   return ((png_charp)png_ptr->time_buffer);

+}

+#endif /* PNG_TIME_RFC1123_SUPPORTED */

+#if 0

+/* Signature string for a PNG file. */

+png_bytep PNGAPI

+png_sig_bytes(void)

+{

+   return ((png_bytep)"\211\120\116\107\015\012\032\012");

+}

+#endif

+png_charp PNGAPI

+png_get_copyright(png_structp png_ptr)

+{

+   if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */

+   return ((png_charp) "\n libpng version 1.2.8 - December 3, 2004\n\

+   Copyright (c) 1998-2004 Glenn Randers-Pehrson\n\

+   Copyright (c) 1996-1997 Andreas Dilger\n\

+   Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n");

+   return ((png_charp) "");

+}

+/* The following return the library version as a short string in the

+ * format 1.0.0 through 99.99.99zz.  To get the version of *.h files

+ * used with your application, print out PNG_LIBPNG_VER_STRING, which

+ * is defined in png.h.

+ * Note: now there is no difference between png_get_libpng_ver() and

+ * png_get_header_ver().  Due to the version_nn_nn_nn typedef guard,

+ * it is guaranteed that png.c uses the correct version of png.h.

+ */

+png_charp PNGAPI

+png_get_libpng_ver(png_structp png_ptr)

+{

+   /* Version of *.c files used when building libpng */

+   if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */

+      return ((png_charp) PNG_LIBPNG_VER_STRING);

+   return ((png_charp) "");

+}

+png_charp PNGAPI

+png_get_header_ver(png_structp png_ptr)

+{

+   /* Version of *.h files used when building libpng */

+   if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */

+      return ((png_charp) PNG_LIBPNG_VER_STRING);

+   return ((png_charp) "");

+}

+png_charp PNGAPI

+png_get_header_version(png_structp png_ptr)

+{

+   /* Returns longer string containing both version and date */

+   if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */

+      return ((png_charp) PNG_HEADER_VERSION_STRING);

+   return ((png_charp) "");

+}

+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

+int PNGAPI

+png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)

+{

+   /* check chunk_name and return "keep" value if it's on the list, else 0 */

+   int i;

+   png_bytep p;

+   if((png_ptr == NULL && chunk_name == NULL) || png_ptr->num_chunk_list<=0)

+      return 0;

+   p=png_ptr->chunk_list+png_ptr->num_chunk_list*5-5;

+   for (i = png_ptr->num_chunk_list; i; i--, p-=5)

+      if (!png_memcmp(chunk_name, p, 4))

+        return ((int)*(p+4));

+   return 0;

+}

+#endif

+/* This function, added to libpng-1.0.6g, is untested. */

+int PNGAPI

+png_reset_zstream(png_structp png_ptr)

+{

+   return (inflateReset(&png_ptr->zstream));

+}

+/* This function was added to libpng-1.0.7 */

+png_uint_32 PNGAPI

+png_access_version_number(void)

+{

+   /* Version of *.c files used when building libpng */

+   return((png_uint_32) PNG_LIBPNG_VER);

+}

+#if !defined(PNG_1_0_X)

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)

+    /* GRR:  could add this:   && defined(PNG_MMX_CODE_SUPPORTED) */

+/* this INTERNAL function was added to libpng 1.2.0 */

+void /* PRIVATE */

+png_init_mmx_flags (png_structp png_ptr)

+{

+    png_ptr->mmx_rowbytes_threshold = 0;

+    png_ptr->mmx_bitdepth_threshold = 0;

+#  if (defined(PNG_USE_PNGVCRD) || defined(PNG_USE_PNGGCCRD))

+    png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_COMPILED;

+    if (png_mmx_support() > 0) {

+        png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU

+#    ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW

+                              | PNG_ASM_FLAG_MMX_READ_COMBINE_ROW

+#    endif

+#    ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE

+                              | PNG_ASM_FLAG_MMX_READ_INTERLACE

+#    endif

+#    ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW

+                              ;

+#    else

+                              | PNG_ASM_FLAG_MMX_READ_FILTER_SUB

+                              | PNG_ASM_FLAG_MMX_READ_FILTER_UP

+                              | PNG_ASM_FLAG_MMX_READ_FILTER_AVG

+                              | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;

+        png_ptr->mmx_rowbytes_threshold = PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT;

+        png_ptr->mmx_bitdepth_threshold = PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT;

+#    endif

+    } else {

+        png_ptr->asm_flags &= ~( PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU

+                               | PNG_MMX_READ_FLAGS

+                               | PNG_MMX_WRITE_FLAGS );

+    }

+#  else /* !((PNGVCRD || PNGGCCRD) && PNG_ASSEMBLER_CODE_SUPPORTED)) */

+    /* clear all MMX flags; no support is compiled in */

+    png_ptr->asm_flags &= ~( PNG_MMX_FLAGS );

+#  endif /* ?(PNGVCRD || PNGGCCRD) */

+}

+#endif /* !(PNG_ASSEMBLER_CODE_SUPPORTED) */

+/* this function was added to libpng 1.2.0 */

+#if !defined(PNG_USE_PNGGCCRD) && \

+    !(defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD))

+int PNGAPI

+png_mmx_support(void)

+{

+    return -1;

+}

+#endif

+#endif /* PNG_1_0_X */

+#ifdef PNG_SIZE_T

+/* Added at libpng version 1.2.6 */

+   PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));

+png_size_t PNGAPI

+png_convert_size(size_t size)

+{

+  if (size > (png_size_t)-1)

+     PNG_ABORT();  /* We haven't got access to png_ptr, so no png_error() */

+  return ((png_size_t)size);

+}

+#endif /* PNG_SIZE_T */

--- /dev/null

+++ b/src/gfx/libpng/png.h

@@ -1,0 +1,3419 @@

+/* png.h - header file for PNG reference library

+ *

+ * libpng version 1.2.8 - December 3, 2004

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

+ *

+ * Authors and maintainers:

+ *  libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat

+ *  libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger

+ *  libpng versions 0.97, January 1998, through 1.2.8 - December 3, 2004: Glenn

+ *  See also "Contributing Authors", below.

+ *

+ * Note about libpng version numbers:

+ *

+ *    Due to various miscommunications, unforeseen code incompatibilities

+ *    and occasional factors outside the authors' control, version numbering

+ *    on the library has not always been consistent and straightforward.

+ *    The following table summarizes matters since version 0.89c, which was

+ *    the first widely used release:

+ *

+ *    source                 png.h  png.h  shared-lib

+ *    version                string   int  version

+ *    -------                ------ -----  ----------

+ *    0.89c "1.0 beta 3"     0.89      89  1.0.89

+ *    0.90  "1.0 beta 4"     0.90      90  0.90  [should have been 2.0.90]

+ *    0.95  "1.0 beta 5"     0.95      95  0.95  [should have been 2.0.95]

+ *    0.96  "1.0 beta 6"     0.96      96  0.96  [should have been 2.0.96]

+ *    0.97b "1.00.97 beta 7" 1.00.97   97  1.0.1 [should have been 2.0.97]

+ *    0.97c                  0.97      97  2.0.97

+ *    0.98                   0.98      98  2.0.98

+ *    0.99                   0.99      98  2.0.99

+ *    0.99a-m                0.99      99  2.0.99

+ *    1.00                   1.00     100  2.1.0 [100 should be 10000]

+ *    1.0.0      (from here on, the   100  2.1.0 [100 should be 10000]

+ *    1.0.1       png.h string is   10001  2.1.0

+ *    1.0.1a-e    identical to the  10002  from here on, the shared library

+ *    1.0.2       source version)   10002  is 2.V where V is the source code

+ *    1.0.2a-b                      10003  version, except as noted.

+ *    1.0.3                         10003

+ *    1.0.3a-d                      10004

+ *    1.0.4                         10004

+ *    1.0.4a-f                      10005

+ *    1.0.5 (+ 2 patches)           10005

+ *    1.0.5a-d                      10006

+ *    1.0.5e-r                      10100 (not source compatible)

+ *    1.0.5s-v                      10006 (not binary compatible)

+ *    1.0.6 (+ 3 patches)           10006 (still binary incompatible)

+ *    1.0.6d-f                      10007 (still binary incompatible)

+ *    1.0.6g                        10007

+ *    1.0.6h                        10007  10.6h (testing xy.z so-numbering)

+ *    1.0.6i                        10007  10.6i

+ *    1.0.6j                        10007  2.1.0.6j (incompatible with 1.0.0)

+ *    1.0.7beta11-14        DLLNUM  10007  2.1.0.7beta11-14 (binary compatible)

+ *    1.0.7beta15-18           1    10007  2.1.0.7beta15-18 (binary compatible)

+ *    1.0.7rc1-2               1    10007  2.1.0.7rc1-2 (binary compatible)

+ *    1.0.7                    1    10007  (still compatible)

+ *    1.0.8beta1-4             1    10008  2.1.0.8beta1-4

+ *    1.0.8rc1                 1    10008  2.1.0.8rc1

+ *    1.0.8                    1    10008  2.1.0.8

+ *    1.0.9beta1-6             1    10009  2.1.0.9beta1-6

+ *    1.0.9rc1                 1    10009  2.1.0.9rc1

+ *    1.0.9beta7-10            1    10009  2.1.0.9beta7-10

+ *    1.0.9rc2                 1    10009  2.1.0.9rc2

+ *    1.0.9                    1    10009  2.1.0.9

+ *    1.0.10beta1              1    10010  2.1.0.10beta1

+ *    1.0.10rc1                1    10010  2.1.0.10rc1

+ *    1.0.10                   1    10010  2.1.0.10

+ *    1.0.11beta1-3            1    10011  2.1.0.11beta1-3

+ *    1.0.11rc1                1    10011  2.1.0.11rc1

+ *    1.0.11                   1    10011  2.1.0.11

+ *    1.0.12beta1-2            2    10012  2.1.0.12beta1-2

+ *    1.0.12rc1                2    10012  2.1.0.12rc1

+ *    1.0.12                   2    10012  2.1.0.12

+ *    1.1.0a-f                 -    10100  2.1.1.0a-f (branch abandoned)

+ *    1.2.0beta1-2             2    10200  2.1.2.0beta1-2

+ *    1.2.0beta3-5             3    10200  3.1.2.0beta3-5

+ *    1.2.0rc1                 3    10200  3.1.2.0rc1

+ *    1.2.0                    3    10200  3.1.2.0

+ *    1.2.1beta1-4             3    10201  3.1.2.1beta1-4

+ *    1.2.1rc1-2               3    10201  3.1.2.1rc1-2

+ *    1.2.1                    3    10201  3.1.2.1

+ *    1.2.2beta1-6            12    10202  12.so.0.1.2.2beta1-6

+ *    1.0.13beta1             10    10013  10.so.0.1.0.13beta1

+ *    1.0.13rc1               10    10013  10.so.0.1.0.13rc1

+ *    1.2.2rc1                12    10202  12.so.0.1.2.2rc1

+ *    1.0.13                  10    10013  10.so.0.1.0.13

+ *    1.2.2                   12    10202  12.so.0.1.2.2

+ *    1.2.3rc1-6              12    10203  12.so.0.1.2.3rc1-6

+ *    1.2.3                   12    10203  12.so.0.1.2.3

+ *    1.2.4beta1-3            13    10204  12.so.0.1.2.4beta1-3

+ *    1.0.14rc1               13    10014  10.so.0.1.0.14rc1

+ *    1.2.4rc1                13    10204  12.so.0.1.2.4rc1

+ *    1.0.14                  10    10014  10.so.0.1.0.14

+ *    1.2.4                   13    10204  12.so.0.1.2.4

+ *    1.2.5beta1-2            13    10205  12.so.0.1.2.5beta1-2

+ *    1.0.15rc1-3             10    10015  10.so.0.1.0.15rc1-3

+ *    1.2.5rc1-3              13    10205  12.so.0.1.2.5rc1-3

+ *    1.0.15                  10    10015  10.so.0.1.0.15

+ *    1.2.5                   13    10205  12.so.0.1.2.5

+ *    1.2.6beta1-4            13    10206  12.so.0.1.2.6beta1-4

+ *    1.0.16                  10    10016  10.so.0.1.0.16

+ *    1.2.6                   13    10206  12.so.0.1.2.6

+ *    1.2.7beta1-2            13    10207  12.so.0.1.2.7beta1-2

+ *    1.0.17rc1               10    10017  12.so.0.1.0.17rc1

+ *    1.2.7rc1                13    10207  12.so.0.1.2.7rc1

+ *    1.0.17                  10    10017  12.so.0.1.0.17

+ *    1.2.7                   13    10207  12.so.0.1.2.7

+ *    1.2.8beta1-5            13    10208  12.so.0.1.2.8beta1-5

+ *    1.0.18rc1-5             10    10018  12.so.0.1.0.18rc1-5

+ *    1.2.8rc1-5              13    10208  12.so.0.1.2.8rc1-5

+ *    1.0.18                  10    10018  12.so.0.1.0.18

+ *    1.2.8                   13    10208  12.so.0.1.2.8

+ *

+ *    Henceforth the source version will match the shared-library major

+ *    and minor numbers; the shared-library major version number will be

+ *    used for changes in backward compatibility, as it is intended.  The

+ *    PNG_LIBPNG_VER macro, which is not used within libpng but is available

+ *    for applications, is an unsigned integer of the form xyyzz corresponding

+ *    to the source version x.y.z (leading zeros in y and z).  Beta versions

+ *    were given the previous public release number plus a letter, until

+ *    version 1.0.6j; from then on they were given the upcoming public

+ *    release number plus "betaNN" or "rcN".

+ *

+ *    Binary incompatibility exists only when applications make direct access

+ *    to the info_ptr or png_ptr members through png.h, and the compiled

+ *    application is loaded with a different version of the library.

+ *

+ *    DLLNUM will change each time there are forward or backward changes

+ *    in binary compatibility (e.g., when a new feature is added).

+ *

+ * See libpng.txt or libpng.3 for more information.  The PNG specification

+ * is available as a W3C Recommendation and as an ISO Specification,

+ * <http://www.w3.org/TR/2003/REC-PNG-20031110/

+ */

+/*

+ * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:

+ *

+ * If you modify libpng you may insert additional notices immediately following

+ * this sentence.

+ *

+ * libpng versions 1.2.6, August 15, 2004, through 1.2.8, December 3, 2004, are

+ * Copyright (c) 2004 Glenn Randers-Pehrson, and are

+ * distributed according to the same disclaimer and license as libpng-1.2.5

+ * with the following individual added to the list of Contributing Authors:

+ *

+ *    Cosmin Truta

+ *

+ * libpng versions 1.0.7, July 1, 2000, through 1.2.5, October 3, 2002, are

+ * Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are

+ * distributed according to the same disclaimer and license as libpng-1.0.6

+ * with the following individuals added to the list of Contributing Authors:

+ *

+ *    Simon-Pierre Cadieux

+ *    Eric S. Raymond

+ *    Gilles Vollant

+ *

+ * and with the following additions to the disclaimer:

+ *

+ *    There is no warranty against interference with your enjoyment of the

+ *    library or against infringement.  There is no warranty that our

+ *    efforts or the library will fulfill any of your particular purposes

+ *    or needs.  This library is provided with all faults, and the entire

+ *    risk of satisfactory quality, performance, accuracy, and effort is with

+ *    the user.

+ *

+ * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are

+ * Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson, and are

+ * distributed according to the same disclaimer and license as libpng-0.96,

+ * with the following individuals added to the list of Contributing Authors:

+ *

+ *    Tom Lane

+ *    Glenn Randers-Pehrson

+ *    Willem van Schaik

+ *

+ * libpng versions 0.89, June 1996, through 0.96, May 1997, are

+ * Copyright (c) 1996, 1997 Andreas Dilger

+ * Distributed according to the same disclaimer and license as libpng-0.88,

+ * with the following individuals added to the list of Contributing Authors:

+ *

+ *    John Bowler

+ *    Kevin Bracey

+ *    Sam Bushell

+ *    Magnus Holmgren

+ *    Greg Roelofs

+ *    Tom Tanner

+ *

+ * libpng versions 0.5, May 1995, through 0.88, January 1996, are

+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.

+ *

+ * For the purposes of this copyright and license, "Contributing Authors"

+ * is defined as the following set of individuals:

+ *

+ *    Andreas Dilger

+ *    Dave Martindale

+ *    Guy Eric Schalnat

+ *    Paul Schmidt

+ *    Tim Wegner

+ *

+ * The PNG Reference Library is supplied "AS IS".  The Contributing Authors

+ * and Group 42, Inc. disclaim all warranties, expressed or implied,

+ * including, without limitation, the warranties of merchantability and of

+ * fitness for any purpose.  The Contributing Authors and Group 42, Inc.

+ * assume no liability for direct, indirect, incidental, special, exemplary,

+ * or consequential damages, which may result from the use of the PNG

+ * Reference Library, even if advised of the possibility of such damage.

+ *

+ * Permission is hereby granted to use, copy, modify, and distribute this

+ * source code, or portions hereof, for any purpose, without fee, subject

+ * to the following restrictions:

+ *

+ * 1. The origin of this source code must not be misrepresented.

+ *

+ * 2. Altered versions must be plainly marked as such and

+ * must not be misrepresented as being the original source.

+ *

+ * 3. This Copyright notice may not be removed or altered from

+ *    any source or altered source distribution.

+ *

+ * The Contributing Authors and Group 42, Inc. specifically permit, without

+ * fee, and encourage the use of this source code as a component to

+ * supporting the PNG file format in commercial products.  If you use this

+ * source code in a product, acknowledgment is not required but would be

+ * appreciated.

+ */

+/*

+ * A "png_get_copyright" function is available, for convenient use in "about"

+ * boxes and the like:

+ *

+ * printf("%s",png_get_copyright(NULL));

+ *

+ * Also, the PNG logo (in PNG format, of course) is supplied in the

+ * files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).

+ */

+/*

+ * Libpng is OSI Certified Open Source Software.  OSI Certified is a

+ * certification mark of the Open Source Initiative.

+ */

+/*

+ * The contributing authors would like to thank all those who helped

+ * with testing, bug fixes, and patience.  This wouldn't have been

+ * possible without all of you.

+ *

+ * Thanks to Frank J. T. Wojcik for helping with the documentation.

+ */

+/*

+ * Y2K compliance in libpng:

+ * =========================

+ *

+ *    December 3, 2004

+ *

+ *    Since the PNG Development group is an ad-hoc body, we can't make

+ *    an official declaration.

+ *

+ *    This is your unofficial assurance that libpng from version 0.71 and

+ *    upward through 1.2.8 are Y2K compliant.  It is my belief that earlier

+ *    versions were also Y2K compliant.

+ *

+ *    Libpng only has three year fields.  One is a 2-byte unsigned integer

+ *    that will hold years up to 65535.  The other two hold the date in text

+ *    format, and will hold years up to 9999.

+ *

+ *    The integer is

+ *        "png_uint_16 year" in png_time_struct.

+ *

+ *    The strings are

+ *        "png_charp time_buffer" in png_struct and

+ *        "near_time_buffer", which is a local character string in png.c.

+ *

+ *    There are seven time-related functions:

+ *        png.c: png_convert_to_rfc_1123() in png.c

+ *          (formerly png_convert_to_rfc_1152() in error)

+ *        png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c

+ *        png_convert_from_time_t() in pngwrite.c

+ *        png_get_tIME() in pngget.c

+ *        png_handle_tIME() in pngrutil.c, called in pngread.c

+ *        png_set_tIME() in pngset.c

+ *        png_write_tIME() in pngwutil.c, called in pngwrite.c

+ *

+ *    All handle dates properly in a Y2K environment.  The

+ *    png_convert_from_time_t() function calls gmtime() to convert from system

+ *    clock time, which returns (year - 1900), which we properly convert to

+ *    the full 4-digit year.  There is a possibility that applications using

+ *    libpng are not passing 4-digit years into the png_convert_to_rfc_1123()

+ *    function, or that they are incorrectly passing only a 2-digit year

+ *    instead of "year - 1900" into the png_convert_from_struct_tm() function,

+ *    but this is not under our control.  The libpng documentation has always

+ *    stated that it works with 4-digit years, and the APIs have been

+ *    documented as such.

+ *

+ *    The tIME chunk itself is also Y2K compliant.  It uses a 2-byte unsigned

+ *    integer to hold the year, and can hold years as large as 65535.

+ *

+ *    zlib, upon which libpng depends, is also Y2K compliant.  It contains

+ *    no date-related code.

+ *

+ *       Glenn Randers-Pehrson

+ *       libpng maintainer

+ *       PNG Development Group

+ */

+#ifndef PNG_H

+#define PNG_H

+/* This is not the place to learn how to use libpng.  The file libpng.txt

+ * describes how to use libpng, and the file example.c summarizes it

+ * with some code on which to build.  This file is useful for looking

+ * at the actual function definitions and structure components.

+ */

+/* Version information for png.h - this should match the version in png.c */

+#define PNG_LIBPNG_VER_STRING "1.2.8"

+#define PNG_HEADER_VERSION_STRING \

+   " libpng version 1.2.8 - December 3, 2004 (header)\n"

+#define PNG_LIBPNG_VER_SONUM   0

+#define PNG_LIBPNG_VER_DLLNUM  13

+/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */

+#define PNG_LIBPNG_VER_MAJOR   1

+#define PNG_LIBPNG_VER_MINOR   2

+#define PNG_LIBPNG_VER_RELEASE 8

+/* This should match the numeric part of the final component of

+ * PNG_LIBPNG_VER_STRING, omitting any leading zero: */

+#define PNG_LIBPNG_VER_BUILD  0

+/* Release Status */

+#define PNG_LIBPNG_BUILD_ALPHA    1

+#define PNG_LIBPNG_BUILD_BETA     2

+#define PNG_LIBPNG_BUILD_RC       3

+#define PNG_LIBPNG_BUILD_STABLE   4

+#define PNG_LIBPNG_BUILD_RELEASE_STATUS_MASK 7

+/* Release-Specific Flags */

+#define PNG_LIBPNG_BUILD_PATCH    8 /* Can be OR'ed with

+                                       PNG_LIBPNG_BUILD_STABLE only */

+#define PNG_LIBPNG_BUILD_PRIVATE 16 /* Cannot be OR'ed with

+                                       PNG_LIBPNG_BUILD_SPECIAL */

+#define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with

+                                       PNG_LIBPNG_BUILD_PRIVATE */

+#define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_STABLE

+/* Careful here.  At one time, Guy wanted to use 082, but that would be octal.

+ * We must not include leading zeros.

+ * Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only

+ * version 1.0.0 was mis-numbered 100 instead of 10000).  From

+ * version 1.0.1 it's    xxyyzz, where x=major, y=minor, z=release */

+#define PNG_LIBPNG_VER 10208 /* 1.2.8 */

+#ifndef PNG_VERSION_INFO_ONLY

+/* include the compression library's header */

+#include "zlib.h"

+#endif

+/* include all user configurable info, including optional assembler routines */

+#include "pngconf.h"

+/*

+ * Added at libpng-1.2.8 */

+/* Ref MSDN: Private as priority over Special

+ * VS_FF_PRIVATEBUILD File *was not* built using standard release

+ * procedures. If this value is given, the StringFileInfo block must

+ * contain a PrivateBuild string.

+ *

+ * VS_FF_SPECIALBUILD File *was* built by the original company using

+ * standard release procedures but is a variation of the standard

+ * file of the same version number. If this value is given, the

+ * StringFileInfo block must contain a SpecialBuild string.

+ */

+#if defined(PNG_USER_PRIVATEBUILD)

+#  define PNG_LIBPNG_BUILD_TYPE PNG_LIBPNG_BUILD_BASE_TYPE | \

+          PNG_LIBPNG_BUILD_PRIVATE

+#else

+#  if defined(PNG_LIBPNG_SPECIALBUILD)

+#    define PNG_LIBPNG_BUILD_TYPE PNG_LIBPNG_BUILD_BASE_TYPE | \

+            PNG_LIBPNG_BUILD_SPECIAL

+#  else

+#    define PNG_LIBPNG_BUILD_TYPE PNG_LIBPNG_BUILD_BASE_TYPE

+#  endif

+#endif

+#ifndef PNG_VERSION_INFO_ONLY

+/* Inhibit C++ name-mangling for libpng functions but not for system calls. */

+#ifdef __cplusplus

+extern "C" {

+#endif /* __cplusplus */

+/* This file is arranged in several sections.  The first section contains

+ * structure and type definitions.  The second section contains the external

+ * library functions, while the third has the internal library functions,

+ * which applications aren't expected to use directly.

+ */

+#ifndef PNG_NO_TYPECAST_NULL

+#define int_p_NULL                (int *)NULL

+#define png_bytep_NULL            (png_bytep)NULL

+#define png_bytepp_NULL           (png_bytepp)NULL

+#define png_doublep_NULL          (png_doublep)NULL

+#define png_error_ptr_NULL        (png_error_ptr)NULL

+#define png_flush_ptr_NULL        (png_flush_ptr)NULL

+#define png_free_ptr_NULL         (png_free_ptr)NULL

+#define png_infopp_NULL           (png_infopp)NULL

+#define png_malloc_ptr_NULL       (png_malloc_ptr)NULL

+#define png_read_status_ptr_NULL  (png_read_status_ptr)NULL

+#define png_rw_ptr_NULL           (png_rw_ptr)NULL

+#define png_structp_NULL          (png_structp)NULL

+#define png_uint_16p_NULL         (png_uint_16p)NULL

+#define png_voidp_NULL            (png_voidp)NULL

+#define png_write_status_ptr_NULL (png_write_status_ptr)NULL

+#else

+#define int_p_NULL                NULL

+#define png_bytep_NULL            NULL

+#define png_bytepp_NULL           NULL

+#define png_doublep_NULL          NULL

+#define png_error_ptr_NULL        NULL

+#define png_flush_ptr_NULL        NULL

+#define png_free_ptr_NULL         NULL

+#define png_infopp_NULL           NULL

+#define png_malloc_ptr_NULL       NULL

+#define png_read_status_ptr_NULL  NULL

+#define png_rw_ptr_NULL           NULL

+#define png_structp_NULL          NULL

+#define png_uint_16p_NULL         NULL

+#define png_voidp_NULL            NULL

+#define png_write_status_ptr_NULL NULL

+#endif

+/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */

+#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN)

+/* Version information for C files, stored in png.c.  This had better match

+ * the version above.

+ */

+#ifdef PNG_USE_GLOBAL_ARRAYS

+PNG_EXPORT_VAR (const char) png_libpng_ver[18];

+  /* need room for 99.99.99beta99z */

+#else

+#define png_libpng_ver png_get_header_ver(NULL)

+#endif

+#ifdef PNG_USE_GLOBAL_ARRAYS

+/* This was removed in version 1.0.5c */

+/* Structures to facilitate easy interlacing.  See png.c for more details */

+PNG_EXPORT_VAR (const int FARDATA) png_pass_start[7];

+PNG_EXPORT_VAR (const int FARDATA) png_pass_inc[7];

+PNG_EXPORT_VAR (const int FARDATA) png_pass_ystart[7];

+PNG_EXPORT_VAR (const int FARDATA) png_pass_yinc[7];

+PNG_EXPORT_VAR (const int FARDATA) png_pass_mask[7];

+PNG_EXPORT_VAR (const int FARDATA) png_pass_dsp_mask[7];

+#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW

+PNG_EXPORT_VAR (const int FARDATA) png_pass_width[7];

+#endif

+/* This isn't currently used.  If you need it, see png.c for more details.

+PNG_EXPORT_VAR (const int FARDATA) png_pass_height[7];

+*/

+#endif

+#endif /* PNG_NO_EXTERN */

+/* Three color definitions.  The order of the red, green, and blue, (and the

+ * exact size) is not important, although the size of the fields need to

+ * be png_byte or png_uint_16 (as defined below).

+ */

+typedef struct png_color_struct

+{

+   png_byte red;

+   png_byte green;

+   png_byte blue;

+} png_color;

+typedef png_color FAR * png_colorp;

+typedef png_color FAR * FAR * png_colorpp;

+typedef struct png_color_16_struct

+{

+   png_byte index;    /* used for palette files */

+   png_uint_16 red;   /* for use in red green blue files */

+   png_uint_16 green;

+   png_uint_16 blue;

+   png_uint_16 gray;  /* for use in grayscale files */

+} png_color_16;

+typedef png_color_16 FAR * png_color_16p;

+typedef png_color_16 FAR * FAR * png_color_16pp;

+typedef struct png_color_8_struct

+{

+   png_byte red;   /* for use in red green blue files */

+   png_byte green;

+   png_byte blue;

+   png_byte gray;  /* for use in grayscale files */

+   png_byte alpha; /* for alpha channel files */

+} png_color_8;

+typedef png_color_8 FAR * png_color_8p;

+typedef png_color_8 FAR * FAR * png_color_8pp;

+/*

+ * The following two structures are used for the in-core representation

+ * of sPLT chunks.

+ */

+typedef struct png_sPLT_entry_struct

+{

+   png_uint_16 red;

+   png_uint_16 green;

+   png_uint_16 blue;

+   png_uint_16 alpha;

+   png_uint_16 frequency;

+} png_sPLT_entry;

+typedef png_sPLT_entry FAR * png_sPLT_entryp;

+typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp;

+/*  When the depth of the sPLT palette is 8 bits, the color and alpha samples

+ *  occupy the LSB of their respective members, and the MSB of each member

+ *  is zero-filled.  The frequency member always occupies the full 16 bits.

+ */

+typedef struct png_sPLT_struct

+{

+   png_charp name;           /* palette name */

+   png_byte depth;           /* depth of palette samples */

+   png_sPLT_entryp entries;  /* palette entries */

+   png_int_32 nentries;      /* number of palette entries */

+} png_sPLT_t;

+typedef png_sPLT_t FAR * png_sPLT_tp;

+typedef png_sPLT_t FAR * FAR * png_sPLT_tpp;

+#ifdef PNG_TEXT_SUPPORTED

+/* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file,

+ * and whether that contents is compressed or not.  The "key" field

+ * points to a regular zero-terminated C string.  The "text", "lang", and

+ * "lang_key" fields can be regular C strings, empty strings, or NULL pointers.

+ * However, the * structure returned by png_get_text() will always contain

+ * regular zero-terminated C strings (possibly empty), never NULL pointers,

+ * so they can be safely used in printf() and other string-handling functions.

+ */

+typedef struct png_text_struct

+{

+   int  compression;       /* compression value:

+                             -1: tEXt, none

+                              0: zTXt, deflate

+                              1: iTXt, none

+                              2: iTXt, deflate  */

+   png_charp key;          /* keyword, 1-79 character description of "text" */

+   png_charp text;         /* comment, may be an empty string (ie "")

+                              or a NULL pointer */

+   png_size_t text_length; /* length of the text string */

+#ifdef PNG_iTXt_SUPPORTED

+   png_size_t itxt_length; /* length of the itxt string */

+   png_charp lang;         /* language code, 0-79 characters

+                              or a NULL pointer */

+   png_charp lang_key;     /* keyword translated UTF-8 string, 0 or more

+                              chars or a NULL pointer */

+#endif

+} png_text;

+typedef png_text FAR * png_textp;

+typedef png_text FAR * FAR * png_textpp;

+#endif

+/* Supported compression types for text in PNG files (tEXt, and zTXt).

+ * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */

+#define PNG_TEXT_COMPRESSION_NONE_WR -3

+#define PNG_TEXT_COMPRESSION_zTXt_WR -2

+#define PNG_TEXT_COMPRESSION_NONE    -1

+#define PNG_TEXT_COMPRESSION_zTXt     0

+#define PNG_ITXT_COMPRESSION_NONE     1

+#define PNG_ITXT_COMPRESSION_zTXt     2

+#define PNG_TEXT_COMPRESSION_LAST     3  /* Not a valid value */

+/* png_time is a way to hold the time in an machine independent way.

+ * Two conversions are provided, both from time_t and struct tm.  There

+ * is no portable way to convert to either of these structures, as far

+ * as I know.  If you know of a portable way, send it to me.  As a side

+ * note - PNG has always been Year 2000 compliant!

+ */

+typedef struct png_time_struct

+{

+   png_uint_16 year; /* full year, as in, 1995 */

+   png_byte month;   /* month of year, 1 - 12 */

+   png_byte day;     /* day of month, 1 - 31 */

+   png_byte hour;    /* hour of day, 0 - 23 */

+   png_byte minute;  /* minute of hour, 0 - 59 */

+   png_byte second;  /* second of minute, 0 - 60 (for leap seconds) */

+} png_time;

+typedef png_time FAR * png_timep;

+typedef png_time FAR * FAR * png_timepp;

+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)

+/* png_unknown_chunk is a structure to hold queued chunks for which there is

+ * no specific support.  The idea is that we can use this to queue

+ * up private chunks for output even though the library doesn't actually

+ * know about their semantics.

+ */

+typedef struct png_unknown_chunk_t

+{

+    png_byte name[5];

+    png_byte *data;

+    png_size_t size;

+    /* libpng-using applications should NOT directly modify this byte. */

+    png_byte location; /* mode of operation at read time */

+}

+png_unknown_chunk;

+typedef png_unknown_chunk FAR * png_unknown_chunkp;

+typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp;

+#endif

+/* png_info is a structure that holds the information in a PNG file so

+ * that the application can find out the characteristics of the image.

+ * If you are reading the file, this structure will tell you what is

+ * in the PNG file.  If you are writing the file, fill in the information

+ * you want to put into the PNG file, then call png_write_info().

+ * The names chosen should be very close to the PNG specification, so

+ * consult that document for information about the meaning of each field.

+ *

+ * With libpng < 0.95, it was only possible to directly set and read the

+ * the values in the png_info_struct, which meant that the contents and

+ * order of the values had to remain fixed.  With libpng 0.95 and later,

+ * however, there are now functions that abstract the contents of

+ * png_info_struct from the application, so this makes it easier to use

+ * libpng with dynamic libraries, and even makes it possible to use

+ * libraries that don't have all of the libpng ancillary chunk-handing

+ * functionality.

+ *

+ * In any case, the order of the parameters in png_info_struct should NOT

+ * be changed for as long as possible to keep compatibility with applications

+ * that use the old direct-access method with png_info_struct.

+ *

+ * The following members may have allocated storage attached that should be

+ * cleaned up before the structure is discarded: palette, trans, text,

+ * pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile,

+ * splt_palettes, scal_unit, row_pointers, and unknowns.   By default, these

+ * are automatically freed when the info structure is deallocated, if they were

+ * allocated internally by libpng.  This behavior can be changed by means

+ * of the png_data_freer() function.

+ *

+ * More allocation details: all the chunk-reading functions that

+ * change these members go through the corresponding png_set_*

+ * functions.  A function to clear these members is available: see

+ * png_free_data().  The png_set_* functions do not depend on being

+ * able to point info structure members to any of the storage they are

+ * passed (they make their own copies), EXCEPT that the png_set_text

+ * functions use the same storage passed to them in the text_ptr or

+ * itxt_ptr structure argument, and the png_set_rows and png_set_unknowns

+ * functions do not make their own copies.

+ */

+typedef struct png_info_struct

+{

+   /* the following are necessary for every PNG file */

+   png_uint_32 width;       /* width of image in pixels (from IHDR) */

+   png_uint_32 height;      /* height of image in pixels (from IHDR) */

+   png_uint_32 valid;       /* valid chunk data (see PNG_INFO_ below) */

+   png_uint_32 rowbytes;    /* bytes needed to hold an untransformed row */

+   png_colorp palette;      /* array of color values (valid & PNG_INFO_PLTE) */

+   png_uint_16 num_palette; /* number of color entries in "palette" (PLTE) */

+   png_uint_16 num_trans;   /* number of transparent palette color (tRNS) */

+   png_byte bit_depth;      /* 1, 2, 4, 8, or 16 bits/channel (from IHDR) */

+   png_byte color_type;     /* see PNG_COLOR_TYPE_ below (from IHDR) */

+   /* The following three should have been named *_method not *_type */

+   png_byte compression_type; /* must be PNG_COMPRESSION_TYPE_BASE (IHDR) */

+   png_byte filter_type;    /* must be PNG_FILTER_TYPE_BASE (from IHDR) */

+   png_byte interlace_type; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */

+   /* The following is informational only on read, and not used on writes. */

+   png_byte channels;       /* number of data channels per pixel (1, 2, 3, 4) */

+   png_byte pixel_depth;    /* number of bits per pixel */

+   png_byte spare_byte;     /* to align the data, and for future use */

+   png_byte signature[8];   /* magic bytes read by libpng from start of file */

+   /* The rest of the data is optional.  If you are reading, check the

+    * valid field to see if the information in these are valid.  If you

+    * are writing, set the valid field to those chunks you want written,

+    * and initialize the appropriate fields below.

+    */

+#if defined(PNG_gAMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)

+   /* The gAMA chunk describes the gamma characteristics of the system

+    * on which the image was created, normally in the range [1.0, 2.5].

+    * Data is valid if (valid & PNG_INFO_gAMA) is non-zero.

+    */

+   float gamma; /* gamma value of image, if (valid & PNG_INFO_gAMA) */

+#endif

+#if defined(PNG_sRGB_SUPPORTED)

+    /* GR-P, 0.96a */

+    /* Data valid if (valid & PNG_INFO_sRGB) non-zero. */

+   png_byte srgb_intent; /* sRGB rendering intent [0, 1, 2, or 3] */

+#endif

+#if defined(PNG_TEXT_SUPPORTED)

+   /* The tEXt, and zTXt chunks contain human-readable textual data in

+    * uncompressed, compressed, and optionally compressed forms, respectively.

+    * The data in "text" is an array of pointers to uncompressed,

+    * null-terminated C strings. Each chunk has a keyword that describes the

+    * textual data contained in that chunk.  Keywords are not required to be

+    * unique, and the text string may be empty.  Any number of text chunks may

+    * be in an image.

+    */

+   int num_text; /* number of comments read/to write */

+   int max_text; /* current size of text array */

+   png_textp text; /* array of comments read/to write */

+#endif /* PNG_TEXT_SUPPORTED */

+#if defined(PNG_tIME_SUPPORTED)

+   /* The tIME chunk holds the last time the displayed image data was

+    * modified.  See the png_time struct for the contents of this struct.

+    */

+   png_time mod_time;

+#endif

+#if defined(PNG_sBIT_SUPPORTED)

+   /* The sBIT chunk specifies the number of significant high-order bits

+    * in the pixel data.  Values are in the range [1, bit_depth], and are

+    * only specified for the channels in the pixel data.  The contents of

+    * the low-order bits is not specified.  Data is valid if

+    * (valid & PNG_INFO_sBIT) is non-zero.

+    */

+   png_color_8 sig_bit; /* significant bits in color channels */

+#endif

+#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_EXPAND_SUPPORTED) || \

+defined(PNG_READ_BACKGROUND_SUPPORTED)

+   /* The tRNS chunk supplies transparency data for paletted images and

+    * other image types that don't need a full alpha channel.  There are

+    * "num_trans" transparency values for a paletted image, stored in the

+    * same order as the palette colors, starting from index 0.  Values

+    * for the data are in the range [0, 255], ranging from fully transparent

+    * to fully opaque, respectively.  For non-paletted images, there is a

+    * single color specified that should be treated as fully transparent.

+    * Data is valid if (valid & PNG_INFO_tRNS) is non-zero.

+    */

+   png_bytep trans; /* transparent values for paletted image */

+   png_color_16 trans_values; /* transparent color for non-palette image */

+#endif

+#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

+   /* The bKGD chunk gives the suggested image background color if the

+    * display program does not have its own background color and the image

+    * is needs to composited onto a background before display.  The colors

+    * in "background" are normally in the same color space/depth as the

+    * pixel data.  Data is valid if (valid & PNG_INFO_bKGD) is non-zero.

+    */

+   png_color_16 background;

+#endif

+#if defined(PNG_oFFs_SUPPORTED)

+   /* The oFFs chunk gives the offset in "offset_unit_type" units rightwards

+    * and downwards from the top-left corner of the display, page, or other

+    * application-specific co-ordinate space.  See the PNG_OFFSET_ defines

+    * below for the unit types.  Valid if (valid & PNG_INFO_oFFs) non-zero.

+    */

+   png_int_32 x_offset; /* x offset on page */

+   png_int_32 y_offset; /* y offset on page */

+   png_byte offset_unit_type; /* offset units type */

+#endif

+#if defined(PNG_pHYs_SUPPORTED)

+   /* The pHYs chunk gives the physical pixel density of the image for

+    * display or printing in "phys_unit_type" units (see PNG_RESOLUTION_

+    * defines below).  Data is valid if (valid & PNG_INFO_pHYs) is non-zero.

+    */

+   png_uint_32 x_pixels_per_unit; /* horizontal pixel density */

+   png_uint_32 y_pixels_per_unit; /* vertical pixel density */

+   png_byte phys_unit_type; /* resolution type (see PNG_RESOLUTION_ below) */

+#endif

+#if defined(PNG_hIST_SUPPORTED)

+   /* The hIST chunk contains the relative frequency or importance of the

+    * various palette entries, so that a viewer can intelligently select a

+    * reduced-color palette, if required.  Data is an array of "num_palette"

+    * values in the range [0,65535]. Data valid if (valid & PNG_INFO_hIST)

+    * is non-zero.

+    */

+   png_uint_16p hist;

+#endif

+#ifdef PNG_cHRM_SUPPORTED

+   /* The cHRM chunk describes the CIE color characteristics of the monitor

+    * on which the PNG was created.  This data allows the viewer to do gamut

+    * mapping of the input image to ensure that the viewer sees the same

+    * colors in the image as the creator.  Values are in the range

+    * [0.0, 0.8].  Data valid if (valid & PNG_INFO_cHRM) non-zero.

+    */

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+   float x_white;

+   float y_white;

+   float x_red;

+   float y_red;

+   float x_green;

+   float y_green;

+   float x_blue;

+   float y_blue;

+#endif

+#endif

+#if defined(PNG_pCAL_SUPPORTED)

+   /* The pCAL chunk describes a transformation between the stored pixel

+    * values and original physical data values used to create the image.

+    * The integer range [0, 2^bit_depth - 1] maps to the floating-point

+    * range given by [pcal_X0, pcal_X1], and are further transformed by a

+    * (possibly non-linear) transformation function given by "pcal_type"

+    * and "pcal_params" into "pcal_units".  Please see the PNG_EQUATION_

+    * defines below, and the PNG-Group's PNG extensions document for a

+    * complete description of the transformations and how they should be

+    * implemented, and for a description of the ASCII parameter strings.

+    * Data values are valid if (valid & PNG_INFO_pCAL) non-zero.

+    */

+   png_charp pcal_purpose;  /* pCAL chunk description string */

+   png_int_32 pcal_X0;      /* minimum value */

+   png_int_32 pcal_X1;      /* maximum value */

+   png_charp pcal_units;    /* Latin-1 string giving physical units */

+   png_charpp pcal_params;  /* ASCII strings containing parameter values */

+   png_byte pcal_type;      /* equation type (see PNG_EQUATION_ below) */

+   png_byte pcal_nparams;   /* number of parameters given in pcal_params */

+#endif

+/* New members added in libpng-1.0.6 */

+#ifdef PNG_FREE_ME_SUPPORTED

+   png_uint_32 free_me;     /* flags items libpng is responsible for freeing */

+#endif

+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)

+   /* storage for unknown chunks that the library doesn't recognize. */

+   png_unknown_chunkp unknown_chunks;

+   png_size_t unknown_chunks_num;

+#endif

+#if defined(PNG_iCCP_SUPPORTED)

+   /* iCCP chunk data. */

+   png_charp iccp_name;     /* profile name */

+   png_charp iccp_profile;  /* International Color Consortium profile data */

+                            /* Note to maintainer: should be png_bytep */

+   png_uint_32 iccp_proflen;  /* ICC profile data length */

+   png_byte iccp_compression; /* Always zero */

+#endif

+#if defined(PNG_sPLT_SUPPORTED)

+   /* data on sPLT chunks (there may be more than one). */

+   png_sPLT_tp splt_palettes;

+   png_uint_32 splt_palettes_num;

+#endif

+#if defined(PNG_sCAL_SUPPORTED)

+   /* The sCAL chunk describes the actual physical dimensions of the

+    * subject matter of the graphic.  The chunk contains a unit specification

+    * a byte value, and two ASCII strings representing floating-point

+    * values.  The values are width and height corresponsing to one pixel

+    * in the image.  This external representation is converted to double

+    * here.  Data values are valid if (valid & PNG_INFO_sCAL) is non-zero.

+    */

+   png_byte scal_unit;         /* unit of physical scale */

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+   double scal_pixel_width;    /* width of one pixel */

+   double scal_pixel_height;   /* height of one pixel */

+#endif

+#ifdef PNG_FIXED_POINT_SUPPORTED

+   png_charp scal_s_width;     /* string containing height */

+   png_charp scal_s_height;    /* string containing width */

+#endif

+#endif

+#if defined(PNG_INFO_IMAGE_SUPPORTED)

+   /* Memory has been allocated if (valid & PNG_ALLOCATED_INFO_ROWS) non-zero */

+   /* Data valid if (valid & PNG_INFO_IDAT) non-zero */

+   png_bytepp row_pointers;        /* the image bits */

+#endif

+#if defined(PNG_FIXED_POINT_SUPPORTED) && defined(PNG_gAMA_SUPPORTED)

+   png_fixed_point int_gamma; /* gamma of image, if (valid & PNG_INFO_gAMA) */

+#endif

+#if defined(PNG_cHRM_SUPPORTED) && defined(PNG_FIXED_POINT_SUPPORTED)

+   png_fixed_point int_x_white;

+   png_fixed_point int_y_white;

+   png_fixed_point int_x_red;

+   png_fixed_point int_y_red;

+   png_fixed_point int_x_green;

+   png_fixed_point int_y_green;

+   png_fixed_point int_x_blue;

+   png_fixed_point int_y_blue;

+#endif

+} png_info;

+typedef png_info FAR * png_infop;

+typedef png_info FAR * FAR * png_infopp;

+/* Maximum positive integer used in PNG is (2^31)-1 */

+#define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL)

+#define PNG_UINT_32_MAX ((png_uint_32)(-1))

+#define PNG_SIZE_MAX ((png_size_t)(-1))

+/* PNG_MAX_UINT is deprecated; use PNG_UINT_31_MAX instead. */

+#define PNG_MAX_UINT PNG_UINT_31_MAX

+/* These describe the color_type field in png_info. */

+/* color type masks */

+#define PNG_COLOR_MASK_PALETTE    1

+#define PNG_COLOR_MASK_COLOR      2

+#define PNG_COLOR_MASK_ALPHA      4

+/* color types.  Note that not all combinations are legal */

+#define PNG_COLOR_TYPE_GRAY 0

+#define PNG_COLOR_TYPE_PALETTE  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)

+#define PNG_COLOR_TYPE_RGB        (PNG_COLOR_MASK_COLOR)

+#define PNG_COLOR_TYPE_RGB_ALPHA  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)

+#define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA)

+/* aliases */

+#define PNG_COLOR_TYPE_RGBA  PNG_COLOR_TYPE_RGB_ALPHA

+#define PNG_COLOR_TYPE_GA  PNG_COLOR_TYPE_GRAY_ALPHA

+/* This is for compression type. PNG 1.0-1.2 only define the single type. */

+#define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */

+#define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE

+/* This is for filter type. PNG 1.0-1.2 only define the single type. */

+#define PNG_FILTER_TYPE_BASE      0 /* Single row per-byte filtering */

+#define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */

+#define PNG_FILTER_TYPE_DEFAULT   PNG_FILTER_TYPE_BASE

+/* These are for the interlacing type.  These values should NOT be changed. */

+#define PNG_INTERLACE_NONE        0 /* Non-interlaced image */

+#define PNG_INTERLACE_ADAM7       1 /* Adam7 interlacing */

+#define PNG_INTERLACE_LAST        2 /* Not a valid value */

+/* These are for the oFFs chunk.  These values should NOT be changed. */

+#define PNG_OFFSET_PIXEL          0 /* Offset in pixels */

+#define PNG_OFFSET_MICROMETER     1 /* Offset in micrometers (1/10^6 meter) */

+#define PNG_OFFSET_LAST           2 /* Not a valid value */

+/* These are for the pCAL chunk.  These values should NOT be changed. */

+#define PNG_EQUATION_LINEAR       0 /* Linear transformation */

+#define PNG_EQUATION_BASE_E       1 /* Exponential base e transform */

+#define PNG_EQUATION_ARBITRARY    2 /* Arbitrary base exponential transform */

+#define PNG_EQUATION_HYPERBOLIC   3 /* Hyperbolic sine transformation */

+#define PNG_EQUATION_LAST         4 /* Not a valid value */

+/* These are for the sCAL chunk.  These values should NOT be changed. */

+#define PNG_SCALE_UNKNOWN         0 /* unknown unit (image scale) */

+#define PNG_SCALE_METER           1 /* meters per pixel */

+#define PNG_SCALE_RADIAN          2 /* radians per pixel */

+#define PNG_SCALE_LAST            3 /* Not a valid value */

+/* These are for the pHYs chunk.  These values should NOT be changed. */

+#define PNG_RESOLUTION_UNKNOWN    0 /* pixels/unknown unit (aspect ratio) */

+#define PNG_RESOLUTION_METER      1 /* pixels/meter */

+#define PNG_RESOLUTION_LAST       2 /* Not a valid value */

+/* These are for the sRGB chunk.  These values should NOT be changed. */

+#define PNG_sRGB_INTENT_PERCEPTUAL 0

+#define PNG_sRGB_INTENT_RELATIVE   1

+#define PNG_sRGB_INTENT_SATURATION 2

+#define PNG_sRGB_INTENT_ABSOLUTE   3

+#define PNG_sRGB_INTENT_LAST       4 /* Not a valid value */

+/* This is for text chunks */

+#define PNG_KEYWORD_MAX_LENGTH     79

+/* Maximum number of entries in PLTE/sPLT/tRNS arrays */

+#define PNG_MAX_PALETTE_LENGTH    256

+/* These determine if an ancillary chunk's data has been successfully read

+ * from the PNG header, or if the application has filled in the corresponding

+ * data in the info_struct to be written into the output file.  The values

+ * of the PNG_INFO_<chunk> defines should NOT be changed.

+ */

+#define PNG_INFO_gAMA 0x0001

+#define PNG_INFO_sBIT 0x0002

+#define PNG_INFO_cHRM 0x0004

+#define PNG_INFO_PLTE 0x0008

+#define PNG_INFO_tRNS 0x0010

+#define PNG_INFO_bKGD 0x0020

+#define PNG_INFO_hIST 0x0040

+#define PNG_INFO_pHYs 0x0080

+#define PNG_INFO_oFFs 0x0100

+#define PNG_INFO_tIME 0x0200

+#define PNG_INFO_pCAL 0x0400

+#define PNG_INFO_sRGB 0x0800   /* GR-P, 0.96a */

+#define PNG_INFO_iCCP 0x1000   /* ESR, 1.0.6 */

+#define PNG_INFO_sPLT 0x2000   /* ESR, 1.0.6 */

+#define PNG_INFO_sCAL 0x4000   /* ESR, 1.0.6 */

+#define PNG_INFO_IDAT 0x8000L  /* ESR, 1.0.6 */

+/* This is used for the transformation routines, as some of them

+ * change these values for the row.  It also should enable using

+ * the routines for other purposes.

+ */

+typedef struct png_row_info_struct

+{

+   png_uint_32 width; /* width of row */

+   png_uint_32 rowbytes; /* number of bytes in row */

+   png_byte color_type; /* color type of row */

+   png_byte bit_depth; /* bit depth of row */

+   png_byte channels; /* number of channels (1, 2, 3, or 4) */

+   png_byte pixel_depth; /* bits per pixel (depth * channels) */

+} png_row_info;

+typedef png_row_info FAR * png_row_infop;

+typedef png_row_info FAR * FAR * png_row_infopp;

+/* These are the function types for the I/O functions and for the functions

+ * that allow the user to override the default I/O functions with his or her

+ * own.  The png_error_ptr type should match that of user-supplied warning

+ * and error functions, while the png_rw_ptr type should match that of the

+ * user read/write data functions.

+ */

+typedef struct png_struct_def png_struct;

+typedef png_struct FAR * png_structp;

+typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp));

+typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t));

+typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp));

+typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32,

+   int));

+typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32,

+   int));

+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

+typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp, png_infop));

+typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop));

+typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep,

+   png_uint_32, int));

+#endif

+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \

+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \

+    defined(PNG_LEGACY_SUPPORTED)

+typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp,

+    png_row_infop, png_bytep));

+#endif

+#if defined(PNG_USER_CHUNKS_SUPPORTED)

+typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp));

+#endif

+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)

+typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp));

+#endif

+/* Transform masks for the high-level interface */

+#define PNG_TRANSFORM_IDENTITY       0x0000    /* read and write */

+#define PNG_TRANSFORM_STRIP_16       0x0001    /* read only */

+#define PNG_TRANSFORM_STRIP_ALPHA    0x0002    /* read only */

+#define PNG_TRANSFORM_PACKING        0x0004    /* read and write */

+#define PNG_TRANSFORM_PACKSWAP       0x0008    /* read and write */

+#define PNG_TRANSFORM_EXPAND         0x0010    /* read only */

+#define PNG_TRANSFORM_INVERT_MONO    0x0020    /* read and write */

+#define PNG_TRANSFORM_SHIFT          0x0040    /* read and write */

+#define PNG_TRANSFORM_BGR            0x0080    /* read and write */

+#define PNG_TRANSFORM_SWAP_ALPHA     0x0100    /* read and write */

+#define PNG_TRANSFORM_SWAP_ENDIAN    0x0200    /* read and write */

+#define PNG_TRANSFORM_INVERT_ALPHA   0x0400    /* read and write */

+#define PNG_TRANSFORM_STRIP_FILLER   0x0800    /* WRITE only */

+/* Flags for MNG supported features */

+#define PNG_FLAG_MNG_EMPTY_PLTE     0x01

+#define PNG_FLAG_MNG_FILTER_64      0x04

+#define PNG_ALL_MNG_FEATURES        0x05

+typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_size_t));

+typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp));

+/* The structure that holds the information to read and write PNG files.

+ * The only people who need to care about what is inside of this are the

+ * people who will be modifying the library for their own special needs.

+ * It should NOT be accessed directly by an application, except to store

+ * the jmp_buf.

+ */

+struct png_struct_def

+{

+#ifdef PNG_SETJMP_SUPPORTED

+   jmp_buf jmpbuf;            /* used in png_error */

+#endif

+   png_error_ptr error_fn;    /* function for printing errors and aborting */

+   png_error_ptr warning_fn;  /* function for printing warnings */

+   png_voidp error_ptr;       /* user supplied struct for error functions */

+   png_rw_ptr write_data_fn;  /* function for writing output data */

+   png_rw_ptr read_data_fn;   /* function for reading input data */

+   png_voidp io_ptr;          /* ptr to application struct for I/O functions */

+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)

+   png_user_transform_ptr read_user_transform_fn; /* user read transform */

+#endif

+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

+   png_user_transform_ptr write_user_transform_fn; /* user write transform */

+#endif

+/* These were added in libpng-1.0.2 */

+#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)

+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \

+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

+   png_voidp user_transform_ptr; /* user supplied struct for user transform */

+   png_byte user_transform_depth;    /* bit depth of user transformed pixels */

+   png_byte user_transform_channels; /* channels in user transformed pixels */

+#endif

+#endif

+   png_uint_32 mode;          /* tells us where we are in the PNG file */

+   png_uint_32 flags;         /* flags indicating various things to libpng */

+   png_uint_32 transformations; /* which transformations to perform */

+   z_stream zstream;          /* pointer to decompression structure (below) */

+   png_bytep zbuf;            /* buffer for zlib */

+   png_size_t zbuf_size;      /* size of zbuf */

+   int zlib_level;            /* holds zlib compression level */

+   int zlib_method;           /* holds zlib compression method */

+   int zlib_window_bits;      /* holds zlib compression window bits */

+   int zlib_mem_level;        /* holds zlib compression memory level */

+   int zlib_strategy;         /* holds zlib compression strategy */

+   png_uint_32 width;         /* width of image in pixels */

+   png_uint_32 height;        /* height of image in pixels */

+   png_uint_32 num_rows;      /* number of rows in current pass */

+   png_uint_32 usr_width;     /* width of row at start of write */

+   png_uint_32 rowbytes;      /* size of row in bytes */

+   png_uint_32 irowbytes;     /* size of current interlaced row in bytes */

+   png_uint_32 iwidth;        /* width of current interlaced row in pixels */

+   png_uint_32 row_number;    /* current row in interlace pass */

+   png_bytep prev_row;        /* buffer to save previous (unfiltered) row */

+   png_bytep row_buf;         /* buffer to save current (unfiltered) row */

+   png_bytep sub_row;         /* buffer to save "sub" row when filtering */

+   png_bytep up_row;          /* buffer to save "up" row when filtering */

+   png_bytep avg_row;         /* buffer to save "avg" row when filtering */

+   png_bytep paeth_row;       /* buffer to save "Paeth" row when filtering */

+   png_row_info row_info;     /* used for transformation routines */

+   png_uint_32 idat_size;     /* current IDAT size for read */

+   png_uint_32 crc;           /* current chunk CRC value */

+   png_colorp palette;        /* palette from the input file */

+   png_uint_16 num_palette;   /* number of color entries in palette */

+   png_uint_16 num_trans;     /* number of transparency values */

+   png_byte chunk_name[5];    /* null-terminated name of current chunk */

+   png_byte compression;      /* file compression type (always 0) */

+   png_byte filter;           /* file filter type (always 0) */

+   png_byte interlaced;       /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */

+   png_byte pass;             /* current interlace pass (0 - 6) */

+   png_byte do_filter;        /* row filter flags (see PNG_FILTER_ below ) */

+   png_byte color_type;       /* color type of file */

+   png_byte bit_depth;        /* bit depth of file */

+   png_byte usr_bit_depth;    /* bit depth of users row */

+   png_byte pixel_depth;      /* number of bits per pixel */

+   png_byte channels;         /* number of channels in file */

+   png_byte usr_channels;     /* channels at start of write */

+   png_byte sig_bytes;        /* magic bytes read/written from start of file */

+#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)

+#ifdef PNG_LEGACY_SUPPORTED

+   png_byte filler;           /* filler byte for pixel expansion */

+#else

+   png_uint_16 filler;           /* filler bytes for pixel expansion */

+#endif

+#endif

+#if defined(PNG_bKGD_SUPPORTED)

+   png_byte background_gamma_type;

+#  ifdef PNG_FLOATING_POINT_SUPPORTED

+   float background_gamma;

+#  endif

+   png_color_16 background;   /* background color in screen gamma space */

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+   png_color_16 background_1; /* background normalized to gamma 1.0 */

+#endif

+#endif /* PNG_bKGD_SUPPORTED */

+#if defined(PNG_WRITE_FLUSH_SUPPORTED)

+   png_flush_ptr output_flush_fn;/* Function for flushing output */

+   png_uint_32 flush_dist;    /* how many rows apart to flush, 0 - no flush */

+   png_uint_32 flush_rows;    /* number of rows written since last flush */

+#endif

+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

+   int gamma_shift;      /* number of "insignificant" bits 16-bit gamma */

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+   float gamma;          /* file gamma value */

+   float screen_gamma;   /* screen gamma value (display_exponent) */

+#endif

+#endif

+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

+   png_bytep gamma_table;     /* gamma table for 8-bit depth files */

+   png_bytep gamma_from_1;    /* converts from 1.0 to screen */

+   png_bytep gamma_to_1;      /* converts from file to 1.0 */

+   png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */

+   png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */

+   png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */

+#endif

+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED)

+   png_color_8 sig_bit;       /* significant bits in each available channel */

+#endif

+#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)

+   png_color_8 shift;         /* shift for significant bit tranformation */

+#endif

+#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \

+ || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

+   png_bytep trans;           /* transparency values for paletted files */

+   png_color_16 trans_values; /* transparency values for non-paletted files */

+#endif

+   png_read_status_ptr read_row_fn;   /* called after each row is decoded */

+   png_write_status_ptr write_row_fn; /* called after each row is encoded */

+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

+   png_progressive_info_ptr info_fn; /* called after header data fully read */

+   png_progressive_row_ptr row_fn;   /* called after each prog. row is decoded */

+   png_progressive_end_ptr end_fn;   /* called after image is complete */

+   png_bytep save_buffer_ptr;        /* current location in save_buffer */

+   png_bytep save_buffer;            /* buffer for previously read data */

+   png_bytep current_buffer_ptr;     /* current location in current_buffer */

+   png_bytep current_buffer;         /* buffer for recently used data */

+   png_uint_32 push_length;          /* size of current input chunk */

+   png_uint_32 skip_length;          /* bytes to skip in input data */

+   png_size_t save_buffer_size;      /* amount of data now in save_buffer */

+   png_size_t save_buffer_max;       /* total size of save_buffer */

+   png_size_t buffer_size;           /* total amount of available input data */

+   png_size_t current_buffer_size;   /* amount of data now in current_buffer */

+   int process_mode;                 /* what push library is currently doing */

+   int cur_palette;                  /* current push library palette index */

+#  if defined(PNG_TEXT_SUPPORTED)

+     png_size_t current_text_size;   /* current size of text input data */

+     png_size_t current_text_left;   /* how much text left to read in input */

+     png_charp current_text;         /* current text chunk buffer */

+     png_charp current_text_ptr;     /* current location in current_text */

+#  endif /* PNG_PROGRESSIVE_READ_SUPPORTED && PNG_TEXT_SUPPORTED */

+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

+#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)

+/* for the Borland special 64K segment handler */

+   png_bytepp offset_table_ptr;

+   png_bytep offset_table;

+   png_uint_16 offset_table_number;

+   png_uint_16 offset_table_count;

+   png_uint_16 offset_table_count_free;

+#endif

+#if defined(PNG_READ_DITHER_SUPPORTED)

+   png_bytep palette_lookup;         /* lookup table for dithering */

+   png_bytep dither_index;           /* index translation for palette files */

+#endif

+#if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_hIST_SUPPORTED)

+   png_uint_16p hist;                /* histogram */

+#endif

+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)

+   png_byte heuristic_method;        /* heuristic for row filter selection */

+   png_byte num_prev_filters;        /* number of weights for previous rows */

+   png_bytep prev_filters;           /* filter type(s) of previous row(s) */

+   png_uint_16p filter_weights;      /* weight(s) for previous line(s) */

+   png_uint_16p inv_filter_weights;  /* 1/weight(s) for previous line(s) */

+   png_uint_16p filter_costs;        /* relative filter calculation cost */

+   png_uint_16p inv_filter_costs;    /* 1/relative filter calculation cost */

+#endif

+#if defined(PNG_TIME_RFC1123_SUPPORTED)

+   png_charp time_buffer;            /* String to hold RFC 1123 time text */

+#endif

+/* New members added in libpng-1.0.6 */

+#ifdef PNG_FREE_ME_SUPPORTED

+   png_uint_32 free_me;       /* flags items libpng is responsible for freeing */

+#endif

+#if defined(PNG_USER_CHUNKS_SUPPORTED)

+   png_voidp user_chunk_ptr;

+   png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */

+#endif

+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)

+   int num_chunk_list;

+   png_bytep chunk_list;

+#endif

+/* New members added in libpng-1.0.3 */

+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)

+   png_byte rgb_to_gray_status;

+   /* These were changed from png_byte in libpng-1.0.6 */

+   png_uint_16 rgb_to_gray_red_coeff;

+   png_uint_16 rgb_to_gray_green_coeff;

+   png_uint_16 rgb_to_gray_blue_coeff;

+#endif

+/* New member added in libpng-1.0.4 (renamed in 1.0.9) */

+#if defined(PNG_MNG_FEATURES_SUPPORTED) || \

+    defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \

+    defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)

+/* changed from png_byte to png_uint_32 at version 1.2.0 */

+#ifdef PNG_1_0_X

+   png_byte mng_features_permitted;

+#else

+   png_uint_32 mng_features_permitted;

+#endif /* PNG_1_0_X */

+#endif

+/* New member added in libpng-1.0.7 */

+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

+   png_fixed_point int_gamma;

+#endif

+/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */

+#if defined(PNG_MNG_FEATURES_SUPPORTED)

+   png_byte filter_type;

+#endif

+#if defined(PNG_1_0_X) || (defined(PNG_DEBUG) && defined(PNG_USE_PNGGCCRD))

+/* New member added in libpng-1.0.10, ifdef'ed out in 1.2.0 */

+   png_uint_32 row_buf_size;

+#endif

+/* New members added in libpng-1.2.0 */

+#if !defined(PNG_1_0_X) && defined(PNG_ASSEMBLER_CODE_SUPPORTED)

+   png_byte     mmx_bitdepth_threshold;

+   png_uint_32  mmx_rowbytes_threshold;

+   png_uint_32  asm_flags;

+#endif

+/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */

+#ifdef PNG_USER_MEM_SUPPORTED

+   png_voidp mem_ptr;                /* user supplied struct for mem functions */

+   png_malloc_ptr malloc_fn;         /* function for allocating memory */

+   png_free_ptr free_fn;             /* function for freeing memory */

+#endif

+/* New member added in libpng-1.0.13 and 1.2.0 */

+   png_bytep big_row_buf;         /* buffer to save current (unfiltered) row */

+#if defined(PNG_READ_DITHER_SUPPORTED)

+/* The following three members were added at version 1.0.14 and 1.2.4 */

+   png_bytep dither_sort;            /* working sort array */

+   png_bytep index_to_palette;       /* where the original index currently is */

+                                     /* in the palette */

+   png_bytep palette_to_index;       /* which original index points to this */

+                                     /* palette color */

+#endif

+/* New members added in libpng-1.0.16 and 1.2.6 */

+   png_byte compression_type;

+#ifdef PNG_SET_USER_LIMITS_SUPPORTED

+   png_uint_32 user_width_max;

+   png_uint_32 user_height_max;

+#endif

+};

+/* This triggers a compiler error in png.c, if png.c and png.h

+ * do not agree upon the version number.

+ */

+typedef png_structp version_1_2_8;

+typedef png_struct FAR * FAR * png_structpp;

+/* Here are the function definitions most commonly used.  This is not

+ * the place to find out how to use libpng.  See libpng.txt for the

+ * full explanation, see example.c for the summary.  This just provides

+ * a simple one line description of the use of each function.

+ */

+/* Returns the version number of the library */

+extern PNG_EXPORT(png_uint_32,png_access_version_number) PNGARG((void));

+/* Tell lib we have already handled the first <num_bytes> magic bytes.

+ * Handling more than 8 bytes from the beginning of the file is an error.

+ */

+extern PNG_EXPORT(void,png_set_sig_bytes) PNGARG((png_structp png_ptr,

+   int num_bytes));

+/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a

+ * PNG file.  Returns zero if the supplied bytes match the 8-byte PNG

+ * signature, and non-zero otherwise.  Having num_to_check == 0 or

+ * start > 7 will always fail (ie return non-zero).

+ */

+extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start,

+   png_size_t num_to_check));

+/* Simple signature checking function.  This is the same as calling

+ * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n).

+ */

+extern PNG_EXPORT(int,png_check_sig) PNGARG((png_bytep sig, int num));

+/* Allocate and initialize png_ptr struct for reading, and any other memory. */

+extern PNG_EXPORT(png_structp,png_create_read_struct)

+   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,

+   png_error_ptr error_fn, png_error_ptr warn_fn));

+/* Allocate and initialize png_ptr struct for writing, and any other memory */

+extern PNG_EXPORT(png_structp,png_create_write_struct)

+   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,

+   png_error_ptr error_fn, png_error_ptr warn_fn));

+#ifdef PNG_WRITE_SUPPORTED

+extern PNG_EXPORT(png_uint_32,png_get_compression_buffer_size)

+   PNGARG((png_structp png_ptr));

+#endif

+#ifdef PNG_WRITE_SUPPORTED

+extern PNG_EXPORT(void,png_set_compression_buffer_size)

+   PNGARG((png_structp png_ptr, png_uint_32 size));

+#endif

+/* Reset the compression stream */

+extern PNG_EXPORT(int,png_reset_zstream) PNGARG((png_structp png_ptr));

+/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */

+#ifdef PNG_USER_MEM_SUPPORTED

+extern PNG_EXPORT(png_structp,png_create_read_struct_2)

+   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,

+   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

+   png_malloc_ptr malloc_fn, png_free_ptr free_fn));

+extern PNG_EXPORT(png_structp,png_create_write_struct_2)

+   PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,

+   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

+   png_malloc_ptr malloc_fn, png_free_ptr free_fn));

+#endif

+/* Write a PNG chunk - size, type, (optional) data, CRC. */

+extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr,

+   png_bytep chunk_name, png_bytep data, png_size_t length));

+/* Write the start of a PNG chunk - length and chunk name. */

+extern PNG_EXPORT(void,png_write_chunk_start) PNGARG((png_structp png_ptr,

+   png_bytep chunk_name, png_uint_32 length));

+/* Write the data of a PNG chunk started with png_write_chunk_start(). */

+extern PNG_EXPORT(void,png_write_chunk_data) PNGARG((png_structp png_ptr,

+   png_bytep data, png_size_t length));

+/* Finish a chunk started with png_write_chunk_start() (includes CRC). */

+extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr));

+/* Allocate and initialize the info structure */

+extern PNG_EXPORT(png_infop,png_create_info_struct)

+   PNGARG((png_structp png_ptr));

+/* Initialize the info structure (old interface - DEPRECATED) */

+extern PNG_EXPORT(void,png_info_init) PNGARG((png_infop info_ptr));

+#undef png_info_init

+#define png_info_init(info_ptr) png_info_init_3(&info_ptr,\

+    png_sizeof(png_info));

+extern PNG_EXPORT(void,png_info_init_3) PNGARG((png_infopp info_ptr,

+    png_size_t png_info_struct_size));

+/* Writes all the PNG information before the image. */

+extern PNG_EXPORT(void,png_write_info_before_PLTE) PNGARG((png_structp png_ptr,

+   png_infop info_ptr));

+extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr,

+   png_infop info_ptr));

+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

+/* read the information before the actual image data. */

+extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr,

+   png_infop info_ptr));

+#endif

+#if defined(PNG_TIME_RFC1123_SUPPORTED)

+extern PNG_EXPORT(png_charp,png_convert_to_rfc1123)

+   PNGARG((png_structp png_ptr, png_timep ptime));

+#endif

+#if !defined(_WIN32_WCE)

+/* "time.h" functions are not supported on WindowsCE */

+#if defined(PNG_WRITE_tIME_SUPPORTED)

+/* convert from a struct tm to png_time */

+extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime,

+   struct tm FAR * ttime));

+/* convert from time_t to png_time.  Uses gmtime() */

+extern PNG_EXPORT(void,png_convert_from_time_t) PNGARG((png_timep ptime,

+   time_t ttime));

+#endif /* PNG_WRITE_tIME_SUPPORTED */

+#endif /* _WIN32_WCE */

+#if defined(PNG_READ_EXPAND_SUPPORTED)

+/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */

+extern PNG_EXPORT(void,png_set_expand) PNGARG((png_structp png_ptr));

+extern PNG_EXPORT(void,png_set_gray_1_2_4_to_8) PNGARG((png_structp png_ptr));

+extern PNG_EXPORT(void,png_set_palette_to_rgb) PNGARG((png_structp png_ptr));

+extern PNG_EXPORT(void,png_set_tRNS_to_alpha) PNGARG((png_structp png_ptr));

+#endif

+#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)

+/* Use blue, green, red order for pixels. */

+extern PNG_EXPORT(void,png_set_bgr) PNGARG((png_structp png_ptr));

+#endif

+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)

+/* Expand the grayscale to 24-bit RGB if necessary. */

+extern PNG_EXPORT(void,png_set_gray_to_rgb) PNGARG((png_structp png_ptr));

+#endif

+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)

+/* Reduce RGB to grayscale. */

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+extern PNG_EXPORT(void,png_set_rgb_to_gray) PNGARG((png_structp png_ptr,

+   int error_action, double red, double green ));

+#endif

+extern PNG_EXPORT(void,png_set_rgb_to_gray_fixed) PNGARG((png_structp png_ptr,

+   int error_action, png_fixed_point red, png_fixed_point green ));

+extern PNG_EXPORT(png_byte,png_get_rgb_to_gray_status) PNGARG((png_structp

+   png_ptr));

+#endif

+extern PNG_EXPORT(void,png_build_grayscale_palette) PNGARG((int bit_depth,

+   png_colorp palette));

+#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)

+extern PNG_EXPORT(void,png_set_strip_alpha) PNGARG((png_structp png_ptr));

+#endif

+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \

+    defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)

+extern PNG_EXPORT(void,png_set_swap_alpha) PNGARG((png_structp png_ptr));

+#endif

+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \

+    defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)

+extern PNG_EXPORT(void,png_set_invert_alpha) PNGARG((png_structp png_ptr));

+#endif

+#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)

+/* Add a filler byte to 8-bit Gray or 24-bit RGB images. */

+extern PNG_EXPORT(void,png_set_filler) PNGARG((png_structp png_ptr,

+   png_uint_32 filler, int flags));

+/* The values of the PNG_FILLER_ defines should NOT be changed */

+#define PNG_FILLER_BEFORE 0

+#define PNG_FILLER_AFTER 1

+/* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */

+#if !defined(PNG_1_0_X)

+extern PNG_EXPORT(void,png_set_add_alpha) PNGARG((png_structp png_ptr,

+   png_uint_32 filler, int flags));

+#endif

+#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */

+#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)

+/* Swap bytes in 16-bit depth files. */

+extern PNG_EXPORT(void,png_set_swap) PNGARG((png_structp png_ptr));

+#endif

+#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)

+/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */

+extern PNG_EXPORT(void,png_set_packing) PNGARG((png_structp png_ptr));

+#endif

+#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED)

+/* Swap packing order of pixels in bytes. */

+extern PNG_EXPORT(void,png_set_packswap) PNGARG((png_structp png_ptr));

+#endif

+#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)

+/* Converts files to legal bit depths. */

+extern PNG_EXPORT(void,png_set_shift) PNGARG((png_structp png_ptr,

+   png_color_8p true_bits));

+#endif

+#if defined(PNG_READ_INTERLACING_SUPPORTED) || \

+    defined(PNG_WRITE_INTERLACING_SUPPORTED)

+/* Have the code handle the interlacing.  Returns the number of passes. */

+extern PNG_EXPORT(int,png_set_interlace_handling) PNGARG((png_structp png_ptr));

+#endif

+#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)

+/* Invert monochrome files */

+extern PNG_EXPORT(void,png_set_invert_mono) PNGARG((png_structp png_ptr));

+#endif

+#if defined(PNG_READ_BACKGROUND_SUPPORTED)

+/* Handle alpha and tRNS by replacing with a background color. */

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr,

+   png_color_16p background_color, int background_gamma_code,

+   int need_expand, double background_gamma));

+#endif

+#define PNG_BACKGROUND_GAMMA_UNKNOWN 0

+#define PNG_BACKGROUND_GAMMA_SCREEN  1

+#define PNG_BACKGROUND_GAMMA_FILE    2

+#define PNG_BACKGROUND_GAMMA_UNIQUE  3

+#endif

+#if defined(PNG_READ_16_TO_8_SUPPORTED)

+/* strip the second byte of information from a 16-bit depth file. */

+extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr));

+#endif

+#if defined(PNG_READ_DITHER_SUPPORTED)

+/* Turn on dithering, and reduce the palette to the number of colors available. */

+extern PNG_EXPORT(void,png_set_dither) PNGARG((png_structp png_ptr,

+   png_colorp palette, int num_palette, int maximum_colors,

+   png_uint_16p histogram, int full_dither));

+#endif

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+/* Handle gamma correction. Screen_gamma=(display_exponent) */

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+extern PNG_EXPORT(void,png_set_gamma) PNGARG((png_structp png_ptr,

+   double screen_gamma, double default_file_gamma));

+#endif

+#endif

+#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \

+    defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)

+/* Permit or disallow empty PLTE (0: not permitted, 1: permitted) */

+/* Deprecated and will be removed.  Use png_permit_mng_features() instead. */

+extern PNG_EXPORT(void,png_permit_empty_plte) PNGARG((png_structp png_ptr,

+   int empty_plte_permitted));

+#endif

+#if defined(PNG_WRITE_FLUSH_SUPPORTED)

+/* Set how many lines between output flushes - 0 for no flushing */

+extern PNG_EXPORT(void,png_set_flush) PNGARG((png_structp png_ptr, int nrows));

+/* Flush the current PNG output buffer */

+extern PNG_EXPORT(void,png_write_flush) PNGARG((png_structp png_ptr));

+#endif

+/* optional update palette with requested transformations */

+extern PNG_EXPORT(void,png_start_read_image) PNGARG((png_structp png_ptr));

+/* optional call to update the users info structure */

+extern PNG_EXPORT(void,png_read_update_info) PNGARG((png_structp png_ptr,

+   png_infop info_ptr));

+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

+/* read one or more rows of image data. */

+extern PNG_EXPORT(void,png_read_rows) PNGARG((png_structp png_ptr,

+   png_bytepp row, png_bytepp display_row, png_uint_32 num_rows));

+#endif

+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

+/* read a row of data. */

+extern PNG_EXPORT(void,png_read_row) PNGARG((png_structp png_ptr,

+   png_bytep row,

+   png_bytep display_row));

+#endif

+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

+/* read the whole image into memory at once. */

+extern PNG_EXPORT(void,png_read_image) PNGARG((png_structp png_ptr,

+   png_bytepp image));

+#endif

+/* write a row of image data */

+extern PNG_EXPORT(void,png_write_row) PNGARG((png_structp png_ptr,

+   png_bytep row));

+/* write a few rows of image data */

+extern PNG_EXPORT(void,png_write_rows) PNGARG((png_structp png_ptr,

+   png_bytepp row, png_uint_32 num_rows));

+/* write the image data */

+extern PNG_EXPORT(void,png_write_image) PNGARG((png_structp png_ptr,

+   png_bytepp image));

+/* writes the end of the PNG file. */

+extern PNG_EXPORT(void,png_write_end) PNGARG((png_structp png_ptr,

+   png_infop info_ptr));

+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

+/* read the end of the PNG file. */

+extern PNG_EXPORT(void,png_read_end) PNGARG((png_structp png_ptr,

+   png_infop info_ptr));

+#endif

+/* free any memory associated with the png_info_struct */

+extern PNG_EXPORT(void,png_destroy_info_struct) PNGARG((png_structp png_ptr,

+   png_infopp info_ptr_ptr));

+/* free any memory associated with the png_struct and the png_info_structs */

+extern PNG_EXPORT(void,png_destroy_read_struct) PNGARG((png_structpp

+   png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr));

+/* free all memory used by the read (old method - NOT DLL EXPORTED) */

+extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_infop end_info_ptr));

+/* free any memory associated with the png_struct and the png_info_structs */

+extern PNG_EXPORT(void,png_destroy_write_struct)

+   PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr));

+/* free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */

+extern void png_write_destroy PNGARG((png_structp png_ptr));

+/* set the libpng method of handling chunk CRC errors */

+extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr,

+   int crit_action, int ancil_action));

+/* Values for png_set_crc_action() to say how to handle CRC errors in

+ * ancillary and critical chunks, and whether to use the data contained

+ * therein.  Note that it is impossible to "discard" data in a critical

+ * chunk.  For versions prior to 0.90, the action was always error/quit,

+ * whereas in version 0.90 and later, the action for CRC errors in ancillary

+ * chunks is warn/discard.  These values should NOT be changed.

+ *

+ *      value                       action:critical     action:ancillary

+ */

+#define PNG_CRC_DEFAULT       0  /* error/quit          warn/discard data */

+#define PNG_CRC_ERROR_QUIT    1  /* error/quit          error/quit        */

+#define PNG_CRC_WARN_DISCARD  2  /* (INVALID)           warn/discard data */

+#define PNG_CRC_WARN_USE      3  /* warn/use data       warn/use data     */

+#define PNG_CRC_QUIET_USE     4  /* quiet/use data      quiet/use data    */

+#define PNG_CRC_NO_CHANGE     5  /* use current value   use current value */

+/* These functions give the user control over the scan-line filtering in

+ * libpng and the compression methods used by zlib.  These functions are

+ * mainly useful for testing, as the defaults should work with most users.

+ * Those users who are tight on memory or want faster performance at the

+ * expense of compression can modify them.  See the compression library

+ * header file (zlib.h) for an explination of the compression functions.

+ */

+/* set the filtering method(s) used by libpng.  Currently, the only valid

+ * value for "method" is 0.

+ */

+extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method,

+   int filters));

+/* Flags for png_set_filter() to say which filters to use.  The flags

+ * are chosen so that they don't conflict with real filter types

+ * below, in case they are supplied instead of the #defined constants.

+ * These values should NOT be changed.

+ */

+#define PNG_NO_FILTERS     0x00

+#define PNG_FILTER_NONE    0x08

+#define PNG_FILTER_SUB     0x10

+#define PNG_FILTER_UP      0x20

+#define PNG_FILTER_AVG     0x40

+#define PNG_FILTER_PAETH   0x80

+#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \

+                         PNG_FILTER_AVG | PNG_FILTER_PAETH)

+/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now.

+ * These defines should NOT be changed.

+ */

+#define PNG_FILTER_VALUE_NONE  0

+#define PNG_FILTER_VALUE_SUB   1

+#define PNG_FILTER_VALUE_UP    2

+#define PNG_FILTER_VALUE_AVG   3

+#define PNG_FILTER_VALUE_PAETH 4

+#define PNG_FILTER_VALUE_LAST  5

+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* EXPERIMENTAL */

+/* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_

+ * defines, either the default (minimum-sum-of-absolute-differences), or

+ * the experimental method (weighted-minimum-sum-of-absolute-differences).

+ *

+ * Weights are factors >= 1.0, indicating how important it is to keep the

+ * filter type consistent between rows.  Larger numbers mean the current

+ * filter is that many times as likely to be the same as the "num_weights"

+ * previous filters.  This is cumulative for each previous row with a weight.

+ * There needs to be "num_weights" values in "filter_weights", or it can be

+ * NULL if the weights aren't being specified.  Weights have no influence on

+ * the selection of the first row filter.  Well chosen weights can (in theory)

+ * improve the compression for a given image.

+ *

+ * Costs are factors >= 1.0 indicating the relative decoding costs of a

+ * filter type.  Higher costs indicate more decoding expense, and are

+ * therefore less likely to be selected over a filter with lower computational

+ * costs.  There needs to be a value in "filter_costs" for each valid filter

+ * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't

+ * setting the costs.  Costs try to improve the speed of decompression without

+ * unduly increasing the compressed image size.

+ *

+ * A negative weight or cost indicates the default value is to be used, and

+ * values in the range [0.0, 1.0) indicate the value is to remain unchanged.

+ * The default values for both weights and costs are currently 1.0, but may

+ * change if good general weighting/cost heuristics can be found.  If both

+ * the weights and costs are set to 1.0, this degenerates the WEIGHTED method

+ * to the UNWEIGHTED method, but with added encoding time/computation.

+ */

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr,

+   int heuristic_method, int num_weights, png_doublep filter_weights,

+   png_doublep filter_costs));

+#endif

+#endif /*  PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */

+/* Heuristic used for row filter selection.  These defines should NOT be

+ * changed.

+ */

+#define PNG_FILTER_HEURISTIC_DEFAULT    0  /* Currently "UNWEIGHTED" */

+#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1  /* Used by libpng < 0.95 */

+#define PNG_FILTER_HEURISTIC_WEIGHTED   2  /* Experimental feature */

+#define PNG_FILTER_HEURISTIC_LAST       3  /* Not a valid value */

+/* Set the library compression level.  Currently, valid values range from

+ * 0 - 9, corresponding directly to the zlib compression levels 0 - 9

+ * (0 - no compression, 9 - "maximal" compression).  Note that tests have

+ * shown that zlib compression levels 3-6 usually perform as well as level 9

+ * for PNG images, and do considerably fewer caclulations.  In the future,

+ * these values may not correspond directly to the zlib compression levels.

+ */

+extern PNG_EXPORT(void,png_set_compression_level) PNGARG((png_structp png_ptr,

+   int level));

+extern PNG_EXPORT(void,png_set_compression_mem_level)

+   PNGARG((png_structp png_ptr, int mem_level));

+extern PNG_EXPORT(void,png_set_compression_strategy)

+   PNGARG((png_structp png_ptr, int strategy));

+extern PNG_EXPORT(void,png_set_compression_window_bits)

+   PNGARG((png_structp png_ptr, int window_bits));

+extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr,

+   int method));

+/* These next functions are called for input/output, memory, and error

+ * handling.  They are in the file pngrio.c, pngwio.c, and pngerror.c,

+ * and call standard C I/O routines such as fread(), fwrite(), and

+ * fprintf().  These functions can be made to use other I/O routines

+ * at run time for those applications that need to handle I/O in a

+ * different manner by calling png_set_???_fn().  See libpng.txt for

+ * more information.

+ */

+#if !defined(PNG_NO_STDIO)

+/* Initialize the input/output for the PNG file to the default functions. */

+extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, png_FILE_p fp));

+#endif

+/* Replace the (error and abort), and warning functions with user

+ * supplied functions.  If no messages are to be printed you must still

+ * write and use replacement functions. The replacement error_fn should

+ * still do a longjmp to the last setjmp location if you are using this

+ * method of error handling.  If error_fn or warning_fn is NULL, the

+ * default function will be used.

+ */

+extern PNG_EXPORT(void,png_set_error_fn) PNGARG((png_structp png_ptr,

+   png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn));

+/* Return the user pointer associated with the error functions */

+extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr));

+/* Replace the default data output functions with a user supplied one(s).

+ * If buffered output is not used, then output_flush_fn can be set to NULL.

+ * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time

+ * output_flush_fn will be ignored (and thus can be NULL).

+ */

+extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr,

+   png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn));

+/* Replace the default data input function with a user supplied one. */

+extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr,

+   png_voidp io_ptr, png_rw_ptr read_data_fn));

+/* Return the user pointer associated with the I/O functions */

+extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr));

+extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr,

+   png_read_status_ptr read_row_fn));

+extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr,

+   png_write_status_ptr write_row_fn));

+#ifdef PNG_USER_MEM_SUPPORTED

+/* Replace the default memory allocation functions with user supplied one(s). */

+extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr,

+   png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn));

+/* Return the user pointer associated with the memory functions */

+extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr));

+#endif

+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \

+    defined(PNG_LEGACY_SUPPORTED)

+extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp

+   png_ptr, png_user_transform_ptr read_user_transform_fn));

+#endif

+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \

+    defined(PNG_LEGACY_SUPPORTED)

+extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp

+   png_ptr, png_user_transform_ptr write_user_transform_fn));

+#endif

+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \

+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \

+    defined(PNG_LEGACY_SUPPORTED)

+extern PNG_EXPORT(void,png_set_user_transform_info) PNGARG((png_structp

+   png_ptr, png_voidp user_transform_ptr, int user_transform_depth,

+   int user_transform_channels));

+/* Return the user pointer associated with the user transform functions */

+extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr)

+   PNGARG((png_structp png_ptr));

+#endif

+#ifdef PNG_USER_CHUNKS_SUPPORTED

+extern PNG_EXPORT(void,png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr,

+   png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn));

+extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr) PNGARG((png_structp

+   png_ptr));

+#endif

+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

+/* Sets the function callbacks for the push reader, and a pointer to a

+ * user-defined structure available to the callback functions.

+ */

+extern PNG_EXPORT(void,png_set_progressive_read_fn) PNGARG((png_structp png_ptr,

+   png_voidp progressive_ptr,

+   png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,

+   png_progressive_end_ptr end_fn));

+/* returns the user pointer associated with the push read functions */

+extern PNG_EXPORT(png_voidp,png_get_progressive_ptr)

+   PNGARG((png_structp png_ptr));

+/* function to be called when data becomes available */

+extern PNG_EXPORT(void,png_process_data) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_bytep buffer, png_size_t buffer_size));

+/* function that combines rows.  Not very much different than the

+ * png_combine_row() call.  Is this even used?????

+ */

+extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr,

+   png_bytep old_row, png_bytep new_row));

+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

+extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr,

+   png_uint_32 size));

+#if defined(PNG_1_0_X)

+#  define png_malloc_warn png_malloc

+#else

+/* Added at libpng version 1.2.4 */

+extern PNG_EXPORT(png_voidp,png_malloc_warn) PNGARG((png_structp png_ptr,

+   png_uint_32 size));

+#endif

+/* frees a pointer allocated by png_malloc() */

+extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr));

+#if defined(PNG_1_0_X)

+/* Function to allocate memory for zlib. */

+extern PNG_EXPORT(voidpf,png_zalloc) PNGARG((voidpf png_ptr, uInt items,

+   uInt size));

+/* Function to free memory for zlib */

+extern PNG_EXPORT(void,png_zfree) PNGARG((voidpf png_ptr, voidpf ptr));

+#endif

+/* Free data that was allocated internally */

+extern PNG_EXPORT(void,png_free_data) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_uint_32 free_me, int num));

+#ifdef PNG_FREE_ME_SUPPORTED

+/* Reassign responsibility for freeing existing data, whether allocated

+ * by libpng or by the application */

+extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, int freer, png_uint_32 mask));

+#endif

+/* assignments for png_data_freer */

+#define PNG_DESTROY_WILL_FREE_DATA 1

+#define PNG_SET_WILL_FREE_DATA 1

+#define PNG_USER_WILL_FREE_DATA 2

+/* Flags for png_ptr->free_me and info_ptr->free_me */

+#define PNG_FREE_HIST 0x0008

+#define PNG_FREE_ICCP 0x0010

+#define PNG_FREE_SPLT 0x0020

+#define PNG_FREE_ROWS 0x0040

+#define PNG_FREE_PCAL 0x0080

+#define PNG_FREE_SCAL 0x0100

+#define PNG_FREE_UNKN 0x0200

+#define PNG_FREE_LIST 0x0400

+#define PNG_FREE_PLTE 0x1000

+#define PNG_FREE_TRNS 0x2000

+#define PNG_FREE_TEXT 0x4000

+#define PNG_FREE_ALL  0x7fff

+#define PNG_FREE_MUL  0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */

+#ifdef PNG_USER_MEM_SUPPORTED

+extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr,

+   png_uint_32 size));

+extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr,

+   png_voidp ptr));

+#endif

+extern PNG_EXPORT(png_voidp,png_memcpy_check) PNGARG((png_structp png_ptr,

+   png_voidp s1, png_voidp s2, png_uint_32 size));

+extern PNG_EXPORT(png_voidp,png_memset_check) PNGARG((png_structp png_ptr,

+   png_voidp s1, int value, png_uint_32 size));

+#if defined(USE_FAR_KEYWORD)  /* memory model conversion function */

+extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr,

+   int check));

+#endif /* USE_FAR_KEYWORD */

+/* Fatal error in PNG image of libpng - can't continue */

+extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr,

+   png_const_charp error_message));

+/* The same, but the chunk name is prepended to the error string. */

+extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr,

+   png_const_charp error_message));

+/* Non-fatal error in libpng.  Can continue, but may have a problem. */

+extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr,

+   png_const_charp warning_message));

+/* Non-fatal error in libpng, chunk name is prepended to message. */

+extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr,

+   png_const_charp warning_message));

+/* The png_set_<chunk> functions are for storing values in the png_info_struct.

+ * Similarly, the png_get_<chunk> calls are used to read values from the

+ * png_info_struct, either storing the parameters in the passed variables, or

+ * setting pointers into the png_info_struct where the data is stored.  The

+ * png_get_<chunk> functions return a non-zero value if the data was available

+ * in info_ptr, or return zero and do not change any of the parameters if the

+ * data was not available.

+ *

+ * These functions should be used instead of directly accessing png_info

+ * to avoid problems with future changes in the size and internal layout of

+ * png_info_struct.

+ */

+/* Returns "flag" if chunk data is valid in info_ptr. */

+extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr,

+png_infop info_ptr, png_uint_32 flag));

+/* Returns number of bytes needed to hold a transformed row. */

+extern PNG_EXPORT(png_uint_32,png_get_rowbytes) PNGARG((png_structp png_ptr,

+png_infop info_ptr));

+#if defined(PNG_INFO_IMAGE_SUPPORTED)

+/* Returns row_pointers, which is an array of pointers to scanlines that was

+returned from png_read_png(). */

+extern PNG_EXPORT(png_bytepp,png_get_rows) PNGARG((png_structp png_ptr,

+png_infop info_ptr));

+/* Set row_pointers, which is an array of pointers to scanlines for use

+by png_write_png(). */

+extern PNG_EXPORT(void,png_set_rows) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_bytepp row_pointers));

+#endif

+/* Returns number of color channels in image. */

+extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr,

+png_infop info_ptr));

+#ifdef PNG_EASY_ACCESS_SUPPORTED

+/* Returns image width in pixels. */

+extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp

+png_ptr, png_infop info_ptr));

+/* Returns image height in pixels. */

+extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp

+png_ptr, png_infop info_ptr));

+/* Returns image bit_depth. */

+extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp

+png_ptr, png_infop info_ptr));

+/* Returns image color_type. */

+extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp

+png_ptr, png_infop info_ptr));

+/* Returns image filter_type. */

+extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp

+png_ptr, png_infop info_ptr));

+/* Returns image interlace_type. */

+extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp

+png_ptr, png_infop info_ptr));

+/* Returns image compression_type. */

+extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp

+png_ptr, png_infop info_ptr));

+/* Returns image resolution in pixels per meter, from pHYs chunk data. */

+extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp

+png_ptr, png_infop info_ptr));

+extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp

+png_ptr, png_infop info_ptr));

+extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp

+png_ptr, png_infop info_ptr));

+/* Returns pixel aspect ratio, computed from pHYs chunk data.  */

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp

+png_ptr, png_infop info_ptr));

+#endif

+/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */

+extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp

+png_ptr, png_infop info_ptr));

+extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp

+png_ptr, png_infop info_ptr));

+extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp

+png_ptr, png_infop info_ptr));

+extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp

+png_ptr, png_infop info_ptr));

+#endif /* PNG_EASY_ACCESS_SUPPORTED */

+/* Returns pointer to signature string read from PNG header */

+extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr,

+png_infop info_ptr));

+#if defined(PNG_bKGD_SUPPORTED)

+extern PNG_EXPORT(png_uint_32,png_get_bKGD) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_color_16p *background));

+#endif

+#if defined(PNG_bKGD_SUPPORTED)

+extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_color_16p background));

+#endif

+#if defined(PNG_cHRM_SUPPORTED)

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+extern PNG_EXPORT(png_uint_32,png_get_cHRM) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, double *white_x, double *white_y, double *red_x,

+   double *red_y, double *green_x, double *green_y, double *blue_x,

+   double *blue_y));

+#endif

+#ifdef PNG_FIXED_POINT_SUPPORTED

+extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point

+   *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y,

+   png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point

+   *int_blue_x, png_fixed_point *int_blue_y));

+#endif

+#endif

+#if defined(PNG_cHRM_SUPPORTED)

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+extern PNG_EXPORT(void,png_set_cHRM) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, double white_x, double white_y, double red_x,

+   double red_y, double green_x, double green_y, double blue_x, double blue_y));

+#endif

+#ifdef PNG_FIXED_POINT_SUPPORTED

+extern PNG_EXPORT(void,png_set_cHRM_fixed) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y,

+   png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point

+   int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,

+   png_fixed_point int_blue_y));

+#endif

+#endif

+#if defined(PNG_gAMA_SUPPORTED)

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+extern PNG_EXPORT(png_uint_32,png_get_gAMA) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, double *file_gamma));

+#endif

+extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_fixed_point *int_file_gamma));

+#endif

+#if defined(PNG_gAMA_SUPPORTED)

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+extern PNG_EXPORT(void,png_set_gAMA) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, double file_gamma));

+#endif

+extern PNG_EXPORT(void,png_set_gAMA_fixed) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_fixed_point int_file_gamma));

+#endif

+#if defined(PNG_hIST_SUPPORTED)

+extern PNG_EXPORT(png_uint_32,png_get_hIST) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_uint_16p *hist));

+#endif

+#if defined(PNG_hIST_SUPPORTED)

+extern PNG_EXPORT(void,png_set_hIST) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_uint_16p hist));

+#endif

+extern PNG_EXPORT(png_uint_32,png_get_IHDR) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_uint_32 *width, png_uint_32 *height,

+   int *bit_depth, int *color_type, int *interlace_method,

+   int *compression_method, int *filter_method));

+extern PNG_EXPORT(void,png_set_IHDR) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth,

+   int color_type, int interlace_method, int compression_method,

+   int filter_method));

+#if defined(PNG_oFFs_SUPPORTED)

+extern PNG_EXPORT(png_uint_32,png_get_oFFs) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y,

+   int *unit_type));

+#endif

+#if defined(PNG_oFFs_SUPPORTED)

+extern PNG_EXPORT(void,png_set_oFFs) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y,

+   int unit_type));

+#endif

+#if defined(PNG_pCAL_SUPPORTED)

+extern PNG_EXPORT(png_uint_32,png_get_pCAL) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1,

+   int *type, int *nparams, png_charp *units, png_charpp *params));

+#endif

+#if defined(PNG_pCAL_SUPPORTED)

+extern PNG_EXPORT(void,png_set_pCAL) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1,

+   int type, int nparams, png_charp units, png_charpp params));

+#endif

+#if defined(PNG_pHYs_SUPPORTED)

+extern PNG_EXPORT(png_uint_32,png_get_pHYs) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type));

+#endif

+#if defined(PNG_pHYs_SUPPORTED)

+extern PNG_EXPORT(void,png_set_pHYs) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type));

+#endif

+extern PNG_EXPORT(png_uint_32,png_get_PLTE) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_colorp *palette, int *num_palette));

+extern PNG_EXPORT(void,png_set_PLTE) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_colorp palette, int num_palette));

+#if defined(PNG_sBIT_SUPPORTED)

+extern PNG_EXPORT(png_uint_32,png_get_sBIT) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_color_8p *sig_bit));

+#endif

+#if defined(PNG_sBIT_SUPPORTED)

+extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_color_8p sig_bit));

+#endif

+#if defined(PNG_sRGB_SUPPORTED)

+extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, int *intent));

+#endif

+#if defined(PNG_sRGB_SUPPORTED)

+extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, int intent));

+extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, int intent));

+#endif

+#if defined(PNG_iCCP_SUPPORTED)

+extern PNG_EXPORT(png_uint_32,png_get_iCCP) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_charpp name, int *compression_type,

+   png_charpp profile, png_uint_32 *proflen));

+   /* Note to maintainer: profile should be png_bytepp */

+#endif

+#if defined(PNG_iCCP_SUPPORTED)

+extern PNG_EXPORT(void,png_set_iCCP) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_charp name, int compression_type,

+   png_charp profile, png_uint_32 proflen));

+   /* Note to maintainer: profile should be png_bytep */

+#endif

+#if defined(PNG_sPLT_SUPPORTED)

+extern PNG_EXPORT(png_uint_32,png_get_sPLT) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_sPLT_tpp entries));

+#endif

+#if defined(PNG_sPLT_SUPPORTED)

+extern PNG_EXPORT(void,png_set_sPLT) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_sPLT_tp entries, int nentries));

+#endif

+#if defined(PNG_TEXT_SUPPORTED)

+/* png_get_text also returns the number of text chunks in *num_text */

+extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_textp *text_ptr, int *num_text));

+#endif

+/*

+ *  Note while png_set_text() will accept a structure whose text,

+ *  language, and  translated keywords are NULL pointers, the structure

+ *  returned by png_get_text will always contain regular

+ *  zero-terminated C strings.  They might be empty strings but

+ *  they will never be NULL pointers.

+ */

+#if defined(PNG_TEXT_SUPPORTED)

+extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_textp text_ptr, int num_text));

+#endif

+#if defined(PNG_tIME_SUPPORTED)

+extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_timep *mod_time));

+#endif

+#if defined(PNG_tIME_SUPPORTED)

+extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_timep mod_time));

+#endif

+#if defined(PNG_tRNS_SUPPORTED)

+extern PNG_EXPORT(png_uint_32,png_get_tRNS) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_bytep *trans, int *num_trans,

+   png_color_16p *trans_values));

+#endif

+#if defined(PNG_tRNS_SUPPORTED)

+extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_bytep trans, int num_trans,

+   png_color_16p trans_values));

+#endif

+#if defined(PNG_tRNS_SUPPORTED)

+#endif

+#if defined(PNG_sCAL_SUPPORTED)

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+extern PNG_EXPORT(png_uint_32,png_get_sCAL) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, int *unit, double *width, double *height));

+#else

+#ifdef PNG_FIXED_POINT_SUPPORTED

+extern PNG_EXPORT(png_uint_32,png_get_sCAL_s) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight));

+#endif

+#endif

+#endif /* PNG_sCAL_SUPPORTED */

+#if defined(PNG_sCAL_SUPPORTED)

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+extern PNG_EXPORT(void,png_set_sCAL) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, int unit, double width, double height));

+#endif

+#ifdef PNG_FIXED_POINT_SUPPORTED

+extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, int unit, png_charp swidth, png_charp sheight));

+#endif

+#endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */

+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)

+/* provide a list of chunks and how they are to be handled, if the built-in

+   handling or default unknown chunk handling is not desired.  Any chunks not

+   listed will be handled in the default manner.  The IHDR and IEND chunks

+   must not be listed.

+      keep = 0: follow default behavour

+           = 1: do not keep

+           = 2: keep only if safe-to-copy

+           = 3: keep even if unsafe-to-copy

+*/

+extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp

+   png_ptr, int keep, png_bytep chunk_list, int num_chunks));

+extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns));

+extern PNG_EXPORT(void, png_set_unknown_chunk_location)

+   PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location));

+extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp

+   png_ptr, png_infop info_ptr, png_unknown_chunkpp entries));

+#endif

+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

+PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep

+   chunk_name));

+#endif

+/* Png_free_data() will turn off the "valid" flag for anything it frees.

+   If you need to turn it off for a chunk that your application has freed,

+   you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); */

+extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr,

+   png_infop info_ptr, int mask));

+#if defined(PNG_INFO_IMAGE_SUPPORTED)

+/* The "params" pointer is currently not used and is for future expansion. */

+extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr,

+                        png_infop info_ptr,

+                        int transforms,

+                        void* params));

+extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr,

+                        png_infop info_ptr,

+                        int transforms,

+                        void* params));

+#endif

+/* Define PNG_DEBUG at compile time for debugging information.  Higher

+ * numbers for PNG_DEBUG mean more debugging information.  This has

+ * only been added since version 0.95 so it is not implemented throughout

+ * libpng yet, but more support will be added as needed.

+ */

+#ifdef PNG_DEBUG

+#if (PNG_DEBUG > 0)

+#if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER)

+#include <crtdbg.h>

+#if (PNG_DEBUG > 1)

+#define png_debug(l,m)  _RPT0(_CRT_WARN,m)

+#define png_debug1(l,m,p1)  _RPT1(_CRT_WARN,m,p1)

+#define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m,p1,p2)

+#endif

+#else /* PNG_DEBUG_FILE || !_MSC_VER */

+#ifndef PNG_DEBUG_FILE

+#define PNG_DEBUG_FILE stderr

+#endif /* PNG_DEBUG_FILE */

+#if (PNG_DEBUG > 1)

+#define png_debug(l,m) \

+{ \

+     int num_tabs=l; \

+     fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \

+       (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \

+}

+#define png_debug1(l,m,p1) \

+{ \

+     int num_tabs=l; \

+     fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \

+       (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \

+}

+#define png_debug2(l,m,p1,p2) \

+{ \

+     int num_tabs=l; \

+     fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \

+       (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \

+}

+#endif /* (PNG_DEBUG > 1) */

+#endif /* _MSC_VER */

+#endif /* (PNG_DEBUG > 0) */

+#endif /* PNG_DEBUG */

+#ifndef png_debug

+#define png_debug(l, m)

+#endif

+#ifndef png_debug1

+#define png_debug1(l, m, p1)

+#endif

+#ifndef png_debug2

+#define png_debug2(l, m, p1, p2)

+#endif

+extern PNG_EXPORT(png_bytep,png_sig_bytes) PNGARG((void));

+extern PNG_EXPORT(png_charp,png_get_copyright) PNGARG((png_structp png_ptr));

+extern PNG_EXPORT(png_charp,png_get_header_ver) PNGARG((png_structp png_ptr));

+extern PNG_EXPORT(png_charp,png_get_header_version) PNGARG((png_structp png_ptr));

+extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr));

+#ifdef PNG_MNG_FEATURES_SUPPORTED

+extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp

+   png_ptr, png_uint_32 mng_features_permitted));

+#endif

+/* For use in png_set_keep_unknown, added to version 1.2.6 */

+#define PNG_HANDLE_CHUNK_AS_DEFAULT   0

+#define PNG_HANDLE_CHUNK_NEVER        1

+#define PNG_HANDLE_CHUNK_IF_SAFE      2

+#define PNG_HANDLE_CHUNK_ALWAYS       3

+/* Added to version 1.2.0 */

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)

+#define PNG_ASM_FLAG_MMX_SUPPORT_COMPILED  0x01  /* not user-settable */

+#define PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU    0x02  /* not user-settable */

+#define PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  0x04

+#define PNG_ASM_FLAG_MMX_READ_INTERLACE    0x08

+#define PNG_ASM_FLAG_MMX_READ_FILTER_SUB   0x10

+#define PNG_ASM_FLAG_MMX_READ_FILTER_UP    0x20

+#define PNG_ASM_FLAG_MMX_READ_FILTER_AVG   0x40

+#define PNG_ASM_FLAG_MMX_READ_FILTER_PAETH 0x80

+#define PNG_ASM_FLAGS_INITIALIZED          0x80000000  /* not user-settable */

+#define PNG_MMX_READ_FLAGS ( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  \

+                           | PNG_ASM_FLAG_MMX_READ_INTERLACE    \

+                           | PNG_ASM_FLAG_MMX_READ_FILTER_SUB   \

+                           | PNG_ASM_FLAG_MMX_READ_FILTER_UP    \

+                           | PNG_ASM_FLAG_MMX_READ_FILTER_AVG   \

+                           | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH )

+#define PNG_MMX_WRITE_FLAGS ( 0 )

+#define PNG_MMX_FLAGS ( PNG_ASM_FLAG_MMX_SUPPORT_COMPILED \

+                      | PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU   \

+                      | PNG_MMX_READ_FLAGS                \

+                      | PNG_MMX_WRITE_FLAGS )

+#define PNG_SELECT_READ   1

+#define PNG_SELECT_WRITE  2

+#if !defined(PNG_1_0_X)

+/* pngget.c */

+extern PNG_EXPORT(png_uint_32,png_get_mmx_flagmask)

+   PNGARG((int flag_select, int *compilerID));

+/* pngget.c */

+extern PNG_EXPORT(png_uint_32,png_get_asm_flagmask)

+   PNGARG((int flag_select));

+/* pngget.c */

+extern PNG_EXPORT(png_uint_32,png_get_asm_flags)

+   PNGARG((png_structp png_ptr));

+/* pngget.c */

+extern PNG_EXPORT(png_byte,png_get_mmx_bitdepth_threshold)

+   PNGARG((png_structp png_ptr));

+/* pngget.c */

+extern PNG_EXPORT(png_uint_32,png_get_mmx_rowbytes_threshold)

+   PNGARG((png_structp png_ptr));

+/* pngset.c */

+extern PNG_EXPORT(void,png_set_asm_flags)

+   PNGARG((png_structp png_ptr, png_uint_32 asm_flags));

+/* pngset.c */

+extern PNG_EXPORT(void,png_set_mmx_thresholds)

+   PNGARG((png_structp png_ptr, png_byte mmx_bitdepth_threshold,

+   png_uint_32 mmx_rowbytes_threshold));

+#endif /* PNG_1_0_X */

+#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */

+#if !defined(PNG_1_0_X)

+/* png.c, pnggccrd.c, or pngvcrd.c */

+extern PNG_EXPORT(int,png_mmx_support) PNGARG((void));

+/* Strip the prepended error numbers ("#nnn ") from error and warning

+ * messages before passing them to the error or warning handler. */

+#ifdef PNG_ERROR_NUMBERS_SUPPORTED

+extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp

+   png_ptr, png_uint_32 strip_mode));

+#endif

+#endif /* PNG_1_0_X */

+/* Added at libpng-1.2.6 */

+#ifdef PNG_SET_USER_LIMITS_SUPPORTED

+extern PNG_EXPORT(void,png_set_user_limits) PNGARG((png_structp

+   png_ptr, png_uint_32 user_width_max, png_uint_32 user_height_max));

+extern PNG_EXPORT(png_uint_32,png_get_user_width_max) PNGARG((png_structp

+   png_ptr));

+extern PNG_EXPORT(png_uint_32,png_get_user_height_max) PNGARG((png_structp

+   png_ptr));

+#endif

+/* Maintainer: Put new public prototypes here ^, in libpng.3, and project defs */

+#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED

+/* With these routines we avoid an integer divide, which will be slower on

+ * most machines.  However, it does take more operations than the corresponding

+ * divide method, so it may be slower on a few RISC systems.  There are two

+ * shifts (by 8 or 16 bits) and an addition, versus a single integer divide.

+ *

+ * Note that the rounding factors are NOT supposed to be the same!  128 and

+ * 32768 are correct for the NODIV code; 127 and 32767 are correct for the

+ * standard method.

+ *

+ * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ]

+ */

+ /* fg and bg should be in `gamma 1.0' space; alpha is the opacity          */

+#  define png_composite(composite, fg, alpha, bg)                            \

+     { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) * (png_uint_16)(alpha) \

+                        +        (png_uint_16)(bg)*(png_uint_16)(255 -       \

+                        (png_uint_16)(alpha)) + (png_uint_16)128);           \

+       (composite) = (png_byte)((temp + (temp >> 8)) >> 8); }

+#  define png_composite_16(composite, fg, alpha, bg)                         \

+     { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) * (png_uint_32)(alpha) \

+                        + (png_uint_32)(bg)*(png_uint_32)(65535L -           \

+                        (png_uint_32)(alpha)) + (png_uint_32)32768L);        \

+       (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); }

+#else  /* standard method using integer division */

+#  define png_composite(composite, fg, alpha, bg)                            \

+     (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) +    \

+       (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) +       \

+       (png_uint_16)127) / 255)

+#  define png_composite_16(composite, fg, alpha, bg)                         \

+     (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \

+       (png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) +      \

+       (png_uint_32)32767) / (png_uint_32)65535L)

+#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */

+/* These next functions are used internally in the code.  They generally

+ * shouldn't be used unless you are writing code to add or replace some

+ * functionality in libpng.  More information about most functions can

+ * be found in the files where the functions are located.

+ */

+#if defined(PNG_INTERNAL)

+/* Various modes of operation.  Note that after an init, mode is set to

+ * zero automatically when the structure is created.

+ */

+#define PNG_HAVE_IHDR               0x01

+#define PNG_HAVE_PLTE               0x02

+#define PNG_HAVE_IDAT               0x04

+#define PNG_AFTER_IDAT              0x08

+#define PNG_HAVE_IEND               0x10

+#define PNG_HAVE_gAMA               0x20

+#define PNG_HAVE_cHRM               0x40

+#define PNG_HAVE_sRGB               0x80

+#define PNG_HAVE_CHUNK_HEADER      0x100

+#define PNG_WROTE_tIME             0x200

+#define PNG_WROTE_INFO_BEFORE_PLTE 0x400

+#define PNG_BACKGROUND_IS_GRAY     0x800

+#define PNG_HAVE_PNG_SIGNATURE    0x1000

+/* flags for the transformations the PNG library does on the image data */

+#define PNG_BGR                0x0001

+#define PNG_INTERLACE          0x0002

+#define PNG_PACK               0x0004

+#define PNG_SHIFT              0x0008

+#define PNG_SWAP_BYTES         0x0010

+#define PNG_INVERT_MONO        0x0020

+#define PNG_DITHER             0x0040

+#define PNG_BACKGROUND         0x0080

+#define PNG_BACKGROUND_EXPAND  0x0100

+                          /*   0x0200 unused */

+#define PNG_16_TO_8            0x0400

+#define PNG_RGBA               0x0800

+#define PNG_EXPAND             0x1000

+#define PNG_GAMMA              0x2000

+#define PNG_GRAY_TO_RGB        0x4000

+#define PNG_FILLER             0x8000L

+#define PNG_PACKSWAP          0x10000L

+#define PNG_SWAP_ALPHA        0x20000L

+#define PNG_STRIP_ALPHA       0x40000L

+#define PNG_INVERT_ALPHA      0x80000L

+#define PNG_USER_TRANSFORM   0x100000L

+#define PNG_RGB_TO_GRAY_ERR  0x200000L

+#define PNG_RGB_TO_GRAY_WARN 0x400000L

+#define PNG_RGB_TO_GRAY      0x600000L  /* two bits, RGB_TO_GRAY_ERR|WARN */

+                       /*    0x800000L     Unused */

+#define PNG_ADD_ALPHA       0x1000000L  /* Added to libpng-1.2.7 */

+                       /*   0x2000000L  unused */

+                       /*   0x4000000L  unused */

+                       /*   0x8000000L  unused */

+                       /*  0x10000000L  unused */

+                       /*  0x20000000L  unused */

+                       /*  0x40000000L  unused */

+/* flags for png_create_struct */

+#define PNG_STRUCT_PNG   0x0001

+#define PNG_STRUCT_INFO  0x0002

+/* Scaling factor for filter heuristic weighting calculations */

+#define PNG_WEIGHT_SHIFT 8

+#define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT))

+#define PNG_COST_SHIFT 3

+#define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT))

+/* flags for the png_ptr->flags rather than declaring a byte for each one */

+#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY     0x0001

+#define PNG_FLAG_ZLIB_CUSTOM_LEVEL        0x0002

+#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL    0x0004

+#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS  0x0008

+#define PNG_FLAG_ZLIB_CUSTOM_METHOD       0x0010

+#define PNG_FLAG_ZLIB_FINISHED            0x0020

+#define PNG_FLAG_ROW_INIT                 0x0040

+#define PNG_FLAG_FILLER_AFTER             0x0080

+#define PNG_FLAG_CRC_ANCILLARY_USE        0x0100

+#define PNG_FLAG_CRC_ANCILLARY_NOWARN     0x0200

+#define PNG_FLAG_CRC_CRITICAL_USE         0x0400

+#define PNG_FLAG_CRC_CRITICAL_IGNORE      0x0800

+#define PNG_FLAG_FREE_PLTE                0x1000

+#define PNG_FLAG_FREE_TRNS                0x2000

+#define PNG_FLAG_FREE_HIST                0x4000

+#define PNG_FLAG_KEEP_UNKNOWN_CHUNKS      0x8000L

+#define PNG_FLAG_KEEP_UNSAFE_CHUNKS       0x10000L

+#define PNG_FLAG_LIBRARY_MISMATCH         0x20000L

+#define PNG_FLAG_STRIP_ERROR_NUMBERS      0x40000L

+#define PNG_FLAG_STRIP_ERROR_TEXT         0x80000L

+#define PNG_FLAG_MALLOC_NULL_MEM_OK       0x100000L

+#define PNG_FLAG_ADD_ALPHA                0x200000L  /* Added to libpng-1.2.8 */

+#define PNG_FLAG_STRIP_ALPHA              0x400000L  /* Added to libpng-1.2.8 */

+                                  /*      0x800000L  unused */

+                                  /*     0x1000000L  unused */

+                                  /*     0x2000000L  unused */

+                                  /*     0x4000000L  unused */

+                                  /*     0x8000000L  unused */

+                                  /*    0x10000000L  unused */

+                                  /*    0x20000000L  unused */

+                                  /*    0x40000000L  unused */

+#define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \

+                                     PNG_FLAG_CRC_ANCILLARY_NOWARN)

+#define PNG_FLAG_CRC_CRITICAL_MASK  (PNG_FLAG_CRC_CRITICAL_USE | \

+                                     PNG_FLAG_CRC_CRITICAL_IGNORE)

+#define PNG_FLAG_CRC_MASK           (PNG_FLAG_CRC_ANCILLARY_MASK | \

+                                     PNG_FLAG_CRC_CRITICAL_MASK)

+/* save typing and make code easier to understand */

+#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \

+   abs((int)((c1).green) - (int)((c2).green)) + \

+   abs((int)((c1).blue) - (int)((c2).blue)))

+/* Added to libpng-1.2.6 JB */

+#define PNG_ROWBYTES(pixel_bits, width) \

+    ((pixel_bits) >= 8 ? \

+    ((width) * (((png_uint_32)(pixel_bits)) >> 3)) : \

+    (( ((width) * ((png_uint_32)(pixel_bits))) + 7) >> 3) )

+/* PNG_OUT_OF_RANGE returns true if value is outside the range

+   ideal-delta..ideal+delta.  Each argument is evaluated twice.

+   "ideal" and "delta" should be constants, normally simple

+   integers, "value" a variable. Added to libpng-1.2.6 JB */

+#define PNG_OUT_OF_RANGE(value, ideal, delta) \

+        ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) )

+/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */

+#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN)

+/* place to hold the signature string for a PNG file. */

+#ifdef PNG_USE_GLOBAL_ARRAYS

+   PNG_EXPORT_VAR (const png_byte FARDATA) png_sig[8];

+#else

+#define png_sig png_sig_bytes(NULL)

+#endif

+#endif /* PNG_NO_EXTERN */

+/* Constant strings for known chunk types.  If you need to add a chunk,

+ * define the name here, and add an invocation of the macro in png.c and

+ * wherever it's needed.

+ */

+#define PNG_IHDR const png_byte png_IHDR[5] = { 73,  72,  68,  82, '\0'}

+#define PNG_IDAT const png_byte png_IDAT[5] = { 73,  68,  65,  84, '\0'}

+#define PNG_IEND const png_byte png_IEND[5] = { 73,  69,  78,  68, '\0'}

+#define PNG_PLTE const png_byte png_PLTE[5] = { 80,  76,  84,  69, '\0'}

+#define PNG_bKGD const png_byte png_bKGD[5] = { 98,  75,  71,  68, '\0'}

+#define PNG_cHRM const png_byte png_cHRM[5] = { 99,  72,  82,  77, '\0'}

+#define PNG_gAMA const png_byte png_gAMA[5] = {103,  65,  77,  65, '\0'}

+#define PNG_hIST const png_byte png_hIST[5] = {104,  73,  83,  84, '\0'}

+#define PNG_iCCP const png_byte png_iCCP[5] = {105,  67,  67,  80, '\0'}

+#define PNG_iTXt const png_byte png_iTXt[5] = {105,  84,  88, 116, '\0'}

+#define PNG_oFFs const png_byte png_oFFs[5] = {111,  70,  70, 115, '\0'}

+#define PNG_pCAL const png_byte png_pCAL[5] = {112,  67,  65,  76, '\0'}

+#define PNG_sCAL const png_byte png_sCAL[5] = {115,  67,  65,  76, '\0'}

+#define PNG_pHYs const png_byte png_pHYs[5] = {112,  72,  89, 115, '\0'}

+#define PNG_sBIT const png_byte png_sBIT[5] = {115,  66,  73,  84, '\0'}

+#define PNG_sPLT const png_byte png_sPLT[5] = {115,  80,  76,  84, '\0'}

+#define PNG_sRGB const png_byte png_sRGB[5] = {115,  82,  71,  66, '\0'}

+#define PNG_tEXt const png_byte png_tEXt[5] = {116,  69,  88, 116, '\0'}

+#define PNG_tIME const png_byte png_tIME[5] = {116,  73,  77,  69, '\0'}

+#define PNG_tRNS const png_byte png_tRNS[5] = {116,  82,  78,  83, '\0'}

+#define PNG_zTXt const png_byte png_zTXt[5] = {122,  84,  88, 116, '\0'}

+#ifdef PNG_USE_GLOBAL_ARRAYS

+PNG_EXPORT_VAR (const png_byte FARDATA) png_IHDR[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_IDAT[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_IEND[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_PLTE[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_bKGD[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_cHRM[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_gAMA[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_hIST[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_iCCP[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_iTXt[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_oFFs[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_pCAL[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_sCAL[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_pHYs[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_sBIT[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_sPLT[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_sRGB[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_tEXt[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_tIME[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_tRNS[5];

+PNG_EXPORT_VAR (const png_byte FARDATA) png_zTXt[5];

+#endif /* PNG_USE_GLOBAL_ARRAYS */

+/* Inline macros to do direct reads of bytes from the input buffer.  These

+ * require that you are using an architecture that uses PNG byte ordering

+ * (MSB first) and supports unaligned data storage.  I think that PowerPC

+ * in big-endian mode and 680x0 are the only ones that will support this.

+ * The x86 line of processors definitely do not.  The png_get_int_32()

+ * routine also assumes we are using two's complement format for negative

+ * values, which is almost certainly true.

+ */

+#if defined(PNG_READ_BIG_ENDIAN_SUPPORTED)

+#  if defined(PNG_pCAL_SUPPORTED) || defined(PNG_oFFs_SUPPORTED)

+#    define png_get_int_32(buf) ( *((png_int_32p) (buf)))

+#  endif

+#  define png_get_uint_32(buf) ( *((png_uint_32p) (buf)))

+#  define png_get_uint_16(buf) ( *((png_uint_16p) (buf)))

+#else

+#  if defined(PNG_pCAL_SUPPORTED) || defined(PNG_oFFs_SUPPORTED)

+PNG_EXTERN png_int_32 png_get_int_32 PNGARG((png_bytep buf));

+#  endif

+PNG_EXTERN png_uint_32 png_get_uint_32 PNGARG((png_bytep buf));

+PNG_EXTERN png_uint_16 png_get_uint_16 PNGARG((png_bytep buf));

+#endif /* !PNG_READ_BIG_ENDIAN_SUPPORTED */

+PNG_EXTERN png_uint_32 png_get_uint_31 PNGARG((png_structp png_ptr,

+  png_bytep buf));

+/* Initialize png_ptr struct for reading, and allocate any other memory.

+ * (old interface - DEPRECATED - use png_create_read_struct instead).

+ */

+extern PNG_EXPORT(void,png_read_init) PNGARG((png_structp png_ptr));

+#undef png_read_init

+#define png_read_init(png_ptr) png_read_init_3(&png_ptr, \

+    PNG_LIBPNG_VER_STRING,  png_sizeof(png_struct));

+extern PNG_EXPORT(void,png_read_init_3) PNGARG((png_structpp ptr_ptr,

+    png_const_charp user_png_ver, png_size_t png_struct_size));

+extern PNG_EXPORT(void,png_read_init_2) PNGARG((png_structp png_ptr,

+    png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t

+    png_info_size));

+/* Initialize png_ptr struct for writing, and allocate any other memory.

+ * (old interface - DEPRECATED - use png_create_write_struct instead).

+ */

+extern PNG_EXPORT(void,png_write_init) PNGARG((png_structp png_ptr));

+#undef png_write_init

+#define png_write_init(png_ptr) png_write_init_3(&png_ptr, \

+    PNG_LIBPNG_VER_STRING, png_sizeof(png_struct));

+extern PNG_EXPORT(void,png_write_init_3) PNGARG((png_structpp ptr_ptr,

+    png_const_charp user_png_ver, png_size_t png_struct_size));

+extern PNG_EXPORT(void,png_write_init_2) PNGARG((png_structp png_ptr,

+    png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t

+    png_info_size));

+/* Allocate memory for an internal libpng struct */

+PNG_EXTERN png_voidp png_create_struct PNGARG((int type));

+/* Free memory from internal libpng struct */

+PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr));

+PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr

+  malloc_fn, png_voidp mem_ptr));

+PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr,

+   png_free_ptr free_fn, png_voidp mem_ptr));

+/* Free any memory that info_ptr points to and reset struct. */

+PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr,

+   png_infop info_ptr));

+#ifndef PNG_1_0_X

+/* Function to allocate memory for zlib. */

+PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items, uInt size));

+/* Function to free memory for zlib */

+PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr));

+#ifdef PNG_SIZE_T

+/* Function to convert a sizeof an item to png_sizeof item */

+   PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));

+#endif

+/* Next four functions are used internally as callbacks.  PNGAPI is required

+ * but not PNG_EXPORT.  PNGAPI added at libpng version 1.2.3. */

+PNG_EXTERN void PNGAPI png_default_read_data PNGARG((png_structp png_ptr,

+   png_bytep data, png_size_t length));

+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

+PNG_EXTERN void PNGAPI png_push_fill_buffer PNGARG((png_structp png_ptr,

+   png_bytep buffer, png_size_t length));

+#endif

+PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr,

+   png_bytep data, png_size_t length));

+#if defined(PNG_WRITE_FLUSH_SUPPORTED)

+#if !defined(PNG_NO_STDIO)

+PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr));

+#endif

+#endif

+#else /* PNG_1_0_X */

+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

+PNG_EXTERN void png_push_fill_buffer PNGARG((png_structp png_ptr,

+   png_bytep buffer, png_size_t length));

+#endif

+#endif /* PNG_1_0_X */

+/* Reset the CRC variable */

+PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr));

+/* Write the "data" buffer to whatever output you are using. */

+PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data,

+   png_size_t length));

+/* Read data from whatever input you are using into the "data" buffer */

+PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data,

+   png_size_t length));

+/* Read bytes into buf, and update png_ptr->crc */

+PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf,

+   png_size_t length));

+/* Decompress data in a chunk that uses compression */

+#if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \

+    defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED)

+PNG_EXTERN png_charp png_decompress_chunk PNGARG((png_structp png_ptr,

+   int comp_type, png_charp chunkdata, png_size_t chunklength,

+   png_size_t prefix_length, png_size_t *data_length));

+#endif

+/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */

+PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip));

+/* Read the CRC from the file and compare it to the libpng calculated CRC */

+PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr));

+/* Calculate the CRC over a section of data.  Note that we are only

+ * passing a maximum of 64K on systems that have this as a memory limit,

+ * since this is the maximum buffer size we can specify.

+ */

+PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr,

+   png_size_t length));

+#if defined(PNG_WRITE_FLUSH_SUPPORTED)

+PNG_EXTERN void png_flush PNGARG((png_structp png_ptr));

+#endif

+/* Place a 32-bit number into a buffer in PNG byte order (big-endian).

+ * The only currently known PNG chunks that use signed numbers are

+ * the ancillary extension chunks, oFFs and pCAL.

+ */

+PNG_EXTERN void png_save_uint_32 PNGARG((png_bytep buf, png_uint_32 i));

+#if defined(PNG_WRITE_pCAL_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED)

+PNG_EXTERN void png_save_int_32 PNGARG((png_bytep buf, png_int_32 i));

+#endif

+/* Place a 16-bit number into a buffer in PNG byte order.

+ * The parameter is declared unsigned int, not png_uint_16,

+ * just to avoid potential problems on pre-ANSI C compilers.

+ */

+PNG_EXTERN void png_save_uint_16 PNGARG((png_bytep buf, unsigned int i));

+/* simple function to write the signature */

+PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr));

+/* write various chunks */

+/* Write the IHDR chunk, and update the png_struct with the necessary

+ * information.

+ */

+PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width,

+   png_uint_32 height,

+   int bit_depth, int color_type, int compression_method, int filter_method,

+   int interlace_method));

+PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette,

+   png_uint_32 num_pal));

+PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data,

+   png_size_t length));

+PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr));

+#if defined(PNG_WRITE_gAMA_SUPPORTED)

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma));

+#endif

+#ifdef PNG_FIXED_POINT_SUPPORTED

+PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr, png_fixed_point

+    file_gamma));

+#endif

+#endif

+#if defined(PNG_WRITE_sBIT_SUPPORTED)

+PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit,

+   int color_type));

+#endif

+#if defined(PNG_WRITE_cHRM_SUPPORTED)

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr,

+   double white_x, double white_y,

+   double red_x, double red_y, double green_x, double green_y,

+   double blue_x, double blue_y));

+#endif

+#ifdef PNG_FIXED_POINT_SUPPORTED

+PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr,

+   png_fixed_point int_white_x, png_fixed_point int_white_y,

+   png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point

+   int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,

+   png_fixed_point int_blue_y));

+#endif

+#endif

+#if defined(PNG_WRITE_sRGB_SUPPORTED)

+PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr,

+   int intent));

+#endif

+#if defined(PNG_WRITE_iCCP_SUPPORTED)

+PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr,

+   png_charp name, int compression_type,

+   png_charp profile, int proflen));

+   /* Note to maintainer: profile should be png_bytep */

+#endif

+#if defined(PNG_WRITE_sPLT_SUPPORTED)

+PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr,

+   png_sPLT_tp palette));

+#endif

+#if defined(PNG_WRITE_tRNS_SUPPORTED)

+PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans,

+   png_color_16p values, int number, int color_type));

+#endif

+#if defined(PNG_WRITE_bKGD_SUPPORTED)

+PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr,

+   png_color_16p values, int color_type));

+#endif

+#if defined(PNG_WRITE_hIST_SUPPORTED)

+PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist,

+   int num_hist));

+#endif

+#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \

+    defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)

+PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr,

+   png_charp key, png_charpp new_key));

+#endif

+#if defined(PNG_WRITE_tEXt_SUPPORTED)

+PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key,

+   png_charp text, png_size_t text_len));

+#endif

+#if defined(PNG_WRITE_zTXt_SUPPORTED)

+PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key,

+   png_charp text, png_size_t text_len, int compression));

+#endif

+#if defined(PNG_WRITE_iTXt_SUPPORTED)

+PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr,

+   int compression, png_charp key, png_charp lang, png_charp lang_key,

+   png_charp text));

+#endif

+#if defined(PNG_TEXT_SUPPORTED)  /* Added at version 1.0.14 and 1.2.4 */

+PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_textp text_ptr, int num_text));

+#endif

+#if defined(PNG_WRITE_oFFs_SUPPORTED)

+PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr,

+   png_int_32 x_offset, png_int_32 y_offset, int unit_type));

+#endif

+#if defined(PNG_WRITE_pCAL_SUPPORTED)

+PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose,

+   png_int_32 X0, png_int_32 X1, int type, int nparams,

+   png_charp units, png_charpp params));

+#endif

+#if defined(PNG_WRITE_pHYs_SUPPORTED)

+PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr,

+   png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit,

+   int unit_type));

+#endif

+#if defined(PNG_WRITE_tIME_SUPPORTED)

+PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr,

+   png_timep mod_time));

+#endif

+#if defined(PNG_WRITE_sCAL_SUPPORTED)

+#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)

+PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr,

+   int unit, double width, double height));

+#else

+#ifdef PNG_FIXED_POINT_SUPPORTED

+PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr,

+   int unit, png_charp width, png_charp height));

+#endif

+#endif

+#endif

+/* Called when finished processing a row of data */

+PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr));

+/* Internal use only.   Called before first row of data */

+PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr));

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr));

+#endif

+/* combine a row of data, dealing with alpha, etc. if requested */

+PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row,

+   int mask));

+#if defined(PNG_READ_INTERLACING_SUPPORTED)

+/* expand an interlaced row */

+/* OLD pre-1.0.9 interface:

+PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info,

+   png_bytep row, int pass, png_uint_32 transformations));

+ */

+PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr));

+#endif

+/* GRR TO DO (2.0 or whenever):  simplify other internal calling interfaces */

+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)

+/* grab pixels out of a row for an interlaced pass */

+PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info,

+   png_bytep row, int pass));

+#endif

+/* unfilter a row */

+PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr,

+   png_row_infop row_info, png_bytep row, png_bytep prev_row, int filter));

+/* Choose the best filter to use and filter the row data */

+PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr,

+   png_row_infop row_info));

+/* Write out the filtered row. */

+PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr,

+   png_bytep filtered_row));

+/* finish a row while reading, dealing with interlacing passes, etc. */

+PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr));

+/* initialize the row buffers, etc. */

+PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr));

+/* optional call to update the users info structure */

+PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr,

+   png_infop info_ptr));

+/* these are the functions that do the transformations */

+#if defined(PNG_READ_FILLER_SUPPORTED)

+PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info,

+   png_bytep row, png_uint_32 filler, png_uint_32 flags));

+#endif

+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)

+PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info,

+   png_bytep row));

+#endif

+#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)

+PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info,

+   png_bytep row));

+#endif

+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)

+PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info,

+   png_bytep row));

+#endif

+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)

+PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info,

+   png_bytep row));

+#endif

+#if defined(PNG_WRITE_FILLER_SUPPORTED) || \

+    defined(PNG_READ_STRIP_ALPHA_SUPPORTED)

+PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info,

+   png_bytep row, png_uint_32 flags));

+#endif

+#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)

+PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, png_bytep row));

+#endif

+#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED)

+PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, png_bytep row));

+#endif

+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)

+PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, png_row_infop

+   row_info, png_bytep row));

+#endif

+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)

+PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info,

+   png_bytep row));

+#endif

+#if defined(PNG_READ_PACK_SUPPORTED)

+PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, png_bytep row));

+#endif

+#if defined(PNG_READ_SHIFT_SUPPORTED)

+PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row,

+   png_color_8p sig_bits));

+#endif

+#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)

+PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, png_bytep row));

+#endif

+#if defined(PNG_READ_16_TO_8_SUPPORTED)

+PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, png_bytep row));

+#endif

+#if defined(PNG_READ_DITHER_SUPPORTED)

+PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info,

+   png_bytep row, png_bytep palette_lookup, png_bytep dither_lookup));

+#  if defined(PNG_CORRECT_PALETTE_SUPPORTED)

+PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr,

+   png_colorp palette, int num_palette));

+#  endif

+#endif

+#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)

+PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, png_bytep row));

+#endif

+#if defined(PNG_WRITE_PACK_SUPPORTED)

+PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info,

+   png_bytep row, png_uint_32 bit_depth));

+#endif

+#if defined(PNG_WRITE_SHIFT_SUPPORTED)

+PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row,

+   png_color_8p bit_depth));

+#endif

+#if defined(PNG_READ_BACKGROUND_SUPPORTED)

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row,

+   png_color_16p trans_values, png_color_16p background,

+   png_color_16p background_1,

+   png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,

+   png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,

+   png_uint_16pp gamma_16_to_1, int gamma_shift));

+#else

+PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row,

+   png_color_16p trans_values, png_color_16p background));

+#endif

+#endif

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row,

+   png_bytep gamma_table, png_uint_16pp gamma_16_table,

+   int gamma_shift));

+#endif

+#if defined(PNG_READ_EXPAND_SUPPORTED)

+PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info,

+   png_bytep row, png_colorp palette, png_bytep trans, int num_trans));

+PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info,

+   png_bytep row, png_color_16p trans_value));

+#endif

+/* The following decodes the appropriate chunks, and does error correction,

+ * then calls the appropriate callback for the chunk if it is valid.

+ */

+/* decode the IHDR chunk */

+PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+#if defined(PNG_READ_bKGD_SUPPORTED)

+PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+#endif

+#if defined(PNG_READ_cHRM_SUPPORTED)

+PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+#endif

+#if defined(PNG_READ_gAMA_SUPPORTED)

+PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+#endif

+#if defined(PNG_READ_hIST_SUPPORTED)

+PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+#endif

+#if defined(PNG_READ_iCCP_SUPPORTED)

+extern void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+#endif /* PNG_READ_iCCP_SUPPORTED */

+#if defined(PNG_READ_iTXt_SUPPORTED)

+PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+#endif

+#if defined(PNG_READ_oFFs_SUPPORTED)

+PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+#endif

+#if defined(PNG_READ_pCAL_SUPPORTED)

+PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+#endif

+#if defined(PNG_READ_pHYs_SUPPORTED)

+PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+#endif

+#if defined(PNG_READ_sBIT_SUPPORTED)

+PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+#endif

+#if defined(PNG_READ_sCAL_SUPPORTED)

+PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+#endif

+#if defined(PNG_READ_sPLT_SUPPORTED)

+extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+#endif /* PNG_READ_sPLT_SUPPORTED */

+#if defined(PNG_READ_sRGB_SUPPORTED)

+PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+#endif

+#if defined(PNG_READ_tEXt_SUPPORTED)

+PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+#endif

+#if defined(PNG_READ_tIME_SUPPORTED)

+PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+#endif

+#if defined(PNG_READ_tRNS_SUPPORTED)

+PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+#endif

+#if defined(PNG_READ_zTXt_SUPPORTED)

+PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 length));

+#endif

+PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_uint_32 length));

+PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr,

+   png_bytep chunk_name));

+/* handle the transformations for reading and writing */

+PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr));

+PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr));

+PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr));

+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

+PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr,

+   png_infop info_ptr));

+PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr,

+   png_infop info_ptr));

+PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr));

+PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr,

+   png_uint_32 length));

+PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr));

+PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr));

+PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr,

+   png_bytep buffer, png_size_t buffer_length));

+PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr));

+PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr,

+   png_bytep buffer, png_size_t buffer_length));

+PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr));

+PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_uint_32 length));

+PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr,

+   png_infop info_ptr));

+PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr,

+   png_infop info_ptr));

+PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row));

+PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr,

+   png_infop info_ptr));

+PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr,

+   png_infop info_ptr));

+PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr));

+#if defined(PNG_READ_tEXt_SUPPORTED)

+PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_uint_32 length));

+PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr,

+   png_infop info_ptr));

+#endif

+#if defined(PNG_READ_zTXt_SUPPORTED)

+PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_uint_32 length));

+PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr,

+   png_infop info_ptr));

+#endif

+#if defined(PNG_READ_iTXt_SUPPORTED)

+PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr,

+   png_infop info_ptr, png_uint_32 length));

+PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr,

+   png_infop info_ptr));

+#endif

+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

+#ifdef PNG_MNG_FEATURES_SUPPORTED

+PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info,

+   png_bytep row));

+PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info,

+   png_bytep row));

+#endif

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)

+/* png.c */ /* PRIVATE */

+PNG_EXTERN void png_init_mmx_flags PNGARG((png_structp png_ptr));

+#endif

+/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */

+#endif /* PNG_INTERNAL */

+#ifdef __cplusplus

+}

+#endif

+#endif /* PNG_VERSION_INFO_ONLY */

+/* do not put anything past this line */

+#endif /* PNG_H */

binary files /dev/null b/src/gfx/libpng/pngbar.jpg differ

binary files /dev/null b/src/gfx/libpng/pngbar.png differ

--- /dev/null

+++ b/src/gfx/libpng/pngconf.h

@@ -1,0 +1,1438 @@

+/* pngconf.h - machine configurable file for libpng

+ *

+ * libpng version 1.2.8 - December 3, 2004

+ * For conditions of distribution and use, see copyright notice in png.h

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

+ */

+/* Any machine specific code is near the front of this file, so if you

+ * are configuring libpng for a machine, you may want to read the section

+ * starting here down to where it starts to typedef png_color, png_text,

+ * and png_info.

+ */

+#ifndef PNGCONF_H

+#define PNGCONF_H

+#define PNG_1_2_X

+/*

+ * PNG_USER_CONFIG has to be defined on the compiler command line. This

+ * includes the resource compiler for Windows DLL configurations.

+ */

+#ifdef PNG_USER_CONFIG

+#include "pngusr.h"

+#endif

+/*

+ * Added at libpng-1.2.8

+ *

+ * If you create a private DLL you need to define in "pngusr.h" the followings:

+ * #define PNG_USER_PRIVATEBUILD <Describes by whom and why this version of

+ *        the DLL was built>

+ *  e.g. #define PNG_USER_PRIVATEBUILD "Build by MyCompany for xyz reasons."

+ * #define PNG_USER_DLLFNAME_POSTFIX <two-letter postfix that serve to

+ *        distinguish your DLL from those of the official release. These

+ *        correspond to the trailing letters that come after the version

+ *        number and must match your private DLL name>

+ *  e.g. // private DLL "libpng13gx.dll"

+ *       #define PNG_USER_DLLFNAME_POSTFIX "gx"

+ *

+ * The following macros are also at your disposal if you want to complete the

+ * DLL VERSIONINFO structure.

+ * - PNG_USER_VERSIONINFO_COMMENTS

+ * - PNG_USER_VERSIONINFO_COMPANYNAME

+ * - PNG_USER_VERSIONINFO_LEGALTRADEMARKS

+ */

+#ifdef __STDC__

+#ifdef SPECIALBUILD

+#  pragma message("PNG_LIBPNG_SPECIALBUILD (and deprecated SPECIALBUILD)\

+ are now LIBPNG reserved macros. Use PNG_USER_PRIVATEBUILD instead.")

+#endif

+#ifdef PRIVATEBUILD

+# pragma message("PRIVATEBUILD is deprecated. Use\

+ PNG_USER_PRIVATEBUILD instead.")

+# define PNG_USER_PRIVATEBUILD PRIVATEBUILD

+#endif

+#endif /* __STDC__ */

+#ifndef PNG_VERSION_INFO_ONLY

+/* End of material added to libpng-1.2.8 */

+/* This is the size of the compression buffer, and thus the size of

+ * an IDAT chunk.  Make this whatever size you feel is best for your

+ * machine.  One of these will be allocated per png_struct.  When this

+ * is full, it writes the data to the disk, and does some other

+ * calculations.  Making this an extremely small size will slow

+ * the library down, but you may want to experiment to determine

+ * where it becomes significant, if you are concerned with memory

+ * usage.  Note that zlib allocates at least 32Kb also.  For readers,

+ * this describes the size of the buffer available to read the data in.

+ * Unless this gets smaller than the size of a row (compressed),

+ * it should not make much difference how big this is.

+ */

+#ifndef PNG_ZBUF_SIZE

+#  define PNG_ZBUF_SIZE 8192

+#endif

+/* Enable if you want a write-only libpng */

+#ifndef PNG_NO_READ_SUPPORTED

+#  define PNG_READ_SUPPORTED

+#endif

+/* Enable if you want a read-only libpng */

+#ifndef PNG_NO_WRITE_SUPPORTED

+#  define PNG_WRITE_SUPPORTED

+#endif

+/* Enabled by default in 1.2.0.  You can disable this if you don't need to

+   support PNGs that are embedded in MNG datastreams */

+#if !defined(PNG_1_0_X) && !defined(PNG_NO_MNG_FEATURES)

+#  ifndef PNG_MNG_FEATURES_SUPPORTED

+#    define PNG_MNG_FEATURES_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_FLOATING_POINT_SUPPORTED

+#  ifndef PNG_FLOATING_POINT_SUPPORTED

+#    define PNG_FLOATING_POINT_SUPPORTED

+#  endif

+#endif

+/* If you are running on a machine where you cannot allocate more

+ * than 64K of memory at once, uncomment this.  While libpng will not

+ * normally need that much memory in a chunk (unless you load up a very

+ * large file), zlib needs to know how big of a chunk it can use, and

+ * libpng thus makes sure to check any memory allocation to verify it

+ * will fit into memory.

+#define PNG_MAX_MALLOC_64K

+ */

+#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)

+#  define PNG_MAX_MALLOC_64K

+#endif

+/* Special munging to support doing things the 'cygwin' way:

+ * 'Normal' png-on-win32 defines/defaults:

+ *   PNG_BUILD_DLL -- building dll

+ *   PNG_USE_DLL   -- building an application, linking to dll

+ *   (no define)   -- building static library, or building an

+ *                    application and linking to the static lib

+ * 'Cygwin' defines/defaults:

+ *   PNG_BUILD_DLL -- (ignored) building the dll

+ *   (no define)   -- (ignored) building an application, linking to the dll

+ *   PNG_STATIC    -- (ignored) building the static lib, or building an

+ *                    application that links to the static lib.

+ *   ALL_STATIC    -- (ignored) building various static libs, or building an

+ *                    application that links to the static libs.

+ * Thus,

+ * a cygwin user should define either PNG_BUILD_DLL or PNG_STATIC, and

+ * this bit of #ifdefs will define the 'correct' config variables based on

+ * that. If a cygwin user *wants* to define 'PNG_USE_DLL' that's okay, but

+ * unnecessary.

+ *

+ * Also, the precedence order is:

+ *   ALL_STATIC (since we can't #undef something outside our namespace)

+ *   PNG_BUILD_DLL

+ *   PNG_STATIC

+ *   (nothing) == PNG_USE_DLL

+ *

+ * CYGWIN (2002-01-20): The preceding is now obsolete. With the advent

+ *   of auto-import in binutils, we no longer need to worry about

+ *   __declspec(dllexport) / __declspec(dllimport) and friends.  Therefore,

+ *   we don't need to worry about PNG_STATIC or ALL_STATIC when it comes

+ *   to __declspec() stuff.  However, we DO need to worry about

+ *   PNG_BUILD_DLL and PNG_STATIC because those change some defaults

+ *   such as CONSOLE_IO and whether GLOBAL_ARRAYS are allowed.

+ */

+#if defined(__CYGWIN__)

+#  if defined(ALL_STATIC)

+#    if defined(PNG_BUILD_DLL)

+#      undef PNG_BUILD_DLL

+#    endif

+#    if defined(PNG_USE_DLL)

+#      undef PNG_USE_DLL

+#    endif

+#    if defined(PNG_DLL)

+#      undef PNG_DLL

+#    endif

+#    if !defined(PNG_STATIC)

+#      define PNG_STATIC

+#    endif

+#  else

+#    if defined (PNG_BUILD_DLL)

+#      if defined(PNG_STATIC)

+#        undef PNG_STATIC

+#      endif

+#      if defined(PNG_USE_DLL)

+#        undef PNG_USE_DLL

+#      endif

+#      if !defined(PNG_DLL)

+#        define PNG_DLL

+#      endif

+#    else

+#      if defined(PNG_STATIC)

+#        if defined(PNG_USE_DLL)

+#          undef PNG_USE_DLL

+#        endif

+#        if defined(PNG_DLL)

+#          undef PNG_DLL

+#        endif

+#      else

+#        if !defined(PNG_USE_DLL)

+#          define PNG_USE_DLL

+#        endif

+#        if !defined(PNG_DLL)

+#          define PNG_DLL

+#        endif

+#      endif

+#    endif

+#  endif

+#endif

+/* This protects us against compilers that run on a windowing system

+ * and thus don't have or would rather us not use the stdio types:

+ * stdin, stdout, and stderr.  The only one currently used is stderr

+ * in png_error() and png_warning().  #defining PNG_NO_CONSOLE_IO will

+ * prevent these from being compiled and used. #defining PNG_NO_STDIO

+ * will also prevent these, plus will prevent the entire set of stdio

+ * macros and functions (FILE *, printf, etc.) from being compiled and used,

+ * unless (PNG_DEBUG > 0) has been #defined.

+ *

+ * #define PNG_NO_CONSOLE_IO

+ * #define PNG_NO_STDIO

+ */

+#if defined(_WIN32_WCE)

+#  include <windows.h>

+   /* Console I/O functions are not supported on WindowsCE */

+#  define PNG_NO_CONSOLE_IO

+#  ifdef PNG_DEBUG

+#    undef PNG_DEBUG

+#  endif

+#endif

+#ifdef PNG_BUILD_DLL

+#  ifndef PNG_CONSOLE_IO_SUPPORTED

+#    ifndef PNG_NO_CONSOLE_IO

+#      define PNG_NO_CONSOLE_IO

+#    endif

+#  endif

+#endif

+#  ifdef PNG_NO_STDIO

+#    ifndef PNG_NO_CONSOLE_IO

+#      define PNG_NO_CONSOLE_IO

+#    endif

+#    ifdef PNG_DEBUG

+#      if (PNG_DEBUG > 0)

+#        include <stdio.h>

+#      endif

+#    endif

+#  else

+#    if !defined(_WIN32_WCE)

+/* "stdio.h" functions are not supported on WindowsCE */

+#      include <stdio.h>

+#    endif

+#  endif

+/* This macro protects us against machines that don't have function

+ * prototypes (ie K&R style headers).  If your compiler does not handle

+ * function prototypes, define this macro and use the included ansi2knr.

+ * I've always been able to use _NO_PROTO as the indicator, but you may

+ * need to drag the empty declaration out in front of here, or change the

+ * ifdef to suit your own needs.

+ */

+#define PNGARG(arglist) arglist

+#ifndef PNGARG

+#ifdef OF /* zlib prototype munger */

+#  define PNGARG(arglist) OF(arglist)

+#else

+#ifdef _NO_PROTO

+#  define PNGARG(arglist) ()

+#  ifndef PNG_TYPECAST_NULL

+#     define PNG_TYPECAST_NULL

+#  endif

+#else

+#  define PNGARG(arglist) arglist

+#endif /* _NO_PROTO */

+#endif /* OF */

+#endif /* PNGARG */

+/* Try to determine if we are compiling on a Mac.  Note that testing for

+ * just __MWERKS__ is not good enough, because the Codewarrior is now used

+ * on non-Mac platforms.

+ */

+#ifndef MACOS

+#  if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \

+      defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC)

+#    define MACOS

+#  endif

+#endif

+/* enough people need this for various reasons to include it here */

+#if !defined(MACOS) && !defined(RISCOS) && !defined(_WIN32_WCE)

+#  include <sys/types.h>

+#endif

+#if !defined(PNG_SETJMP_NOT_SUPPORTED) && !defined(PNG_NO_SETJMP_SUPPORTED)

+#  define PNG_SETJMP_SUPPORTED

+#endif

+#ifdef PNG_SETJMP_SUPPORTED

+/* This is an attempt to force a single setjmp behaviour on Linux.  If

+ * the X config stuff didn't define _BSD_SOURCE we wouldn't need this.

+ */

+#  ifdef __linux__

+#    ifdef _BSD_SOURCE

+#      define PNG_SAVE_BSD_SOURCE

+#      undef _BSD_SOURCE

+#    endif

+#    ifdef _SETJMP_H

+     /* If you encounter a compiler error here, see the explanation

+      * near the end of INSTALL.

+      */

+         __png.h__ already includes setjmp.h;

+         __dont__ include it again.;

+#    endif

+#  endif /* __linux__ */

+   /* include setjmp.h for error handling */

+#  include <setjmp.h>

+#  ifdef __linux__

+#    ifdef PNG_SAVE_BSD_SOURCE

+#      define _BSD_SOURCE

+#      undef PNG_SAVE_BSD_SOURCE

+#    endif

+#  endif /* __linux__ */

+#endif /* PNG_SETJMP_SUPPORTED */

+#ifdef BSD

+#  include <strings.h>

+#else

+#  include <string.h>

+#endif

+/* Other defines for things like memory and the like can go here.  */

+#ifdef PNG_INTERNAL

+#include <stdlib.h>

+/* The functions exported by PNG_EXTERN are PNG_INTERNAL functions, which

+ * aren't usually used outside the library (as far as I know), so it is

+ * debatable if they should be exported at all.  In the future, when it is

+ * possible to have run-time registry of chunk-handling functions, some of

+ * these will be made available again.

+#define PNG_EXTERN extern

+ */

+#define PNG_EXTERN

+/* Other defines specific to compilers can go here.  Try to keep

+ * them inside an appropriate ifdef/endif pair for portability.

+ */

+#if defined(PNG_FLOATING_POINT_SUPPORTED)

+#  if defined(MACOS)

+     /* We need to check that <math.h> hasn't already been included earlier

+      * as it seems it doesn't agree with <fp.h>, yet we should really use

+      * <fp.h> if possible.

+      */

+#    if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__)

+#      include <fp.h>

+#    endif

+#  else

+#    include <math.h>

+#  endif

+#  if defined(_AMIGA) && defined(__SASC) && defined(_M68881)

+     /* Amiga SAS/C: We must include builtin FPU functions when compiling using

+      * MATH=68881

+      */

+#    include <m68881.h>

+#  endif

+#endif

+/* Codewarrior on NT has linking problems without this. */

+#if (defined(__MWERKS__) && defined(WIN32)) || defined(__STDC__)

+#  define PNG_ALWAYS_EXTERN

+#endif

+/* This provides the non-ANSI (far) memory allocation routines. */

+#if defined(__TURBOC__) && defined(__MSDOS__)

+#  include <mem.h>

+#  include <alloc.h>

+#endif

+/* I have no idea why is this necessary... */

+#if defined(_MSC_VER) && (defined(WIN32) || defined(_Windows) || \

+    defined(_WINDOWS) || defined(_WIN32) || defined(__WIN32__))

+#  include <malloc.h>

+#endif

+/* This controls how fine the dithering gets.  As this allocates

+ * a largish chunk of memory (32K), those who are not as concerned

+ * with dithering quality can decrease some or all of these.

+ */

+#ifndef PNG_DITHER_RED_BITS

+#  define PNG_DITHER_RED_BITS 5

+#endif

+#ifndef PNG_DITHER_GREEN_BITS

+#  define PNG_DITHER_GREEN_BITS 5

+#endif

+#ifndef PNG_DITHER_BLUE_BITS

+#  define PNG_DITHER_BLUE_BITS 5

+#endif

+/* This controls how fine the gamma correction becomes when you

+ * are only interested in 8 bits anyway.  Increasing this value

+ * results in more memory being used, and more pow() functions

+ * being called to fill in the gamma tables.  Don't set this value

+ * less then 8, and even that may not work (I haven't tested it).

+ */

+#ifndef PNG_MAX_GAMMA_8

+#  define PNG_MAX_GAMMA_8 11

+#endif

+/* This controls how much a difference in gamma we can tolerate before

+ * we actually start doing gamma conversion.

+ */

+#ifndef PNG_GAMMA_THRESHOLD

+#  define PNG_GAMMA_THRESHOLD 0.05

+#endif

+#endif /* PNG_INTERNAL */

+/* The following uses const char * instead of char * for error

+ * and warning message functions, so some compilers won't complain.

+ * If you do not want to use const, define PNG_NO_CONST here.

+ */

+#ifndef PNG_NO_CONST

+#  define PNG_CONST const

+#else

+#  define PNG_CONST

+#endif

+/* The following defines give you the ability to remove code from the

+ * library that you will not be using.  I wish I could figure out how to

+ * automate this, but I can't do that without making it seriously hard

+ * on the users.  So if you are not using an ability, change the #define

+ * to and #undef, and that part of the library will not be compiled.  If

+ * your linker can't find a function, you may want to make sure the

+ * ability is defined here.  Some of these depend upon some others being

+ * defined.  I haven't figured out all the interactions here, so you may

+ * have to experiment awhile to get everything to compile.  If you are

+ * creating or using a shared library, you probably shouldn't touch this,

+ * as it will affect the size of the structures, and this will cause bad

+ * things to happen if the library and/or application ever change.

+ */

+/* Any features you will not be using can be undef'ed here */

+/* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user

+ * to turn it off with "*TRANSFORMS_NOT_SUPPORTED" or *PNG_NO_*_TRANSFORMS

+ * on the compile line, then pick and choose which ones to define without

+ * having to edit this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED

+ * if you only want to have a png-compliant reader/writer but don't need

+ * any of the extra transformations.  This saves about 80 kbytes in a

+ * typical installation of the library. (PNG_NO_* form added in version

+ * 1.0.1c, for consistency)

+ */

+/* The size of the png_text structure changed in libpng-1.0.6 when

+ * iTXt is supported.  It is turned off by default, to support old apps

+ * that malloc the png_text structure instead of calling png_set_text()

+ * and letting libpng malloc it.  It will be turned on by default in

+ * libpng-1.3.0.

+ */

+#ifndef PNG_iTXt_SUPPORTED

+#  if !defined(PNG_READ_iTXt_SUPPORTED) && !defined(PNG_NO_READ_iTXt)

+#    define PNG_NO_READ_iTXt

+#  endif

+#  if !defined(PNG_WRITE_iTXt_SUPPORTED) && !defined(PNG_NO_WRITE_iTXt)

+#    define PNG_NO_WRITE_iTXt

+#  endif

+#endif

+/* The following support, added after version 1.0.0, can be turned off here en

+ * masse by defining PNG_LEGACY_SUPPORTED in case you need binary compatibility

+ * with old applications that require the length of png_struct and png_info

+ * to remain unchanged.

+ */

+#ifdef PNG_LEGACY_SUPPORTED

+#  define PNG_NO_FREE_ME

+#  define PNG_NO_READ_UNKNOWN_CHUNKS

+#  define PNG_NO_WRITE_UNKNOWN_CHUNKS

+#  define PNG_NO_READ_USER_CHUNKS

+#  define PNG_NO_READ_iCCP

+#  define PNG_NO_WRITE_iCCP

+#  define PNG_NO_READ_iTXt

+#  define PNG_NO_WRITE_iTXt

+#  define PNG_NO_READ_sCAL

+#  define PNG_NO_WRITE_sCAL

+#  define PNG_NO_READ_sPLT

+#  define PNG_NO_WRITE_sPLT

+#  define PNG_NO_INFO_IMAGE

+#  define PNG_NO_READ_RGB_TO_GRAY

+#  define PNG_NO_READ_USER_TRANSFORM

+#  define PNG_NO_WRITE_USER_TRANSFORM

+#  define PNG_NO_USER_MEM

+#  define PNG_NO_READ_EMPTY_PLTE

+#  define PNG_NO_MNG_FEATURES

+#  define PNG_NO_FIXED_POINT_SUPPORTED

+#endif

+/* Ignore attempt to turn off both floating and fixed point support */

+#if !defined(PNG_FLOATING_POINT_SUPPORTED) || \

+    !defined(PNG_NO_FIXED_POINT_SUPPORTED)

+#  define PNG_FIXED_POINT_SUPPORTED

+#endif

+#ifndef PNG_NO_FREE_ME

+#  define PNG_FREE_ME_SUPPORTED

+#endif

+#if defined(PNG_READ_SUPPORTED)

+#if !defined(PNG_READ_TRANSFORMS_NOT_SUPPORTED) && \

+      !defined(PNG_NO_READ_TRANSFORMS)

+#  define PNG_READ_TRANSFORMS_SUPPORTED

+#endif

+#ifdef PNG_READ_TRANSFORMS_SUPPORTED

+#  ifndef PNG_NO_READ_EXPAND

+#    define PNG_READ_EXPAND_SUPPORTED

+#  endif

+#  ifndef PNG_NO_READ_SHIFT

+#    define PNG_READ_SHIFT_SUPPORTED

+#  endif

+#  ifndef PNG_NO_READ_PACK

+#    define PNG_READ_PACK_SUPPORTED

+#  endif

+#  ifndef PNG_NO_READ_BGR

+#    define PNG_READ_BGR_SUPPORTED

+#  endif

+#  ifndef PNG_NO_READ_SWAP

+#    define PNG_READ_SWAP_SUPPORTED

+#  endif

+#  ifndef PNG_NO_READ_PACKSWAP

+#    define PNG_READ_PACKSWAP_SUPPORTED

+#  endif

+#  ifndef PNG_NO_READ_INVERT

+#    define PNG_READ_INVERT_SUPPORTED

+#  endif

+#  ifndef PNG_NO_READ_DITHER

+#    define PNG_READ_DITHER_SUPPORTED

+#  endif

+#  ifndef PNG_NO_READ_BACKGROUND

+#    define PNG_READ_BACKGROUND_SUPPORTED

+#  endif

+#  ifndef PNG_NO_READ_16_TO_8

+#    define PNG_READ_16_TO_8_SUPPORTED

+#  endif

+#  ifndef PNG_NO_READ_FILLER

+#    define PNG_READ_FILLER_SUPPORTED

+#  endif

+#  ifndef PNG_NO_READ_GAMMA

+#    define PNG_READ_GAMMA_SUPPORTED

+#  endif

+#  ifndef PNG_NO_READ_GRAY_TO_RGB

+#    define PNG_READ_GRAY_TO_RGB_SUPPORTED

+#  endif

+#  ifndef PNG_NO_READ_SWAP_ALPHA

+#    define PNG_READ_SWAP_ALPHA_SUPPORTED

+#  endif

+#  ifndef PNG_NO_READ_INVERT_ALPHA

+#    define PNG_READ_INVERT_ALPHA_SUPPORTED

+#  endif

+#  ifndef PNG_NO_READ_STRIP_ALPHA

+#    define PNG_READ_STRIP_ALPHA_SUPPORTED

+#  endif

+#  ifndef PNG_NO_READ_USER_TRANSFORM

+#    define PNG_READ_USER_TRANSFORM_SUPPORTED

+#  endif

+#  ifndef PNG_NO_READ_RGB_TO_GRAY

+#    define PNG_READ_RGB_TO_GRAY_SUPPORTED

+#  endif

+#endif /* PNG_READ_TRANSFORMS_SUPPORTED */

+#if !defined(PNG_NO_PROGRESSIVE_READ) && \

+ !defined(PNG_PROGRESSIVE_READ_NOT_SUPPORTED)  /* if you don't do progressive */

+#  define PNG_PROGRESSIVE_READ_SUPPORTED     /* reading.  This is not talking */

+#endif                               /* about interlacing capability!  You'll */

+              /* still have interlacing unless you change the following line: */

+#define PNG_READ_INTERLACING_SUPPORTED /* required for PNG-compliant decoders */

+#ifndef PNG_NO_READ_COMPOSITE_NODIV

+#  ifndef PNG_NO_READ_COMPOSITED_NODIV  /* libpng-1.0.x misspelling */

+#    define PNG_READ_COMPOSITE_NODIV_SUPPORTED   /* well tested on Intel, SGI */

+#  endif

+#endif

+/* Deprecated, will be removed from version 2.0.0.

+   Use PNG_MNG_FEATURES_SUPPORTED instead. */

+#ifndef PNG_NO_READ_EMPTY_PLTE

+#  define PNG_READ_EMPTY_PLTE_SUPPORTED

+#endif

+#endif /* PNG_READ_SUPPORTED */

+#if defined(PNG_WRITE_SUPPORTED)

+# if !defined(PNG_WRITE_TRANSFORMS_NOT_SUPPORTED) && \

+    !defined(PNG_NO_WRITE_TRANSFORMS)

+#  define PNG_WRITE_TRANSFORMS_SUPPORTED

+#endif

+#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED

+#  ifndef PNG_NO_WRITE_SHIFT

+#    define PNG_WRITE_SHIFT_SUPPORTED

+#  endif

+#  ifndef PNG_NO_WRITE_PACK

+#    define PNG_WRITE_PACK_SUPPORTED

+#  endif

+#  ifndef PNG_NO_WRITE_BGR

+#    define PNG_WRITE_BGR_SUPPORTED

+#  endif

+#  ifndef PNG_NO_WRITE_SWAP

+#    define PNG_WRITE_SWAP_SUPPORTED

+#  endif

+#  ifndef PNG_NO_WRITE_PACKSWAP

+#    define PNG_WRITE_PACKSWAP_SUPPORTED

+#  endif

+#  ifndef PNG_NO_WRITE_INVERT

+#    define PNG_WRITE_INVERT_SUPPORTED

+#  endif

+#  ifndef PNG_NO_WRITE_FILLER

+#    define PNG_WRITE_FILLER_SUPPORTED   /* same as WRITE_STRIP_ALPHA */

+#  endif

+#  ifndef PNG_NO_WRITE_SWAP_ALPHA

+#    define PNG_WRITE_SWAP_ALPHA_SUPPORTED

+#  endif

+#  ifndef PNG_NO_WRITE_INVERT_ALPHA

+#    define PNG_WRITE_INVERT_ALPHA_SUPPORTED

+#  endif

+#  ifndef PNG_NO_WRITE_USER_TRANSFORM

+#    define PNG_WRITE_USER_TRANSFORM_SUPPORTED

+#  endif

+#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */

+#define PNG_WRITE_INTERLACING_SUPPORTED  /* not required for PNG-compliant

+                                            encoders, but can cause trouble

+                                            if left undefined */

+#if !defined(PNG_NO_WRITE_WEIGHTED_FILTER) && \

+     defined(PNG_FLOATING_POINT_SUPPORTED)

+#  define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED

+#endif

+#ifndef PNG_NO_WRITE_FLUSH

+#  define PNG_WRITE_FLUSH_SUPPORTED

+#endif

+/* Deprecated, see PNG_MNG_FEATURES_SUPPORTED, above */

+#ifndef PNG_NO_WRITE_EMPTY_PLTE

+#  define PNG_WRITE_EMPTY_PLTE_SUPPORTED

+#endif

+#endif /* PNG_WRITE_SUPPORTED */

+#ifndef PNG_1_0_X

+#  ifndef PNG_NO_ERROR_NUMBERS

+#    define PNG_ERROR_NUMBERS_SUPPORTED

+#  endif

+#endif /* PNG_1_0_X */

+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \

+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

+#  ifndef PNG_NO_USER_TRANSFORM_PTR

+#    define PNG_USER_TRANSFORM_PTR_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_STDIO

+#  define PNG_TIME_RFC1123_SUPPORTED

+#endif

+/* This adds extra functions in pngget.c for accessing data from the

+ * info pointer (added in version 0.99)

+ * png_get_image_width()

+ * png_get_image_height()

+ * png_get_bit_depth()

+ * png_get_color_type()

+ * png_get_compression_type()

+ * png_get_filter_type()

+ * png_get_interlace_type()

+ * png_get_pixel_aspect_ratio()

+ * png_get_pixels_per_meter()

+ * png_get_x_offset_pixels()

+ * png_get_y_offset_pixels()

+ * png_get_x_offset_microns()

+ * png_get_y_offset_microns()

+ */

+#if !defined(PNG_NO_EASY_ACCESS) && !defined(PNG_EASY_ACCESS_SUPPORTED)

+#  define PNG_EASY_ACCESS_SUPPORTED

+#endif

+/* PNG_ASSEMBLER_CODE was enabled by default in version 1.2.0

+   even when PNG_USE_PNGVCRD or PNG_USE_PNGGCCRD is not defined */

+#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_ASSEMBLER_CODE)

+#  ifndef PNG_ASSEMBLER_CODE_SUPPORTED

+#    define PNG_ASSEMBLER_CODE_SUPPORTED

+#  endif

+#  if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE)

+#    define PNG_MMX_CODE_SUPPORTED

+#  endif

+#endif

+/* If you are sure that you don't need thread safety and you are compiling

+   with PNG_USE_PNGCCRD for an MMX application, you can define this for

+   faster execution.  See pnggccrd.c.

+#define PNG_THREAD_UNSAFE_OK

+*/

+#if !defined(PNG_1_0_X)

+#if !defined(PNG_NO_USER_MEM) && !defined(PNG_USER_MEM_SUPPORTED)

+#  define PNG_USER_MEM_SUPPORTED

+#endif

+#endif /* PNG_1_0_X */

+/* Added at libpng-1.2.6 */

+#if !defined(PNG_1_0_X)

+#ifndef PNG_SET_USER_LIMITS_SUPPORTED

+#if !defined(PNG_NO_SET_USER_LIMITS) && !defined(PNG_SET_USER_LIMITS_SUPPORTED)

+#  define PNG_SET_USER_LIMITS_SUPPORTED

+#endif

+#endif

+#endif /* PNG_1_0_X */

+/* Added at libpng-1.0.16 and 1.2.6.  To accept all valid PNGS no matter

+ * how large, set these limits to 0x7fffffffL

+ */

+#ifndef PNG_USER_WIDTH_MAX

+#  define PNG_USER_WIDTH_MAX 1000000L

+#endif

+#ifndef PNG_USER_HEIGHT_MAX

+#  define PNG_USER_HEIGHT_MAX 1000000L

+#endif

+/* These are currently experimental features, define them if you want */

+/* very little testing */

+/*

+#ifdef PNG_READ_SUPPORTED

+#  ifndef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED

+#    define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED

+#  endif

+#endif

+*/

+/* This is only for PowerPC big-endian and 680x0 systems */

+/* some testing */

+/*

+#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED

+#  define PNG_READ_BIG_ENDIAN_SUPPORTED

+#endif

+*/

+/* Buggy compilers (e.g., gcc 2.7.2.2) need this */

+/*

+#define PNG_NO_POINTER_INDEXING

+*/

+/* These functions are turned off by default, as they will be phased out. */

+/*

+#define  PNG_USELESS_TESTS_SUPPORTED

+#define  PNG_CORRECT_PALETTE_SUPPORTED

+*/

+/* Any chunks you are not interested in, you can undef here.  The

+ * ones that allocate memory may be expecially important (hIST,

+ * tEXt, zTXt, tRNS, pCAL).  Others will just save time and make png_info

+ * a bit smaller.

+ */

+#if defined(PNG_READ_SUPPORTED) && \

+    !defined(PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \

+    !defined(PNG_NO_READ_ANCILLARY_CHUNKS)

+#  define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED

+#endif

+#if defined(PNG_WRITE_SUPPORTED) && \

+    !defined(PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \

+    !defined(PNG_NO_WRITE_ANCILLARY_CHUNKS)

+#  define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED

+#endif

+#ifdef PNG_READ_ANCILLARY_CHUNKS_SUPPORTED

+#ifdef PNG_NO_READ_TEXT

+#  define PNG_NO_READ_iTXt

+#  define PNG_NO_READ_tEXt

+#  define PNG_NO_READ_zTXt

+#endif

+#ifndef PNG_NO_READ_bKGD

+#  define PNG_READ_bKGD_SUPPORTED

+#  define PNG_bKGD_SUPPORTED

+#endif

+#ifndef PNG_NO_READ_cHRM

+#  define PNG_READ_cHRM_SUPPORTED

+#  define PNG_cHRM_SUPPORTED

+#endif

+#ifndef PNG_NO_READ_gAMA

+#  define PNG_READ_gAMA_SUPPORTED

+#  define PNG_gAMA_SUPPORTED

+#endif

+#ifndef PNG_NO_READ_hIST

+#  define PNG_READ_hIST_SUPPORTED

+#  define PNG_hIST_SUPPORTED

+#endif

+#ifndef PNG_NO_READ_iCCP

+#  define PNG_READ_iCCP_SUPPORTED

+#  define PNG_iCCP_SUPPORTED

+#endif

+#ifndef PNG_NO_READ_iTXt

+#  ifndef PNG_READ_iTXt_SUPPORTED

+#    define PNG_READ_iTXt_SUPPORTED

+#  endif

+#  ifndef PNG_iTXt_SUPPORTED

+#    define PNG_iTXt_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_READ_oFFs

+#  define PNG_READ_oFFs_SUPPORTED

+#  define PNG_oFFs_SUPPORTED

+#endif

+#ifndef PNG_NO_READ_pCAL

+#  define PNG_READ_pCAL_SUPPORTED

+#  define PNG_pCAL_SUPPORTED

+#endif

+#ifndef PNG_NO_READ_sCAL

+#  define PNG_READ_sCAL_SUPPORTED

+#  define PNG_sCAL_SUPPORTED

+#endif

+#ifndef PNG_NO_READ_pHYs

+#  define PNG_READ_pHYs_SUPPORTED

+#  define PNG_pHYs_SUPPORTED

+#endif

+#ifndef PNG_NO_READ_sBIT

+#  define PNG_READ_sBIT_SUPPORTED

+#  define PNG_sBIT_SUPPORTED

+#endif

+#ifndef PNG_NO_READ_sPLT

+#  define PNG_READ_sPLT_SUPPORTED

+#  define PNG_sPLT_SUPPORTED

+#endif

+#ifndef PNG_NO_READ_sRGB

+#  define PNG_READ_sRGB_SUPPORTED

+#  define PNG_sRGB_SUPPORTED

+#endif

+#ifndef PNG_NO_READ_tEXt

+#  define PNG_READ_tEXt_SUPPORTED

+#  define PNG_tEXt_SUPPORTED

+#endif

+#ifndef PNG_NO_READ_tIME

+#  define PNG_READ_tIME_SUPPORTED

+#  define PNG_tIME_SUPPORTED

+#endif

+#ifndef PNG_NO_READ_tRNS

+#  define PNG_READ_tRNS_SUPPORTED

+#  define PNG_tRNS_SUPPORTED

+#endif

+#ifndef PNG_NO_READ_zTXt

+#  define PNG_READ_zTXt_SUPPORTED

+#  define PNG_zTXt_SUPPORTED

+#endif

+#ifndef PNG_NO_READ_UNKNOWN_CHUNKS

+#  define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED

+#  ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED

+#    define PNG_UNKNOWN_CHUNKS_SUPPORTED

+#  endif

+#  ifndef PNG_NO_HANDLE_AS_UNKNOWN

+#    define PNG_HANDLE_AS_UNKNOWN_SUPPORTED

+#  endif

+#endif

+#if !defined(PNG_NO_READ_USER_CHUNKS) && \

+     defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)

+#  define PNG_READ_USER_CHUNKS_SUPPORTED

+#  define PNG_USER_CHUNKS_SUPPORTED

+#  ifdef PNG_NO_READ_UNKNOWN_CHUNKS

+#    undef PNG_NO_READ_UNKNOWN_CHUNKS

+#  endif

+#  ifdef PNG_NO_HANDLE_AS_UNKNOWN

+#    undef PNG_NO_HANDLE_AS_UNKNOWN

+#  endif

+#endif

+#ifndef PNG_NO_READ_OPT_PLTE

+#  define PNG_READ_OPT_PLTE_SUPPORTED /* only affects support of the */

+#endif                      /* optional PLTE chunk in RGB and RGBA images */

+#if defined(PNG_READ_iTXt_SUPPORTED) || defined(PNG_READ_tEXt_SUPPORTED) || \

+    defined(PNG_READ_zTXt_SUPPORTED)

+#  define PNG_READ_TEXT_SUPPORTED

+#  define PNG_TEXT_SUPPORTED

+#endif

+#endif /* PNG_READ_ANCILLARY_CHUNKS_SUPPORTED */

+#ifdef PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED

+#ifdef PNG_NO_WRITE_TEXT

+#  define PNG_NO_WRITE_iTXt

+#  define PNG_NO_WRITE_tEXt

+#  define PNG_NO_WRITE_zTXt

+#endif

+#ifndef PNG_NO_WRITE_bKGD

+#  define PNG_WRITE_bKGD_SUPPORTED

+#  ifndef PNG_bKGD_SUPPORTED

+#    define PNG_bKGD_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_WRITE_cHRM

+#  define PNG_WRITE_cHRM_SUPPORTED

+#  ifndef PNG_cHRM_SUPPORTED

+#    define PNG_cHRM_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_WRITE_gAMA

+#  define PNG_WRITE_gAMA_SUPPORTED

+#  ifndef PNG_gAMA_SUPPORTED

+#    define PNG_gAMA_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_WRITE_hIST

+#  define PNG_WRITE_hIST_SUPPORTED

+#  ifndef PNG_hIST_SUPPORTED

+#    define PNG_hIST_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_WRITE_iCCP

+#  define PNG_WRITE_iCCP_SUPPORTED

+#  ifndef PNG_iCCP_SUPPORTED

+#    define PNG_iCCP_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_WRITE_iTXt

+#  ifndef PNG_WRITE_iTXt_SUPPORTED

+#    define PNG_WRITE_iTXt_SUPPORTED

+#  endif

+#  ifndef PNG_iTXt_SUPPORTED

+#    define PNG_iTXt_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_WRITE_oFFs

+#  define PNG_WRITE_oFFs_SUPPORTED

+#  ifndef PNG_oFFs_SUPPORTED

+#    define PNG_oFFs_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_WRITE_pCAL

+#  define PNG_WRITE_pCAL_SUPPORTED

+#  ifndef PNG_pCAL_SUPPORTED

+#    define PNG_pCAL_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_WRITE_sCAL

+#  define PNG_WRITE_sCAL_SUPPORTED

+#  ifndef PNG_sCAL_SUPPORTED

+#    define PNG_sCAL_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_WRITE_pHYs

+#  define PNG_WRITE_pHYs_SUPPORTED

+#  ifndef PNG_pHYs_SUPPORTED

+#    define PNG_pHYs_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_WRITE_sBIT

+#  define PNG_WRITE_sBIT_SUPPORTED

+#  ifndef PNG_sBIT_SUPPORTED

+#    define PNG_sBIT_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_WRITE_sPLT

+#  define PNG_WRITE_sPLT_SUPPORTED

+#  ifndef PNG_sPLT_SUPPORTED

+#    define PNG_sPLT_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_WRITE_sRGB

+#  define PNG_WRITE_sRGB_SUPPORTED

+#  ifndef PNG_sRGB_SUPPORTED

+#    define PNG_sRGB_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_WRITE_tEXt

+#  define PNG_WRITE_tEXt_SUPPORTED

+#  ifndef PNG_tEXt_SUPPORTED

+#    define PNG_tEXt_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_WRITE_tIME

+#  define PNG_WRITE_tIME_SUPPORTED

+#  ifndef PNG_tIME_SUPPORTED

+#    define PNG_tIME_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_WRITE_tRNS

+#  define PNG_WRITE_tRNS_SUPPORTED

+#  ifndef PNG_tRNS_SUPPORTED

+#    define PNG_tRNS_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_WRITE_zTXt

+#  define PNG_WRITE_zTXt_SUPPORTED

+#  ifndef PNG_zTXt_SUPPORTED

+#    define PNG_zTXt_SUPPORTED

+#  endif

+#endif

+#ifndef PNG_NO_WRITE_UNKNOWN_CHUNKS

+#  define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED

+#  ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED

+#    define PNG_UNKNOWN_CHUNKS_SUPPORTED

+#  endif

+#  ifndef PNG_NO_HANDLE_AS_UNKNOWN

+#     ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

+#       define PNG_HANDLE_AS_UNKNOWN_SUPPORTED

+#     endif

+#  endif

+#endif

+#if defined(PNG_WRITE_iTXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \

+    defined(PNG_WRITE_zTXt_SUPPORTED)

+#  define PNG_WRITE_TEXT_SUPPORTED

+#  ifndef PNG_TEXT_SUPPORTED

+#    define PNG_TEXT_SUPPORTED

+#  endif

+#endif

+#endif /* PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED */

+/* Turn this off to disable png_read_png() and

+ * png_write_png() and leave the row_pointers member

+ * out of the info structure.

+ */

+#ifndef PNG_NO_INFO_IMAGE

+#  define PNG_INFO_IMAGE_SUPPORTED

+#endif

+/* need the time information for reading tIME chunks */

+#if defined(PNG_tIME_SUPPORTED)

+#  if !defined(_WIN32_WCE)

+     /* "time.h" functions are not supported on WindowsCE */

+#    include <time.h>

+#  endif

+#endif

+/* Some typedefs to get us started.  These should be safe on most of the

+ * common platforms.  The typedefs should be at least as large as the

+ * numbers suggest (a png_uint_32 must be at least 32 bits long), but they

+ * don't have to be exactly that size.  Some compilers dislike passing

+ * unsigned shorts as function parameters, so you may be better off using

+ * unsigned int for png_uint_16.  Likewise, for 64-bit systems, you may

+ * want to have unsigned int for png_uint_32 instead of unsigned long.

+ */

+typedef unsigned long png_uint_32;

+typedef long png_int_32;

+typedef unsigned short png_uint_16;

+typedef short png_int_16;

+typedef unsigned char png_byte;

+/* This is usually size_t.  It is typedef'ed just in case you need it to

+   change (I'm not sure if you will or not, so I thought I'd be safe) */

+#ifdef PNG_SIZE_T

+   typedef PNG_SIZE_T png_size_t;

+#  define png_sizeof(x) png_convert_size(sizeof (x))

+#else

+   typedef size_t png_size_t;

+#  define png_sizeof(x) sizeof (x)

+#endif

+/* The following is needed for medium model support.  It cannot be in the

+ * PNG_INTERNAL section.  Needs modification for other compilers besides

+ * MSC.  Model independent support declares all arrays and pointers to be

+ * large using the far keyword.  The zlib version used must also support

+ * model independent data.  As of version zlib 1.0.4, the necessary changes

+ * have been made in zlib.  The USE_FAR_KEYWORD define triggers other

+ * changes that are needed. (Tim Wegner)

+ */

+/* Separate compiler dependencies (problem here is that zlib.h always

+   defines FAR. (SJT) */

+#ifdef __BORLANDC__

+#  if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__)

+#    define LDATA 1

+#  else

+#    define LDATA 0

+#  endif

+   /* GRR:  why is Cygwin in here?  Cygwin is not Borland C... */

+#  if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__)

+#    define PNG_MAX_MALLOC_64K

+#    if (LDATA != 1)

+#      ifndef FAR

+#        define FAR __far

+#      endif

+#      define USE_FAR_KEYWORD

+#    endif   /* LDATA != 1 */

+     /* Possibly useful for moving data out of default segment.

+      * Uncomment it if you want. Could also define FARDATA as

+      * const if your compiler supports it. (SJT)

+#    define FARDATA FAR

+      */

+#  endif  /* __WIN32__, __FLAT__, __CYGWIN__ */

+#endif   /* __BORLANDC__ */

+/* Suggest testing for specific compiler first before testing for

+ * FAR.  The Watcom compiler defines both __MEDIUM__ and M_I86MM,

+ * making reliance oncertain keywords suspect. (SJT)

+ */

+/* MSC Medium model */

+#if defined(FAR)

+#  if defined(M_I86MM)

+#    define USE_FAR_KEYWORD

+#    define FARDATA FAR

+#    include <dos.h>

+#  endif

+#endif

+/* SJT: default case */

+#ifndef FAR

+#  define FAR

+#endif

+/* At this point FAR is always defined */

+#ifndef FARDATA

+#  define FARDATA

+#endif

+/* Typedef for floating-point numbers that are converted

+   to fixed-point with a multiple of 100,000, e.g., int_gamma */

+typedef png_int_32 png_fixed_point;

+/* Add typedefs for pointers */

+typedef void            FAR * png_voidp;

+typedef png_byte        FAR * png_bytep;

+typedef png_uint_32     FAR * png_uint_32p;

+typedef png_int_32      FAR * png_int_32p;

+typedef png_uint_16     FAR * png_uint_16p;

+typedef png_int_16      FAR * png_int_16p;

+typedef PNG_CONST char  FAR * png_const_charp;

+typedef char            FAR * png_charp;

+typedef png_fixed_point FAR * png_fixed_point_p;

+#ifndef PNG_NO_STDIO

+#if defined(_WIN32_WCE)

+typedef HANDLE                png_FILE_p;

+#else

+typedef FILE                * png_FILE_p;

+#endif

+#endif

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+typedef double          FAR * png_doublep;

+#endif

+/* Pointers to pointers; i.e. arrays */

+typedef png_byte        FAR * FAR * png_bytepp;

+typedef png_uint_32     FAR * FAR * png_uint_32pp;

+typedef png_int_32      FAR * FAR * png_int_32pp;

+typedef png_uint_16     FAR * FAR * png_uint_16pp;

+typedef png_int_16      FAR * FAR * png_int_16pp;

+typedef PNG_CONST char  FAR * FAR * png_const_charpp;

+typedef char            FAR * FAR * png_charpp;

+typedef png_fixed_point FAR * FAR * png_fixed_point_pp;

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+typedef double          FAR * FAR * png_doublepp;

+#endif

+/* Pointers to pointers to pointers; i.e., pointer to array */

+typedef char            FAR * FAR * FAR * png_charppp;

+#if defined(PNG_1_0_X) || defined(PNG_1_2_X)

+/* SPC -  Is this stuff deprecated? */

+/* It'll be removed as of libpng-1.3.0 - GR-P */

+/* libpng typedefs for types in zlib. If zlib changes

+ * or another compression library is used, then change these.

+ * Eliminates need to change all the source files.

+ */

+typedef charf *         png_zcharp;

+typedef charf * FAR *   png_zcharpp;

+typedef z_stream FAR *  png_zstreamp;

+#endif /* (PNG_1_0_X) || defined(PNG_1_2_X) */

+/*

+ * Define PNG_BUILD_DLL if the module being built is a Windows

+ * LIBPNG DLL.

+ *

+ * Define PNG_USE_DLL if you want to *link* to the Windows LIBPNG DLL.

+ * It is equivalent to Microsoft predefined macro _DLL that is

+ * automatically defined when you compile using the share

+ * version of the CRT (C Run-Time library)

+ *

+ * The cygwin mods make this behavior a little different:

+ * Define PNG_BUILD_DLL if you are building a dll for use with cygwin

+ * Define PNG_STATIC if you are building a static library for use with cygwin,

+ *   -or- if you are building an application that you want to link to the

+ *   static library.

+ * PNG_USE_DLL is defined by default (no user action needed) unless one of

+ *   the other flags is defined.

+ */

+#if !defined(PNG_DLL) && (defined(PNG_BUILD_DLL) || defined(PNG_USE_DLL))

+#  define PNG_DLL

+#endif

+/* If CYGWIN, then disallow GLOBAL ARRAYS unless building a static lib.

+ * When building a static lib, default to no GLOBAL ARRAYS, but allow

+ * command-line override

+ */

+#if defined(__CYGWIN__)

+#  if !defined(PNG_STATIC)

+#    if defined(PNG_USE_GLOBAL_ARRAYS)

+#      undef PNG_USE_GLOBAL_ARRAYS

+#    endif

+#    if !defined(PNG_USE_LOCAL_ARRAYS)

+#      define PNG_USE_LOCAL_ARRAYS

+#    endif

+#  else

+#    if defined(PNG_USE_LOCAL_ARRAYS) || defined(PNG_NO_GLOBAL_ARRAYS)

+#      if defined(PNG_USE_GLOBAL_ARRAYS)

+#        undef PNG_USE_GLOBAL_ARRAYS

+#      endif

+#    endif

+#  endif

+#  if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS)

+#    define PNG_USE_LOCAL_ARRAYS

+#  endif

+#endif

+/* Do not use global arrays (helps with building DLL's)

+ * They are no longer used in libpng itself, since version 1.0.5c,

+ * but might be required for some pre-1.0.5c applications.

+ */

+#if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS)

+#  if defined(PNG_NO_GLOBAL_ARRAYS) || (defined(__GNUC__) && defined(PNG_DLL))

+#    define PNG_USE_LOCAL_ARRAYS

+#  else

+#    define PNG_USE_GLOBAL_ARRAYS

+#  endif

+#endif

+#if defined(__CYGWIN__)

+#  undef PNGAPI

+#  define PNGAPI __cdecl

+#  undef PNG_IMPEXP

+#  define PNG_IMPEXP

+#endif

+/* If you define PNGAPI, e.g., with compiler option "-DPNGAPI=__stdcall",

+ * you may get warnings regarding the linkage of png_zalloc and png_zfree.

+ * Don't ignore those warnings; you must also reset the default calling

+ * convention in your compiler to match your PNGAPI, and you must build

+ * zlib and your applications the same way you build libpng.

+ */

+#if defined(__MINGW32__) && !defined(PNG_MODULEDEF)

+#  ifndef PNG_NO_MODULEDEF

+#    define PNG_NO_MODULEDEF

+#  endif

+#endif

+#if !defined(PNG_IMPEXP) && defined(PNG_BUILD_DLL) && !defined(PNG_NO_MODULEDEF)

+#  define PNG_IMPEXP

+#endif

+#if defined(PNG_DLL) || defined(_DLL) || defined(__DLL__ ) || \

+    (( defined(_Windows) || defined(_WINDOWS) || \

+       defined(WIN32) || defined(_WIN32) || defined(__WIN32__) ))

+#  ifndef PNGAPI

+#     if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800))

+#        define PNGAPI __cdecl

+#     else

+#        define PNGAPI _cdecl

+#     endif

+#  endif

+#  if !defined(PNG_IMPEXP) && (!defined(PNG_DLL) || \

+       0 /* WINCOMPILER_WITH_NO_SUPPORT_FOR_DECLIMPEXP */)

+#     define PNG_IMPEXP

+#  endif

+#  if !defined(PNG_IMPEXP)

+#     define PNG_EXPORT_TYPE1(type,symbol)  PNG_IMPEXP type PNGAPI symbol

+#     define PNG_EXPORT_TYPE2(type,symbol)  type PNG_IMPEXP PNGAPI symbol

+      /* Borland/Microsoft */

+#     if defined(_MSC_VER) || defined(__BORLANDC__)

+#        if (_MSC_VER >= 800) || (__BORLANDC__ >= 0x500)

+#           define PNG_EXPORT PNG_EXPORT_TYPE1

+#        else

+#           define PNG_EXPORT PNG_EXPORT_TYPE2

+#           if defined(PNG_BUILD_DLL)

+#              define PNG_IMPEXP __export

+#           else

+#              define PNG_IMPEXP /*__import */ /* doesn't exist AFAIK in

+                                                 VC++ */

+#           endif                             /* Exists in Borland C++ for

+                                                 C++ classes (== huge) */

+#        endif

+#     endif

+#     if !defined(PNG_IMPEXP)

+#        if defined(PNG_BUILD_DLL)

+#           define PNG_IMPEXP __declspec(dllexport)

+#        else

+#           define PNG_IMPEXP __declspec(dllimport)

+#        endif

+#     endif

+#  endif  /* PNG_IMPEXP */

+#else /* !(DLL || non-cygwin WINDOWS) */

+#   if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__)

+#      ifndef PNGAPI

+#         define PNGAPI _System

+#      endif

+#   else

+#      if 0 /* ... other platforms, with other meanings */

+#      endif

+#   endif

+#endif

+#ifndef PNGAPI

+#  define PNGAPI

+#endif

+#ifndef PNG_IMPEXP

+#  define PNG_IMPEXP

+#endif

+#ifdef PNG_BUILDSYMS

+#  ifndef PNG_EXPORT

+#    define PNG_EXPORT(type,symbol) PNG_FUNCTION_EXPORT symbol END

+#  endif

+#  ifdef PNG_USE_GLOBAL_ARRAYS

+#    ifndef PNG_EXPORT_VAR

+#      define PNG_EXPORT_VAR(type) PNG_DATA_EXPORT

+#    endif

+#  endif

+#endif

+#ifndef PNG_EXPORT

+#  define PNG_EXPORT(type,symbol) PNG_IMPEXP type PNGAPI symbol

+#endif

+#ifdef PNG_USE_GLOBAL_ARRAYS

+#  ifndef PNG_EXPORT_VAR

+#    define PNG_EXPORT_VAR(type) extern PNG_IMPEXP type

+#  endif

+#endif

+/* User may want to use these so they are not in PNG_INTERNAL. Any library

+ * functions that are passed far data must be model independent.

+ */

+#ifndef PNG_ABORT

+#  define PNG_ABORT() abort()

+#endif

+#ifdef PNG_SETJMP_SUPPORTED

+#  define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)

+#else

+#  define png_jmpbuf(png_ptr) \

+   (LIBPNG_WAS_COMPILED_WITH__PNG_SETJMP_NOT_SUPPORTED)

+#endif

+#if defined(USE_FAR_KEYWORD)  /* memory model independent fns */

+/* use this to make far-to-near assignments */

+#  define CHECK   1

+#  define NOCHECK 0

+#  define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK))

+#  define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK))

+#  define png_strcpy  _fstrcpy

+#  define png_strncpy _fstrncpy   /* Added to v 1.2.6 */

+#  define png_strlen  _fstrlen

+#  define png_memcmp  _fmemcmp    /* SJT: added */

+#  define png_memcpy  _fmemcpy

+#  define png_memset  _fmemset

+#else /* use the usual functions */

+#  define CVT_PTR(ptr)         (ptr)

+#  define CVT_PTR_NOCHECK(ptr) (ptr)

+#  define png_strcpy  strcpy

+#  define png_strncpy strncpy     /* Added to v 1.2.6 */

+#  define png_strlen  strlen

+#  define png_memcmp  memcmp      /* SJT: added */

+#  define png_memcpy  memcpy

+#  define png_memset  memset

+#endif

+/* End of memory model independent support */

+/* Just a little check that someone hasn't tried to define something

+ * contradictory.

+ */

+#if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K)

+#  undef PNG_ZBUF_SIZE

+#  define PNG_ZBUF_SIZE 65536L

+#endif

+#ifdef PNG_READ_SUPPORTED

+/* Prior to libpng-1.0.9, this block was in pngasmrd.h */

+#if defined(PNG_INTERNAL)

+/* These are the default thresholds before the MMX code kicks in; if either

+ * rowbytes or bitdepth is below the threshold, plain C code is used.  These

+ * can be overridden at runtime via the png_set_mmx_thresholds() call in

+ * libpng 1.2.0 and later.  The values below were chosen by Intel.

+ */

+#ifndef PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT

+#  define PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT  128  /*  >=  */

+#endif

+#ifndef PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT

+#  define PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT  9    /*  >=  */

+#endif

+/* Set this in the makefile for VC++ on Pentium, not here. */

+/* Platform must be Pentium.  Makefile must assemble and load pngvcrd.c .

+ * MMX will be detected at run time and used if present.

+ */

+#ifdef PNG_USE_PNGVCRD

+#  define PNG_HAVE_ASSEMBLER_COMBINE_ROW

+#  define PNG_HAVE_ASSEMBLER_READ_INTERLACE

+#  define PNG_HAVE_ASSEMBLER_READ_FILTER_ROW

+#endif

+/* Set this in the makefile for gcc/as on Pentium, not here. */

+/* Platform must be Pentium.  Makefile must assemble and load pnggccrd.c .

+ * MMX will be detected at run time and used if present.

+ */

+#ifdef PNG_USE_PNGGCCRD

+#  define PNG_HAVE_ASSEMBLER_COMBINE_ROW

+#  define PNG_HAVE_ASSEMBLER_READ_INTERLACE

+#  define PNG_HAVE_ASSEMBLER_READ_FILTER_ROW

+#endif

+/* - see pnggccrd.c for info about what is currently enabled */

+#endif /* PNG_INTERNAL */

+#endif /* PNG_READ_SUPPORTED */

+/* Added at libpng-1.2.8 */

+#endif /* PNG_VERSION_INFO_ONLY */

+#endif /* PNGCONF_H */

--- /dev/null

+++ b/src/gfx/libpng/pngerror.c

@@ -1,0 +1,295 @@

+/* pngerror.c - stub functions for i/o and memory allocation

+ *

+ * libpng version 1.2.8 - December 3, 2004

+ * For conditions of distribution and use, see copyright notice in png.h

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

+ *

+ * This file provides a location for all error handling.  Users who

+ * need special error handling are expected to write replacement functions

+ * and use png_set_error_fn() to use those functions.  See the instructions

+ * at each function.

+ */

+#define PNG_INTERNAL

+#include "png.h"

+static void /* PRIVATE */

+png_default_error PNGARG((png_structp png_ptr,

+  png_const_charp error_message));

+static void /* PRIVATE */

+png_default_warning PNGARG((png_structp png_ptr,

+  png_const_charp warning_message));

+/* This function is called whenever there is a fatal error.  This function

+ * should not be changed.  If there is a need to handle errors differently,

+ * you should supply a replacement error function and use png_set_error_fn()

+ * to replace the error function at run-time.

+ */

+void PNGAPI

+png_error(png_structp png_ptr, png_const_charp error_message)

+{

+#ifdef PNG_ERROR_NUMBERS_SUPPORTED

+   char msg[16];

+   if (png_ptr->flags&(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))

+   {

+     if (*error_message == '#')

+     {

+         int offset;

+         for (offset=1; offset<15; offset++)

+            if (*(error_message+offset) == ' ')

+                break;

+         if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)

+         {

+            int i;

+            for (i=0; i<offset-1; i++)

+               msg[i]=error_message[i+1];

+            msg[i]='\0';

+            error_message=msg;

+         }

+         else

+            error_message+=offset;

+     }

+     else

+     {

+         if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)

+         {

+            msg[0]='0';

+            msg[1]='\0';

+            error_message=msg;

+         }

+     }

+   }

+#endif

+   if (png_ptr != NULL && png_ptr->error_fn != NULL)

+      (*(png_ptr->error_fn))(png_ptr, error_message);

+   /* If the custom handler doesn't exist, or if it returns,

+      use the default handler, which will not return. */

+   png_default_error(png_ptr, error_message);

+}

+/* This function is called whenever there is a non-fatal error.  This function

+ * should not be changed.  If there is a need to handle warnings differently,

+ * you should supply a replacement warning function and use

+ * png_set_error_fn() to replace the warning function at run-time.

+ */

+void PNGAPI

+png_warning(png_structp png_ptr, png_const_charp warning_message)

+{

+   int offset = 0;

+#ifdef PNG_ERROR_NUMBERS_SUPPORTED

+   if (png_ptr->flags&(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))

+#endif

+   {

+     if (*warning_message == '#')

+     {

+         for (offset=1; offset<15; offset++)

+            if (*(warning_message+offset) == ' ')

+                break;

+     }

+   }

+   if (png_ptr != NULL && png_ptr->warning_fn != NULL)

+      (*(png_ptr->warning_fn))(png_ptr, warning_message+offset);

+   else

+      png_default_warning(png_ptr, warning_message+offset);

+}

+/* These utilities are used internally to build an error message that relates

+ * to the current chunk.  The chunk name comes from png_ptr->chunk_name,

+ * this is used to prefix the message.  The message is limited in length

+ * to 63 bytes, the name characters are output as hex digits wrapped in []

+ * if the character is invalid.

+ */

+#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))

+static PNG_CONST char png_digit[16] = {

+   '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',

+   'A', 'B', 'C', 'D', 'E', 'F'

+};

+static void /* PRIVATE */

+png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp

+   error_message)

+{

+   int iout = 0, iin = 0;

+   while (iin < 4)

+   {

+      int c = png_ptr->chunk_name[iin++];

+      if (isnonalpha(c))

+      {

+         buffer[iout++] = '[';

+         buffer[iout++] = png_digit[(c & 0xf0) >> 4];

+         buffer[iout++] = png_digit[c & 0x0f];

+         buffer[iout++] = ']';

+      }

+      else

+      {

+         buffer[iout++] = (png_byte)c;

+      }

+   }

+   if (error_message == NULL)

+      buffer[iout] = 0;

+   else

+   {

+      buffer[iout++] = ':';

+      buffer[iout++] = ' ';

+      png_strncpy(buffer+iout, error_message, 63);

+      buffer[iout+63] = 0;

+   }

+}

+void PNGAPI

+png_chunk_error(png_structp png_ptr, png_const_charp error_message)

+{

+   char msg[18+64];

+   png_format_buffer(png_ptr, msg, error_message);

+   png_error(png_ptr, msg);

+}

+void PNGAPI

+png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)

+{

+   char msg[18+64];

+   png_format_buffer(png_ptr, msg, warning_message);

+   png_warning(png_ptr, msg);

+}

+/* This is the default error handling function.  Note that replacements for

+ * this function MUST NOT RETURN, or the program will likely crash.  This

+ * function is used by default, or if the program supplies NULL for the

+ * error function pointer in png_set_error_fn().

+ */

+static void /* PRIVATE */

+png_default_error(png_structp png_ptr, png_const_charp error_message)

+{

+#ifndef PNG_NO_CONSOLE_IO

+#ifdef PNG_ERROR_NUMBERS_SUPPORTED

+   if (*error_message == '#')

+   {

+     int offset;

+     char error_number[16];

+     for (offset=0; offset<15; offset++)

+     {

+         error_number[offset] = *(error_message+offset+1);

+         if (*(error_message+offset) == ' ')

+             break;

+     }

+     if((offset > 1) && (offset < 15))

+     {

+       error_number[offset-1]='\0';

+       fprintf(stderr, "libpng error no. %s: %s\n", error_number,

+          error_message+offset);

+     }

+     else

+       fprintf(stderr, "libpng error: %s, offset=%d\n", error_message,offset);

+   }

+   else

+#endif

+   fprintf(stderr, "libpng error: %s\n", error_message);

+#endif

+#ifdef PNG_SETJMP_SUPPORTED

+#  ifdef USE_FAR_KEYWORD

+   {

+      jmp_buf jmpbuf;

+      png_memcpy(jmpbuf,png_ptr->jmpbuf,png_sizeof(jmp_buf));

+      longjmp(jmpbuf, 1);

+   }

+#  else

+   longjmp(png_ptr->jmpbuf, 1);

+# endif

+#else

+   /* make compiler happy */ ;

+   if (png_ptr)

+   PNG_ABORT();

+#endif

+#ifdef PNG_NO_CONSOLE_IO

+   /* make compiler happy */ ;

+   if (&error_message != NULL)

+      return;

+#endif

+}

+/* This function is called when there is a warning, but the library thinks

+ * it can continue anyway.  Replacement functions don't have to do anything

+ * here if you don't want them to.  In the default configuration, png_ptr is

+ * not used, but it is passed in case it may be useful.

+ */

+static void /* PRIVATE */

+png_default_warning(png_structp png_ptr, png_const_charp warning_message)

+{

+#ifndef PNG_NO_CONSOLE_IO

+#  ifdef PNG_ERROR_NUMBERS_SUPPORTED

+   if (*warning_message == '#')

+   {

+     int offset;

+     char warning_number[16];

+     for (offset=0; offset<15; offset++)

+     {

+        warning_number[offset]=*(warning_message+offset+1);

+        if (*(warning_message+offset) == ' ')

+            break;

+     }

+     if((offset > 1) && (offset < 15))

+     {

+       warning_number[offset-1]='\0';

+       fprintf(stderr, "libpng warning no. %s: %s\n", warning_number,

+          warning_message+offset);

+     }

+     else

+       fprintf(stderr, "libpng warning: %s\n", warning_message);

+   }

+   else

+#  endif

+     fprintf(stderr, "libpng warning: %s\n", warning_message);

+#else

+   /* make compiler happy */ ;

+   if (warning_message)

+     return;

+#endif

+   /* make compiler happy */ ;

+   if (png_ptr)

+      return;

+}

+/* This function is called when the application wants to use another method

+ * of handling errors and warnings.  Note that the error function MUST NOT

+ * return to the calling routine or serious problems will occur.  The return

+ * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1)

+ */

+void PNGAPI

+png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,

+   png_error_ptr error_fn, png_error_ptr warning_fn)

+{

+   png_ptr->error_ptr = error_ptr;

+   png_ptr->error_fn = error_fn;

+   png_ptr->warning_fn = warning_fn;

+}

+/* This function returns a pointer to the error_ptr associated with the user

+ * functions.  The application should free any memory associated with this

+ * pointer before png_write_destroy and png_read_destroy are called.

+ */

+png_voidp PNGAPI

+png_get_error_ptr(png_structp png_ptr)

+{

+   return ((png_voidp)png_ptr->error_ptr);

+}

+#ifdef PNG_ERROR_NUMBERS_SUPPORTED

+void PNGAPI

+png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)

+{

+   if(png_ptr != NULL)

+   {

+     png_ptr->flags &=

+       ((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);

+   }

+}

+#endif

--- /dev/null

+++ b/src/gfx/libpng/pnggccrd.c

@@ -1,0 +1,5408 @@

+/* pnggccrd.c - mixed C/assembler version of utilities to read a PNG file

+ *

+ * For Intel x86 CPU (Pentium-MMX or later) and GNU C compiler.

+ *

+ *     See http://www.intel.com/drg/pentiumII/appnotes/916/916.htm

+ *     and http://www.intel.com/drg/pentiumII/appnotes/923/923.htm

+ *     for Intel's performance analysis of the MMX vs. non-MMX code.

+ *

+ * libpng version 1.2.8 - December 3, 2004

+ * For conditions of distribution and use, see copyright notice in png.h

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * Copyright (c) 1998, Intel Corporation

+ *

+ * Based on MSVC code contributed by Nirav Chhatrapati, Intel Corp., 1998.

+ * Interface to libpng contributed by Gilles Vollant, 1999.

+ * GNU C port by Greg Roelofs, 1999-2001.

+ *

+ * Lines 2350-4300 converted in place with intel2gas 1.3.1:

+ *

+ *   intel2gas -mdI pnggccrd.c.partially-msvc -o pnggccrd.c

+ *

+ * and then cleaned up by hand.  See http://hermes.terminal.at/intel2gas/ .

+ *

+ * NOTE:  A sufficiently recent version of GNU as (or as.exe under DOS/Windows)

+ *        is required to assemble the newer MMX instructions such as movq.

+ *        For djgpp, see

+ *

+ *           ftp://ftp.simtel.net/pub/simtelnet/gnu/djgpp/v2gnu/bnu281b.zip

+ *

+ *        (or a later version in the same directory).  For Linux, check your

+ *        distribution's web site(s) or try these links:

+ *

+ *           http://rufus.w3.org/linux/RPM/binutils.html

+ *           http://www.debian.org/Packages/stable/devel/binutils.html

+ *           ftp://ftp.slackware.com/pub/linux/slackware/slackware/slakware/d1/

+ *             binutils.tgz

+ *

+ *        For other platforms, see the main GNU site:

+ *

+ *           ftp://ftp.gnu.org/pub/gnu/binutils/

+ *

+ *        Version 2.5.2l.15 is definitely too old...

+ */

+/*

+ * TEMPORARY PORTING NOTES AND CHANGELOG (mostly by Greg Roelofs)

+ * =====================================

+ *

+ * 19991006:

+ *  - fixed sign error in post-MMX cleanup code (16- & 32-bit cases)

+ *

+ * 19991007:

+ *  - additional optimizations (possible or definite):

+ *     x [DONE] write MMX code for 64-bit case (pixel_bytes == 8) [not tested]

+ *     - write MMX code for 48-bit case (pixel_bytes == 6)

+ *     - figure out what's up with 24-bit case (pixel_bytes == 3):

+ *        why subtract 8 from width_mmx in the pass 4/5 case?

+ *        (only width_mmx case) (near line 1606)

+ *     x [DONE] replace pixel_bytes within each block with the true

+ *        constant value (or are compilers smart enough to do that?)

+ *     - rewrite all MMX interlacing code so it's aligned with

+ *        the *beginning* of the row buffer, not the end.  This

+ *        would not only allow one to eliminate half of the memory

+ *        writes for odd passes (that is, pass == odd), it may also

+ *        eliminate some unaligned-data-access exceptions (assuming

+ *        there's a penalty for not aligning 64-bit accesses on

+ *        64-bit boundaries).  The only catch is that the "leftover"

+ *        pixel(s) at the end of the row would have to be saved,

+ *        but there are enough unused MMX registers in every case,

+ *        so this is not a problem.  A further benefit is that the

+ *        post-MMX cleanup code (C code) in at least some of the

+ *        cases could be done within the assembler block.

+ *  x [DONE] the "v3 v2 v1 v0 v7 v6 v5 v4" comments are confusing,

+ *     inconsistent, and don't match the MMX Programmer's Reference

+ *     Manual conventions anyway.  They should be changed to

+ *     "b7 b6 b5 b4 b3 b2 b1 b0," where b0 indicates the byte that

+ *     was lowest in memory (e.g., corresponding to a left pixel)

+ *     and b7 is the byte that was highest (e.g., a right pixel).

+ *

+ * 19991016:

+ *  - Brennan's Guide notwithstanding, gcc under Linux does *not*

+ *     want globals prefixed by underscores when referencing them--

+ *     i.e., if the variable is const4, then refer to it as const4,

+ *     not _const4.  This seems to be a djgpp-specific requirement.

+ *     Also, such variables apparently *must* be declared outside

+ *     of functions; neither static nor automatic variables work if

+ *     defined within the scope of a single function, but both

+ *     static and truly global (multi-module) variables work fine.

+ *

+ * 19991023:

+ *  - fixed png_combine_row() non-MMX replication bug (odd passes only?)

+ *  - switched from string-concatenation-with-macros to cleaner method of

+ *     renaming global variables for djgpp--i.e., always use prefixes in

+ *     inlined assembler code (== strings) and conditionally rename the

+ *     variables, not the other way around.  Hence _const4, _mask8_0, etc.

+ *

+ * 19991024:

+ *  - fixed mmxsupport()/png_do_read_interlace() first-row bug

+ *     This one was severely weird:  even though mmxsupport() doesn't touch

+ *     ebx (where "row" pointer was stored), it nevertheless managed to zero

+ *     the register (even in static/non-fPIC code--see below), which in turn

+ *     caused png_do_read_interlace() to return prematurely on the first row of

+ *     interlaced images (i.e., without expanding the interlaced pixels).

+ *     Inspection of the generated assembly code didn't turn up any clues,

+ *     although it did point at a minor optimization (i.e., get rid of

+ *     mmx_supported_local variable and just use eax).  Possibly the CPUID

+ *     instruction is more destructive than it looks?  (Not yet checked.)

+ *  - "info gcc" was next to useless, so compared fPIC and non-fPIC assembly

+ *     listings...  Apparently register spillage has to do with ebx, since

+ *     it's used to index the global offset table.  Commenting it out of the

+ *     input-reg lists in png_combine_row() eliminated compiler barfage, so

+ *     ifdef'd with __PIC__ macro:  if defined, use a global for unmask

+ *

+ * 19991107:

+ *  - verified CPUID clobberage:  12-char string constant ("GenuineIntel",

+ *     "AuthenticAMD", etc.) placed in ebx:ecx:edx.  Still need to polish.

+ *

+ * 19991120:

+ *  - made "diff" variable (now "_dif") global to simplify conversion of

+ *     filtering routines (running out of regs, sigh).  "diff" is still used

+ *     in interlacing routines, however.

+ *  - fixed up both versions of mmxsupport() (ORIG_THAT_USED_TO_CLOBBER_EBX

+ *     macro determines which is used); original not yet tested.

+ *

+ * 20000213:

+ *  - when compiling with gcc, be sure to use  -fomit-frame-pointer

+ *

+ * 20000319:

+ *  - fixed a register-name typo in png_do_read_interlace(), default (MMX) case,

+ *     pass == 4 or 5, that caused visible corruption of interlaced images

+ *

+ * 20000623:

+ *  - Various problems were reported with gcc 2.95.2 in the Cygwin environment,

+ *     many of the form "forbidden register 0 (ax) was spilled for class AREG."

+ *     This is explained at http://gcc.gnu.org/fom_serv/cache/23.html, and

+ *     Chuck Wilson supplied a patch involving dummy output registers.  See

+ *     http://sourceforge.net/bugs/?func=detailbug&bug_id=108741&group_id=5624

+ *     for the original (anonymous) SourceForge bug report.

+ *

+ * 20000706:

+ *  - Chuck Wilson passed along these remaining gcc 2.95.2 errors:

+ *       pnggccrd.c: In function `png_combine_row':

+ *       pnggccrd.c:525: more than 10 operands in `asm'

+ *       pnggccrd.c:669: more than 10 operands in `asm'

+ *       pnggccrd.c:828: more than 10 operands in `asm'

+ *       pnggccrd.c:994: more than 10 operands in `asm'

+ *       pnggccrd.c:1177: more than 10 operands in `asm'

+ *     They are all the same problem and can be worked around by using the

+ *     global _unmask variable unconditionally, not just in the -fPIC case.

+ *     Reportedly earlier versions of gcc also have the problem with more than

+ *     10 operands; they just don't report it.  Much strangeness ensues, etc.

+ *

+ * 20000729:

+ *  - enabled png_read_filter_row_mmx_up() (shortest remaining unconverted

+ *     MMX routine); began converting png_read_filter_row_mmx_sub()

+ *  - to finish remaining sections:

+ *     - clean up indentation and comments

+ *     - preload local variables

+ *     - add output and input regs (order of former determines numerical

+ *        mapping of latter)

+ *     - avoid all usage of ebx (including bx, bh, bl) register [20000823]

+ *     - remove "$" from addressing of Shift and Mask variables [20000823]

+ *

+ * 20000731:

+ *  - global union vars causing segfaults in png_read_filter_row_mmx_sub()?

+ *

+ * 20000822:

+ *  - ARGH, stupid png_read_filter_row_mmx_sub() segfault only happens with

+ *     shared-library (-fPIC) version!  Code works just fine as part of static

+ *     library.  Damn damn damn damn damn, should have tested that sooner.

+ *     ebx is getting clobbered again (explicitly this time); need to save it

+ *     on stack or rewrite asm code to avoid using it altogether.  Blargh!

+ *

+ * 20000823:

+ *  - first section was trickiest; all remaining sections have ebx -> edx now.

+ *     (-fPIC works again.)  Also added missing underscores to various Shift*

+ *     and *Mask* globals and got rid of leading "$" signs.

+ *

+ * 20000826:

+ *  - added visual separators to help navigate microscopic printed copies

+ *     (http://pobox.com/~newt/code/gpr-latest.zip, mode 10); started working

+ *     on png_read_filter_row_mmx_avg()

+ *

+ * 20000828:

+ *  - finished png_read_filter_row_mmx_avg():  only Paeth left! (930 lines...)

+ *     What the hell, did png_read_filter_row_mmx_paeth(), too.  Comments not

+ *     cleaned up/shortened in either routine, but functionality is complete

+ *     and seems to be working fine.

+ *

+ * 20000829:

+ *  - ahhh, figured out last(?) bit of gcc/gas asm-fu:  if register is listed

+ *     as an input reg (with dummy output variables, etc.), then it *cannot*

+ *     also appear in the clobber list or gcc 2.95.2 will barf.  The solution

+ *     is simple enough...

+ *

+ * 20000914:

+ *  - bug in png_read_filter_row_mmx_avg():  16-bit grayscale not handled

+ *     correctly (but 48-bit RGB just fine)

+ *

+ * 20000916:

+ *  - fixed bug in png_read_filter_row_mmx_avg(), bpp == 2 case; three errors:

+ *     - "_ShiftBpp.use = 24;"      should have been   "_ShiftBpp.use = 16;"

+ *     - "_ShiftRem.use = 40;"      should have been   "_ShiftRem.use = 48;"

+ *     - "psllq _ShiftRem, %%mm2"   should have been   "psrlq _ShiftRem, %%mm2"

+ *

+ * 20010101:

+ *  - added new png_init_mmx_flags() function (here only because it needs to

+ *     call mmxsupport(), which should probably become global png_mmxsupport());

+ *     modified other MMX routines to run conditionally (png_ptr->asm_flags)

+ *

+ * 20010103:

+ *  - renamed mmxsupport() to png_mmx_support(), with auto-set of mmx_supported,

+ *     and made it public; moved png_init_mmx_flags() to png.c as internal func

+ *

+ * 20010104:

+ *  - removed dependency on png_read_filter_row_c() (C code already duplicated

+ *     within MMX version of png_read_filter_row()) so no longer necessary to

+ *     compile it into pngrutil.o

+ *

+ * 20010310:

+ *  - fixed buffer-overrun bug in png_combine_row() C code (non-MMX)

+ *

+ * 20020304:

+ *  - eliminated incorrect use of width_mmx in pixel_bytes == 8 case

+ *

+ * 20040724:

+ *   - more tinkering with clobber list at lines 4529 and 5033, to get

+ *     it to compile on gcc-3.4.

+ *

+ * STILL TO DO:

+ *     - test png_do_read_interlace() 64-bit case (pixel_bytes == 8)

+ *     - write MMX code for 48-bit case (pixel_bytes == 6)

+ *     - figure out what's up with 24-bit case (pixel_bytes == 3):

+ *        why subtract 8 from width_mmx in the pass 4/5 case?

+ *        (only width_mmx case) (near line 1606)

+ *     - rewrite all MMX interlacing code so it's aligned with beginning

+ *        of the row buffer, not the end (see 19991007 for details)

+ *     x pick one version of mmxsupport() and get rid of the other

+ *     - add error messages to any remaining bogus default cases

+ *     - enable pixel_depth == 8 cases in png_read_filter_row()? (test speed)

+ *     x add support for runtime enable/disable/query of various MMX routines

+ */

+#define PNG_INTERNAL

+#include "png.h"

+#if defined(PNG_USE_PNGGCCRD)

+int PNGAPI png_mmx_support(void);

+#ifdef PNG_USE_LOCAL_ARRAYS

+static const int FARDATA png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

+static const int FARDATA png_pass_inc[7]   = {8, 8, 4, 4, 2, 2, 1};

+static const int FARDATA png_pass_width[7] = {8, 4, 4, 2, 2, 1, 1};

+#endif

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)

+/* djgpp, Win32, and Cygwin add their own underscores to global variables,

+ * so define them without: */

+#if defined(__DJGPP__) || defined(WIN32) || defined(__CYGWIN__)

+#  define _mmx_supported  mmx_supported

+#  define _const4         const4

+#  define _const6         const6

+#  define _mask8_0        mask8_0

+#  define _mask16_1       mask16_1

+#  define _mask16_0       mask16_0

+#  define _mask24_2       mask24_2

+#  define _mask24_1       mask24_1

+#  define _mask24_0       mask24_0

+#  define _mask32_3       mask32_3

+#  define _mask32_2       mask32_2

+#  define _mask32_1       mask32_1

+#  define _mask32_0       mask32_0

+#  define _mask48_5       mask48_5

+#  define _mask48_4       mask48_4

+#  define _mask48_3       mask48_3

+#  define _mask48_2       mask48_2

+#  define _mask48_1       mask48_1

+#  define _mask48_0       mask48_0

+#  define _LBCarryMask    LBCarryMask

+#  define _HBClearMask    HBClearMask

+#  define _ActiveMask     ActiveMask

+#  define _ActiveMask2    ActiveMask2

+#  define _ActiveMaskEnd  ActiveMaskEnd

+#  define _ShiftBpp       ShiftBpp

+#  define _ShiftRem       ShiftRem

+#ifdef PNG_THREAD_UNSAFE_OK

+#  define _unmask         unmask

+#  define _FullLength     FullLength

+#  define _MMXLength      MMXLength

+#  define _dif            dif

+#  define _patemp         patemp

+#  define _pbtemp         pbtemp

+#  define _pctemp         pctemp

+#endif

+#endif

+/* These constants are used in the inlined MMX assembly code.

+   Ignore gcc's "At top level: defined but not used" warnings. */

+/* GRR 20000706:  originally _unmask was needed only when compiling with -fPIC,

+ *  since that case uses the %ebx register for indexing the Global Offset Table

+ *  and there were no other registers available.  But gcc 2.95 and later emit

+ *  "more than 10 operands in `asm'" errors when %ebx is used to preload unmask

+ *  in the non-PIC case, so we'll just use the global unconditionally now.

+ */

+#ifdef PNG_THREAD_UNSAFE_OK

+static int _unmask;

+#endif

+static unsigned long long _mask8_0  = 0x0102040810204080LL;

+static unsigned long long _mask16_1 = 0x0101020204040808LL;

+static unsigned long long _mask16_0 = 0x1010202040408080LL;

+static unsigned long long _mask24_2 = 0x0101010202020404LL;

+static unsigned long long _mask24_1 = 0x0408080810101020LL;

+static unsigned long long _mask24_0 = 0x2020404040808080LL;

+static unsigned long long _mask32_3 = 0x0101010102020202LL;

+static unsigned long long _mask32_2 = 0x0404040408080808LL;

+static unsigned long long _mask32_1 = 0x1010101020202020LL;

+static unsigned long long _mask32_0 = 0x4040404080808080LL;

+static unsigned long long _mask48_5 = 0x0101010101010202LL;

+static unsigned long long _mask48_4 = 0x0202020204040404LL;

+static unsigned long long _mask48_3 = 0x0404080808080808LL;

+static unsigned long long _mask48_2 = 0x1010101010102020LL;

+static unsigned long long _mask48_1 = 0x2020202040404040LL;

+static unsigned long long _mask48_0 = 0x4040808080808080LL;

+static unsigned long long _const4   = 0x0000000000FFFFFFLL;

+//static unsigned long long _const5 = 0x000000FFFFFF0000LL;     // NOT USED

+static unsigned long long _const6   = 0x00000000000000FFLL;

+// These are used in the row-filter routines and should/would be local

+//  variables if not for gcc addressing limitations.

+// WARNING: Their presence probably defeats the thread safety of libpng.

+#ifdef PNG_THREAD_UNSAFE_OK

+static png_uint_32  _FullLength;

+static png_uint_32  _MMXLength;

+static int          _dif;

+static int          _patemp; // temp variables for Paeth routine

+static int          _pbtemp;

+static int          _pctemp;

+#endif

+void /* PRIVATE */

+png_squelch_warnings(void)

+{

+#ifdef PNG_THREAD_UNSAFE_OK

+   _dif = _dif;

+   _patemp = _patemp;

+   _pbtemp = _pbtemp;

+   _pctemp = _pctemp;

+   _MMXLength = _MMXLength;

+#endif

+   _const4  = _const4;

+   _const6  = _const6;

+   _mask8_0  = _mask8_0;

+   _mask16_1 = _mask16_1;

+   _mask16_0 = _mask16_0;

+   _mask24_2 = _mask24_2;

+   _mask24_1 = _mask24_1;

+   _mask24_0 = _mask24_0;

+   _mask32_3 = _mask32_3;

+   _mask32_2 = _mask32_2;

+   _mask32_1 = _mask32_1;

+   _mask32_0 = _mask32_0;

+   _mask48_5 = _mask48_5;

+   _mask48_4 = _mask48_4;

+   _mask48_3 = _mask48_3;

+   _mask48_2 = _mask48_2;

+   _mask48_1 = _mask48_1;

+   _mask48_0 = _mask48_0;

+}

+#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */

+static int _mmx_supported = 2;

+/*===========================================================================*/

+/*                                                                           */

+/*                       P N G _ C O M B I N E _ R O W                       */

+/*                                                                           */

+/*===========================================================================*/

+#if defined(PNG_HAVE_ASSEMBLER_COMBINE_ROW)

+#define BPP2  2

+#define BPP3  3 /* bytes per pixel (a.k.a. pixel_bytes) */

+#define BPP4  4

+#define BPP6  6 /* (defined only to help avoid cut-and-paste errors) */

+#define BPP8  8

+/* Combines the row recently read in with the previous row.

+   This routine takes care of alpha and transparency if requested.

+   This routine also handles the two methods of progressive display

+   of interlaced images, depending on the mask value.

+   The mask value describes which pixels are to be combined with

+   the row.  The pattern always repeats every 8 pixels, so just 8

+   bits are needed.  A one indicates the pixel is to be combined; a

+   zero indicates the pixel is to be skipped.  This is in addition

+   to any alpha or transparency value associated with the pixel.

+   If you want all pixels to be combined, pass 0xff (255) in mask. */

+/* Use this routine for the x86 platform - it uses a faster MMX routine

+   if the machine supports MMX. */

+void /* PRIVATE */

+png_combine_row(png_structp png_ptr, png_bytep row, int mask)

+{

+   png_debug(1, "in png_combine_row (pnggccrd.c)\n");

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)

+   if (_mmx_supported == 2) {

+#if !defined(PNG_1_0_X)

+       /* this should have happened in png_init_mmx_flags() already */

+       png_warning(png_ptr, "asm_flags may not have been initialized");

+#endif

+       png_mmx_support();

+   }

+#endif

+   if (mask == 0xff)

+   {

+      png_debug(2,"mask == 0xff:  doing single png_memcpy()\n");

+      png_memcpy(row, png_ptr->row_buf + 1,

+       (png_size_t)PNG_ROWBYTES(png_ptr->row_info.pixel_depth,png_ptr->width));

+   }

+   else   /* (png_combine_row() is never called with mask == 0) */

+   {

+      switch (png_ptr->row_info.pixel_depth)

+      {

+         case 1:        /* png_ptr->row_info.pixel_depth */

+         {

+            png_bytep sp;

+            png_bytep dp;

+            int s_inc, s_start, s_end;

+            int m;

+            int shift;

+            png_uint_32 i;

+            sp = png_ptr->row_buf + 1;

+            dp = row;

+            m = 0x80;

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+            if (png_ptr->transformations & PNG_PACKSWAP)

+            {

+                s_start = 0;

+                s_end = 7;

+                s_inc = 1;

+            }

+            else

+#endif

+            {

+                s_start = 7;

+                s_end = 0;

+                s_inc = -1;

+            }

+            shift = s_start;

+            for (i = 0; i < png_ptr->width; i++)

+            {

+               if (m & mask)

+               {

+                  int value;

+                  value = (*sp >> shift) & 0x1;

+                  *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);

+                  *dp |= (png_byte)(value << shift);

+               }

+               if (shift == s_end)

+               {

+                  shift = s_start;

+                  sp++;

+                  dp++;

+               }

+               else

+                  shift += s_inc;

+               if (m == 1)

+                  m = 0x80;

+               else

+                  m >>= 1;

+            }

+            break;

+         }

+         case 2:        /* png_ptr->row_info.pixel_depth */

+         {

+            png_bytep sp;

+            png_bytep dp;

+            int s_start, s_end, s_inc;

+            int m;

+            int shift;

+            png_uint_32 i;

+            int value;

+            sp = png_ptr->row_buf + 1;

+            dp = row;

+            m = 0x80;

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+            if (png_ptr->transformations & PNG_PACKSWAP)

+            {

+               s_start = 0;

+               s_end = 6;

+               s_inc = 2;

+            }

+            else

+#endif

+            {

+               s_start = 6;

+               s_end = 0;

+               s_inc = -2;

+            }

+            shift = s_start;

+            for (i = 0; i < png_ptr->width; i++)

+            {

+               if (m & mask)

+               {

+                  value = (*sp >> shift) & 0x3;

+                  *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);

+                  *dp |= (png_byte)(value << shift);

+               }

+               if (shift == s_end)

+               {

+                  shift = s_start;

+                  sp++;

+                  dp++;

+               }

+               else

+                  shift += s_inc;

+               if (m == 1)

+                  m = 0x80;

+               else

+                  m >>= 1;

+            }

+            break;

+         }

+         case 4:        /* png_ptr->row_info.pixel_depth */

+         {

+            png_bytep sp;

+            png_bytep dp;

+            int s_start, s_end, s_inc;

+            int m;

+            int shift;

+            png_uint_32 i;

+            int value;

+            sp = png_ptr->row_buf + 1;

+            dp = row;

+            m = 0x80;

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+            if (png_ptr->transformations & PNG_PACKSWAP)

+            {

+               s_start = 0;

+               s_end = 4;

+               s_inc = 4;

+            }

+            else

+#endif

+            {

+               s_start = 4;

+               s_end = 0;

+               s_inc = -4;

+            }

+            shift = s_start;

+            for (i = 0; i < png_ptr->width; i++)

+            {

+               if (m & mask)

+               {

+                  value = (*sp >> shift) & 0xf;

+                  *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);

+                  *dp |= (png_byte)(value << shift);

+               }

+               if (shift == s_end)

+               {

+                  shift = s_start;

+                  sp++;

+                  dp++;

+               }

+               else

+                  shift += s_inc;

+               if (m == 1)

+                  m = 0x80;

+               else

+                  m >>= 1;

+            }

+            break;

+         }

+         case 8:        /* png_ptr->row_info.pixel_depth */

+         {

+            png_bytep srcptr;

+            png_bytep dstptr;

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK)

+#if !defined(PNG_1_0_X)

+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)

+                /* && _mmx_supported */ )

+#else

+            if (_mmx_supported)

+#endif

+            {

+               png_uint_32 len;

+               int diff;

+               int dummy_value_a;   // fix 'forbidden register spilled' error

+               int dummy_value_d;

+               int dummy_value_c;

+               int dummy_value_S;

+               int dummy_value_D;

+               _unmask = ~mask;            // global variable for -fPIC version

+               srcptr = png_ptr->row_buf + 1;

+               dstptr = row;

+               len  = png_ptr->width &~7;  // reduce to multiple of 8

+               diff = (int) (png_ptr->width & 7);  // amount lost

+               __asm__ __volatile__ (

+                  "movd      _unmask, %%mm7  \n\t" // load bit pattern

+                  "psubb     %%mm6, %%mm6    \n\t" // zero mm6

+                  "punpcklbw %%mm7, %%mm7    \n\t"

+                  "punpcklwd %%mm7, %%mm7    \n\t"

+                  "punpckldq %%mm7, %%mm7    \n\t" // fill reg with 8 masks

+                  "movq      _mask8_0, %%mm0 \n\t"

+                  "pand      %%mm7, %%mm0    \n\t" // nonzero if keep byte

+                  "pcmpeqb   %%mm6, %%mm0    \n\t" // zeros->1s, v versa

+// preload        "movl      len, %%ecx      \n\t" // load length of line

+// preload        "movl      srcptr, %%esi   \n\t" // load source

+// preload        "movl      dstptr, %%edi   \n\t" // load dest

+                  "cmpl      $0, %%ecx       \n\t" // len == 0 ?

+                  "je        mainloop8end    \n\t"

+                "mainloop8:                  \n\t"

+                  "movq      (%%esi), %%mm4  \n\t" // *srcptr

+                  "pand      %%mm0, %%mm4    \n\t"

+                  "movq      %%mm0, %%mm6    \n\t"

+                  "pandn     (%%edi), %%mm6  \n\t" // *dstptr

+                  "por       %%mm6, %%mm4    \n\t"

+                  "movq      %%mm4, (%%edi)  \n\t"

+                  "addl      $8, %%esi       \n\t" // inc by 8 bytes processed

+                  "addl      $8, %%edi       \n\t"

+                  "subl      $8, %%ecx       \n\t" // dec by 8 pixels processed

+                  "ja        mainloop8       \n\t"

+                "mainloop8end:               \n\t"

+// preload        "movl      diff, %%ecx     \n\t" // (diff is in eax)

+                  "movl      %%eax, %%ecx    \n\t"

+                  "cmpl      $0, %%ecx       \n\t"

+                  "jz        end8            \n\t"

+// preload        "movl      mask, %%edx     \n\t"

+                  "sall      $24, %%edx      \n\t" // make low byte, high byte

+                "secondloop8:                \n\t"

+                  "sall      %%edx           \n\t" // move high bit to CF

+                  "jnc       skip8           \n\t" // if CF = 0

+                  "movb      (%%esi), %%al   \n\t"

+                  "movb      %%al, (%%edi)   \n\t"

+                "skip8:                      \n\t"

+                  "incl      %%esi           \n\t"

+                  "incl      %%edi           \n\t"

+                  "decl      %%ecx           \n\t"

+                  "jnz       secondloop8     \n\t"

+                "end8:                       \n\t"

+                  "EMMS                      \n\t"  // DONE

+                  : "=a" (dummy_value_a),           // output regs (dummy)

+                    "=d" (dummy_value_d),

+                    "=c" (dummy_value_c),

+                    "=S" (dummy_value_S),

+                    "=D" (dummy_value_D)

+                  : "3" (srcptr),      // esi       // input regs

+                    "4" (dstptr),      // edi

+                    "0" (diff),        // eax

+// was (unmask)     "b"    RESERVED    // ebx       // Global Offset Table idx

+                    "2" (len),         // ecx

+                    "1" (mask)         // edx

+#if 0  /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */

+                  : "%mm0", "%mm4", "%mm6", "%mm7"  // clobber list

+#endif

+               );

+            }

+            else /* mmx _not supported - Use modified C routine */

+#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */

+            {

+               register png_uint_32 i;

+               png_uint_32 initial_val = png_pass_start[png_ptr->pass];

+                 /* png.c:  png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */

+               register int stride = png_pass_inc[png_ptr->pass];

+                 /* png.c:  png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */

+               register int rep_bytes = png_pass_width[png_ptr->pass];

+                 /* png.c:  png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */

+               png_uint_32 len = png_ptr->width &~7;  /* reduce to mult. of 8 */

+               int diff = (int) (png_ptr->width & 7); /* amount lost */

+               register png_uint_32 final_val = len;  /* GRR bugfix */

+               srcptr = png_ptr->row_buf + 1 + initial_val;

+               dstptr = row + initial_val;

+               for (i = initial_val; i < final_val; i += stride)

+               {

+                  png_memcpy(dstptr, srcptr, rep_bytes);

+                  srcptr += stride;

+                  dstptr += stride;

+               }

+               if (diff)  /* number of leftover pixels:  3 for pngtest */

+               {

+                  final_val+=diff /* *BPP1 */ ;

+                  for (; i < final_val; i += stride)

+                  {

+                     if (rep_bytes > (int)(final_val-i))

+                        rep_bytes = (int)(final_val-i);

+                     png_memcpy(dstptr, srcptr, rep_bytes);

+                     srcptr += stride;

+                     dstptr += stride;

+                  }

+               }

+            } /* end of else (_mmx_supported) */

+            break;

+         }       /* end 8 bpp */

+         case 16:       /* png_ptr->row_info.pixel_depth */

+         {

+            png_bytep srcptr;

+            png_bytep dstptr;

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK)

+#if !defined(PNG_1_0_X)

+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)

+                /* && _mmx_supported */ )

+#else

+            if (_mmx_supported)

+#endif

+            {

+               png_uint_32 len;

+               int diff;

+               int dummy_value_a;   // fix 'forbidden register spilled' error

+               int dummy_value_d;

+               int dummy_value_c;

+               int dummy_value_S;

+               int dummy_value_D;

+               _unmask = ~mask;            // global variable for -fPIC version

+               srcptr = png_ptr->row_buf + 1;

+               dstptr = row;

+               len  = png_ptr->width &~7;  // reduce to multiple of 8

+               diff = (int) (png_ptr->width & 7); // amount lost //

+               __asm__ __volatile__ (

+                  "movd      _unmask, %%mm7   \n\t" // load bit pattern

+                  "psubb     %%mm6, %%mm6     \n\t" // zero mm6

+                  "punpcklbw %%mm7, %%mm7     \n\t"

+                  "punpcklwd %%mm7, %%mm7     \n\t"

+                  "punpckldq %%mm7, %%mm7     \n\t" // fill reg with 8 masks

+                  "movq      _mask16_0, %%mm0 \n\t"

+                  "movq      _mask16_1, %%mm1 \n\t"

+                  "pand      %%mm7, %%mm0     \n\t"

+                  "pand      %%mm7, %%mm1     \n\t"

+                  "pcmpeqb   %%mm6, %%mm0     \n\t"

+                  "pcmpeqb   %%mm6, %%mm1     \n\t"

+// preload        "movl      len, %%ecx       \n\t" // load length of line

+// preload        "movl      srcptr, %%esi    \n\t" // load source

+// preload        "movl      dstptr, %%edi    \n\t" // load dest

+                  "cmpl      $0, %%ecx        \n\t"

+                  "jz        mainloop16end    \n\t"

+                "mainloop16:                  \n\t"

+                  "movq      (%%esi), %%mm4   \n\t"

+                  "pand      %%mm0, %%mm4     \n\t"

+                  "movq      %%mm0, %%mm6     \n\t"

+                  "movq      (%%edi), %%mm7   \n\t"

+                  "pandn     %%mm7, %%mm6     \n\t"

+                  "por       %%mm6, %%mm4     \n\t"

+                  "movq      %%mm4, (%%edi)   \n\t"

+                  "movq      8(%%esi), %%mm5  \n\t"

+                  "pand      %%mm1, %%mm5     \n\t"

+                  "movq      %%mm1, %%mm7     \n\t"

+                  "movq      8(%%edi), %%mm6  \n\t"

+                  "pandn     %%mm6, %%mm7     \n\t"

+                  "por       %%mm7, %%mm5     \n\t"

+                  "movq      %%mm5, 8(%%edi)  \n\t"

+                  "addl      $16, %%esi       \n\t" // inc by 16 bytes processed

+                  "addl      $16, %%edi       \n\t"

+                  "subl      $8, %%ecx        \n\t" // dec by 8 pixels processed

+                  "ja        mainloop16       \n\t"

+                "mainloop16end:               \n\t"

+// preload        "movl      diff, %%ecx      \n\t" // (diff is in eax)

+                  "movl      %%eax, %%ecx     \n\t"

+                  "cmpl      $0, %%ecx        \n\t"

+                  "jz        end16            \n\t"

+// preload        "movl      mask, %%edx      \n\t"

+                  "sall      $24, %%edx       \n\t" // make low byte, high byte

+                "secondloop16:                \n\t"

+                  "sall      %%edx            \n\t" // move high bit to CF

+                  "jnc       skip16           \n\t" // if CF = 0

+                  "movw      (%%esi), %%ax    \n\t"

+                  "movw      %%ax, (%%edi)    \n\t"

+                "skip16:                      \n\t"

+                  "addl      $2, %%esi        \n\t"

+                  "addl      $2, %%edi        \n\t"

+                  "decl      %%ecx            \n\t"

+                  "jnz       secondloop16     \n\t"

+                "end16:                       \n\t"

+                  "EMMS                       \n\t" // DONE

+                  : "=a" (dummy_value_a),           // output regs (dummy)

+                    "=c" (dummy_value_c),

+                    "=d" (dummy_value_d),

+                    "=S" (dummy_value_S),

+                    "=D" (dummy_value_D)

+                  : "0" (diff),        // eax       // input regs

+// was (unmask)     " "    RESERVED    // ebx       // Global Offset Table idx

+                    "1" (len),         // ecx

+                    "2" (mask),        // edx

+                    "3" (srcptr),      // esi

+                    "4" (dstptr)       // edi

+#if 0  /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */

+                  : "%mm0", "%mm1", "%mm4"          // clobber list

+                  , "%mm5", "%mm6", "%mm7"

+#endif

+               );

+            }

+            else /* mmx _not supported - Use modified C routine */

+#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */

+            {

+               register png_uint_32 i;

+               png_uint_32 initial_val = BPP2 * png_pass_start[png_ptr->pass];

+                 /* png.c:  png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */

+               register int stride = BPP2 * png_pass_inc[png_ptr->pass];

+                 /* png.c:  png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */

+               register int rep_bytes = BPP2 * png_pass_width[png_ptr->pass];

+                 /* png.c:  png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */

+               png_uint_32 len = png_ptr->width &~7;  /* reduce to mult. of 8 */

+               int diff = (int) (png_ptr->width & 7); /* amount lost */

+               register png_uint_32 final_val = BPP2 * len;   /* GRR bugfix */

+               srcptr = png_ptr->row_buf + 1 + initial_val;

+               dstptr = row + initial_val;

+               for (i = initial_val; i < final_val; i += stride)

+               {

+                  png_memcpy(dstptr, srcptr, rep_bytes);

+                  srcptr += stride;

+                  dstptr += stride;

+               }

+               if (diff)  /* number of leftover pixels:  3 for pngtest */

+               {

+                  final_val+=diff*BPP2;

+                  for (; i < final_val; i += stride)

+                  {

+                     if (rep_bytes > (int)(final_val-i))

+                        rep_bytes = (int)(final_val-i);

+                     png_memcpy(dstptr, srcptr, rep_bytes);

+                     srcptr += stride;

+                     dstptr += stride;

+                  }

+               }

+            } /* end of else (_mmx_supported) */

+            break;

+         }       /* end 16 bpp */

+         case 24:       /* png_ptr->row_info.pixel_depth */

+         {

+            png_bytep srcptr;

+            png_bytep dstptr;

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK)

+#if !defined(PNG_1_0_X)

+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)

+                /* && _mmx_supported */ )

+#else

+            if (_mmx_supported)

+#endif

+            {

+               png_uint_32 len;

+               int diff;

+               int dummy_value_a;   // fix 'forbidden register spilled' error

+               int dummy_value_d;

+               int dummy_value_c;

+               int dummy_value_S;

+               int dummy_value_D;

+               _unmask = ~mask;            // global variable for -fPIC version

+               srcptr = png_ptr->row_buf + 1;

+               dstptr = row;

+               len  = png_ptr->width &~7;  // reduce to multiple of 8

+               diff = (int) (png_ptr->width & 7); // amount lost //

+               __asm__ __volatile__ (

+                  "movd      _unmask, %%mm7   \n\t" // load bit pattern

+                  "psubb     %%mm6, %%mm6     \n\t" // zero mm6

+                  "punpcklbw %%mm7, %%mm7     \n\t"

+                  "punpcklwd %%mm7, %%mm7     \n\t"

+                  "punpckldq %%mm7, %%mm7     \n\t" // fill reg with 8 masks

+                  "movq      _mask24_0, %%mm0 \n\t"

+                  "movq      _mask24_1, %%mm1 \n\t"

+                  "movq      _mask24_2, %%mm2 \n\t"

+                  "pand      %%mm7, %%mm0     \n\t"

+                  "pand      %%mm7, %%mm1     \n\t"

+                  "pand      %%mm7, %%mm2     \n\t"

+                  "pcmpeqb   %%mm6, %%mm0     \n\t"

+                  "pcmpeqb   %%mm6, %%mm1     \n\t"

+                  "pcmpeqb   %%mm6, %%mm2     \n\t"

+// preload        "movl      len, %%ecx       \n\t" // load length of line

+// preload        "movl      srcptr, %%esi    \n\t" // load source

+// preload        "movl      dstptr, %%edi    \n\t" // load dest

+                  "cmpl      $0, %%ecx        \n\t"

+                  "jz        mainloop24end    \n\t"

+                "mainloop24:                  \n\t"

+                  "movq      (%%esi), %%mm4   \n\t"

+                  "pand      %%mm0, %%mm4     \n\t"

+                  "movq      %%mm0, %%mm6     \n\t"

+                  "movq      (%%edi), %%mm7   \n\t"

+                  "pandn     %%mm7, %%mm6     \n\t"

+                  "por       %%mm6, %%mm4     \n\t"

+                  "movq      %%mm4, (%%edi)   \n\t"

+                  "movq      8(%%esi), %%mm5  \n\t"

+                  "pand      %%mm1, %%mm5     \n\t"

+                  "movq      %%mm1, %%mm7     \n\t"

+                  "movq      8(%%edi), %%mm6  \n\t"

+                  "pandn     %%mm6, %%mm7     \n\t"

+                  "por       %%mm7, %%mm5     \n\t"

+                  "movq      %%mm5, 8(%%edi)  \n\t"

+                  "movq      16(%%esi), %%mm6 \n\t"

+                  "pand      %%mm2, %%mm6     \n\t"

+                  "movq      %%mm2, %%mm4     \n\t"

+                  "movq      16(%%edi), %%mm7 \n\t"

+                  "pandn     %%mm7, %%mm4     \n\t"

+                  "por       %%mm4, %%mm6     \n\t"

+                  "movq      %%mm6, 16(%%edi) \n\t"

+                  "addl      $24, %%esi       \n\t" // inc by 24 bytes processed

+                  "addl      $24, %%edi       \n\t"

+                  "subl      $8, %%ecx        \n\t" // dec by 8 pixels processed

+                  "ja        mainloop24       \n\t"

+                "mainloop24end:               \n\t"

+// preload        "movl      diff, %%ecx      \n\t" // (diff is in eax)

+                  "movl      %%eax, %%ecx     \n\t"

+                  "cmpl      $0, %%ecx        \n\t"

+                  "jz        end24            \n\t"

+// preload        "movl      mask, %%edx      \n\t"

+                  "sall      $24, %%edx       \n\t" // make low byte, high byte

+                "secondloop24:                \n\t"

+                  "sall      %%edx            \n\t" // move high bit to CF

+                  "jnc       skip24           \n\t" // if CF = 0

+                  "movw      (%%esi), %%ax    \n\t"

+                  "movw      %%ax, (%%edi)    \n\t"

+                  "xorl      %%eax, %%eax     \n\t"

+                  "movb      2(%%esi), %%al   \n\t"

+                  "movb      %%al, 2(%%edi)   \n\t"

+                "skip24:                      \n\t"

+                  "addl      $3, %%esi        \n\t"

+                  "addl      $3, %%edi        \n\t"

+                  "decl      %%ecx            \n\t"

+                  "jnz       secondloop24     \n\t"

+                "end24:                       \n\t"

+                  "EMMS                       \n\t" // DONE

+                  : "=a" (dummy_value_a),           // output regs (dummy)

+                    "=d" (dummy_value_d),

+                    "=c" (dummy_value_c),

+                    "=S" (dummy_value_S),

+                    "=D" (dummy_value_D)

+                  : "3" (srcptr),      // esi       // input regs

+                    "4" (dstptr),      // edi

+                    "0" (diff),        // eax

+// was (unmask)     "b"    RESERVED    // ebx       // Global Offset Table idx

+                    "2" (len),         // ecx

+                    "1" (mask)         // edx

+#if 0  /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */

+                  : "%mm0", "%mm1", "%mm2"          // clobber list

+                  , "%mm4", "%mm5", "%mm6", "%mm7"

+#endif

+               );

+            }

+            else /* mmx _not supported - Use modified C routine */

+#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */

+            {

+               register png_uint_32 i;

+               png_uint_32 initial_val = BPP3 * png_pass_start[png_ptr->pass];

+                 /* png.c:  png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */

+               register int stride = BPP3 * png_pass_inc[png_ptr->pass];

+                 /* png.c:  png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */

+               register int rep_bytes = BPP3 * png_pass_width[png_ptr->pass];

+                 /* png.c:  png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */

+               png_uint_32 len = png_ptr->width &~7;  /* reduce to mult. of 8 */

+               int diff = (int) (png_ptr->width & 7); /* amount lost */

+               register png_uint_32 final_val = BPP3 * len;   /* GRR bugfix */

+               srcptr = png_ptr->row_buf + 1 + initial_val;

+               dstptr = row + initial_val;

+               for (i = initial_val; i < final_val; i += stride)

+               {

+                  png_memcpy(dstptr, srcptr, rep_bytes);

+                  srcptr += stride;

+                  dstptr += stride;

+               }

+               if (diff)  /* number of leftover pixels:  3 for pngtest */

+               {

+                  final_val+=diff*BPP3;

+                  for (; i < final_val; i += stride)

+                  {

+                     if (rep_bytes > (int)(final_val-i))

+                        rep_bytes = (int)(final_val-i);

+                     png_memcpy(dstptr, srcptr, rep_bytes);

+                     srcptr += stride;

+                     dstptr += stride;

+                  }

+               }

+            } /* end of else (_mmx_supported) */

+            break;

+         }       /* end 24 bpp */

+         case 32:       /* png_ptr->row_info.pixel_depth */

+         {

+            png_bytep srcptr;

+            png_bytep dstptr;

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK)

+#if !defined(PNG_1_0_X)

+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)

+                /* && _mmx_supported */ )

+#else

+            if (_mmx_supported)

+#endif

+            {

+               png_uint_32 len;

+               int diff;

+               int dummy_value_a;   // fix 'forbidden register spilled' error

+               int dummy_value_d;

+               int dummy_value_c;

+               int dummy_value_S;

+               int dummy_value_D;

+               _unmask = ~mask;            // global variable for -fPIC version

+               srcptr = png_ptr->row_buf + 1;

+               dstptr = row;

+               len  = png_ptr->width &~7;  // reduce to multiple of 8

+               diff = (int) (png_ptr->width & 7); // amount lost //

+               __asm__ __volatile__ (

+                  "movd      _unmask, %%mm7   \n\t" // load bit pattern

+                  "psubb     %%mm6, %%mm6     \n\t" // zero mm6

+                  "punpcklbw %%mm7, %%mm7     \n\t"

+                  "punpcklwd %%mm7, %%mm7     \n\t"

+                  "punpckldq %%mm7, %%mm7     \n\t" // fill reg with 8 masks

+                  "movq      _mask32_0, %%mm0 \n\t"

+                  "movq      _mask32_1, %%mm1 \n\t"

+                  "movq      _mask32_2, %%mm2 \n\t"

+                  "movq      _mask32_3, %%mm3 \n\t"

+                  "pand      %%mm7, %%mm0     \n\t"

+                  "pand      %%mm7, %%mm1     \n\t"

+                  "pand      %%mm7, %%mm2     \n\t"

+                  "pand      %%mm7, %%mm3     \n\t"

+                  "pcmpeqb   %%mm6, %%mm0     \n\t"

+                  "pcmpeqb   %%mm6, %%mm1     \n\t"

+                  "pcmpeqb   %%mm6, %%mm2     \n\t"

+                  "pcmpeqb   %%mm6, %%mm3     \n\t"

+// preload        "movl      len, %%ecx       \n\t" // load length of line

+// preload        "movl      srcptr, %%esi    \n\t" // load source

+// preload        "movl      dstptr, %%edi    \n\t" // load dest

+                  "cmpl      $0, %%ecx        \n\t" // lcr

+                  "jz        mainloop32end    \n\t"

+                "mainloop32:                  \n\t"

+                  "movq      (%%esi), %%mm4   \n\t"

+                  "pand      %%mm0, %%mm4     \n\t"

+                  "movq      %%mm0, %%mm6     \n\t"

+                  "movq      (%%edi), %%mm7   \n\t"

+                  "pandn     %%mm7, %%mm6     \n\t"

+                  "por       %%mm6, %%mm4     \n\t"

+                  "movq      %%mm4, (%%edi)   \n\t"

+                  "movq      8(%%esi), %%mm5  \n\t"

+                  "pand      %%mm1, %%mm5     \n\t"

+                  "movq      %%mm1, %%mm7     \n\t"

+                  "movq      8(%%edi), %%mm6  \n\t"

+                  "pandn     %%mm6, %%mm7     \n\t"

+                  "por       %%mm7, %%mm5     \n\t"

+                  "movq      %%mm5, 8(%%edi)  \n\t"

+                  "movq      16(%%esi), %%mm6 \n\t"

+                  "pand      %%mm2, %%mm6     \n\t"

+                  "movq      %%mm2, %%mm4     \n\t"

+                  "movq      16(%%edi), %%mm7 \n\t"

+                  "pandn     %%mm7, %%mm4     \n\t"

+                  "por       %%mm4, %%mm6     \n\t"

+                  "movq      %%mm6, 16(%%edi) \n\t"

+                  "movq      24(%%esi), %%mm7 \n\t"

+                  "pand      %%mm3, %%mm7     \n\t"

+                  "movq      %%mm3, %%mm5     \n\t"

+                  "movq      24(%%edi), %%mm4 \n\t"

+                  "pandn     %%mm4, %%mm5     \n\t"

+                  "por       %%mm5, %%mm7     \n\t"

+                  "movq      %%mm7, 24(%%edi) \n\t"

+                  "addl      $32, %%esi       \n\t" // inc by 32 bytes processed

+                  "addl      $32, %%edi       \n\t"

+                  "subl      $8, %%ecx        \n\t" // dec by 8 pixels processed

+                  "ja        mainloop32       \n\t"

+                "mainloop32end:               \n\t"

+// preload        "movl      diff, %%ecx      \n\t" // (diff is in eax)

+                  "movl      %%eax, %%ecx     \n\t"

+                  "cmpl      $0, %%ecx        \n\t"

+                  "jz        end32            \n\t"

+// preload        "movl      mask, %%edx      \n\t"

+                  "sall      $24, %%edx       \n\t" // low byte => high byte

+                "secondloop32:                \n\t"

+                  "sall      %%edx            \n\t" // move high bit to CF

+                  "jnc       skip32           \n\t" // if CF = 0

+                  "movl      (%%esi), %%eax   \n\t"

+                  "movl      %%eax, (%%edi)   \n\t"

+                "skip32:                      \n\t"

+                  "addl      $4, %%esi        \n\t"

+                  "addl      $4, %%edi        \n\t"

+                  "decl      %%ecx            \n\t"

+                  "jnz       secondloop32     \n\t"

+                "end32:                       \n\t"

+                  "EMMS                       \n\t" // DONE

+                  : "=a" (dummy_value_a),           // output regs (dummy)

+                    "=d" (dummy_value_d),

+                    "=c" (dummy_value_c),

+                    "=S" (dummy_value_S),

+                    "=D" (dummy_value_D)

+                  : "3" (srcptr),      // esi       // input regs

+                    "4" (dstptr),      // edi

+                    "0" (diff),        // eax

+// was (unmask)     "b"    RESERVED    // ebx       // Global Offset Table idx

+                    "2" (len),         // ecx

+                    "1" (mask)         // edx

+#if 0  /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */

+                  : "%mm0", "%mm1", "%mm2", "%mm3"  // clobber list

+                  , "%mm4", "%mm5", "%mm6", "%mm7"

+#endif

+               );

+            }

+            else /* mmx _not supported - Use modified C routine */

+#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */

+            {

+               register png_uint_32 i;

+               png_uint_32 initial_val = BPP4 * png_pass_start[png_ptr->pass];

+                 /* png.c:  png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */

+               register int stride = BPP4 * png_pass_inc[png_ptr->pass];

+                 /* png.c:  png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */

+               register int rep_bytes = BPP4 * png_pass_width[png_ptr->pass];

+                 /* png.c:  png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */

+               png_uint_32 len = png_ptr->width &~7;  /* reduce to mult. of 8 */

+               int diff = (int) (png_ptr->width & 7); /* amount lost */

+               register png_uint_32 final_val = BPP4 * len;   /* GRR bugfix */

+               srcptr = png_ptr->row_buf + 1 + initial_val;

+               dstptr = row + initial_val;

+               for (i = initial_val; i < final_val; i += stride)

+               {

+                  png_memcpy(dstptr, srcptr, rep_bytes);

+                  srcptr += stride;

+                  dstptr += stride;

+               }

+               if (diff)  /* number of leftover pixels:  3 for pngtest */

+               {

+                  final_val+=diff*BPP4;

+                  for (; i < final_val; i += stride)

+                  {

+                     if (rep_bytes > (int)(final_val-i))

+                        rep_bytes = (int)(final_val-i);

+                     png_memcpy(dstptr, srcptr, rep_bytes);

+                     srcptr += stride;

+                     dstptr += stride;

+                  }

+               }

+            } /* end of else (_mmx_supported) */

+            break;

+         }       /* end 32 bpp */

+         case 48:       /* png_ptr->row_info.pixel_depth */

+         {

+            png_bytep srcptr;

+            png_bytep dstptr;

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK)

+#if !defined(PNG_1_0_X)

+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)

+                /* && _mmx_supported */ )

+#else

+            if (_mmx_supported)

+#endif

+            {

+               png_uint_32 len;

+               int diff;

+               int dummy_value_a;   // fix 'forbidden register spilled' error

+               int dummy_value_d;

+               int dummy_value_c;

+               int dummy_value_S;

+               int dummy_value_D;

+               _unmask = ~mask;            // global variable for -fPIC version

+               srcptr = png_ptr->row_buf + 1;

+               dstptr = row;

+               len  = png_ptr->width &~7;  // reduce to multiple of 8

+               diff = (int) (png_ptr->width & 7); // amount lost //

+               __asm__ __volatile__ (

+                  "movd      _unmask, %%mm7   \n\t" // load bit pattern

+                  "psubb     %%mm6, %%mm6     \n\t" // zero mm6

+                  "punpcklbw %%mm7, %%mm7     \n\t"

+                  "punpcklwd %%mm7, %%mm7     \n\t"

+                  "punpckldq %%mm7, %%mm7     \n\t" // fill reg with 8 masks

+                  "movq      _mask48_0, %%mm0 \n\t"

+                  "movq      _mask48_1, %%mm1 \n\t"

+                  "movq      _mask48_2, %%mm2 \n\t"

+                  "movq      _mask48_3, %%mm3 \n\t"

+                  "movq      _mask48_4, %%mm4 \n\t"

+                  "movq      _mask48_5, %%mm5 \n\t"

+                  "pand      %%mm7, %%mm0     \n\t"

+                  "pand      %%mm7, %%mm1     \n\t"

+                  "pand      %%mm7, %%mm2     \n\t"

+                  "pand      %%mm7, %%mm3     \n\t"

+                  "pand      %%mm7, %%mm4     \n\t"

+                  "pand      %%mm7, %%mm5     \n\t"

+                  "pcmpeqb   %%mm6, %%mm0     \n\t"

+                  "pcmpeqb   %%mm6, %%mm1     \n\t"

+                  "pcmpeqb   %%mm6, %%mm2     \n\t"

+                  "pcmpeqb   %%mm6, %%mm3     \n\t"

+                  "pcmpeqb   %%mm6, %%mm4     \n\t"

+                  "pcmpeqb   %%mm6, %%mm5     \n\t"

+// preload        "movl      len, %%ecx       \n\t" // load length of line

+// preload        "movl      srcptr, %%esi    \n\t" // load source

+// preload        "movl      dstptr, %%edi    \n\t" // load dest

+                  "cmpl      $0, %%ecx        \n\t"

+                  "jz        mainloop48end    \n\t"

+                "mainloop48:                  \n\t"

+                  "movq      (%%esi), %%mm7   \n\t"

+                  "pand      %%mm0, %%mm7     \n\t"

+                  "movq      %%mm0, %%mm6     \n\t"

+                  "pandn     (%%edi), %%mm6   \n\t"

+                  "por       %%mm6, %%mm7     \n\t"

+                  "movq      %%mm7, (%%edi)   \n\t"

+                  "movq      8(%%esi), %%mm6  \n\t"

+                  "pand      %%mm1, %%mm6     \n\t"

+                  "movq      %%mm1, %%mm7     \n\t"

+                  "pandn     8(%%edi), %%mm7  \n\t"

+                  "por       %%mm7, %%mm6     \n\t"

+                  "movq      %%mm6, 8(%%edi)  \n\t"

+                  "movq      16(%%esi), %%mm6 \n\t"

+                  "pand      %%mm2, %%mm6     \n\t"

+                  "movq      %%mm2, %%mm7     \n\t"

+                  "pandn     16(%%edi), %%mm7 \n\t"

+                  "por       %%mm7, %%mm6     \n\t"

+                  "movq      %%mm6, 16(%%edi) \n\t"

+                  "movq      24(%%esi), %%mm7 \n\t"

+                  "pand      %%mm3, %%mm7     \n\t"

+                  "movq      %%mm3, %%mm6     \n\t"

+                  "pandn     24(%%edi), %%mm6 \n\t"

+                  "por       %%mm6, %%mm7     \n\t"

+                  "movq      %%mm7, 24(%%edi) \n\t"

+                  "movq      32(%%esi), %%mm6 \n\t"

+                  "pand      %%mm4, %%mm6     \n\t"

+                  "movq      %%mm4, %%mm7     \n\t"

+                  "pandn     32(%%edi), %%mm7 \n\t"

+                  "por       %%mm7, %%mm6     \n\t"

+                  "movq      %%mm6, 32(%%edi) \n\t"

+                  "movq      40(%%esi), %%mm7 \n\t"

+                  "pand      %%mm5, %%mm7     \n\t"

+                  "movq      %%mm5, %%mm6     \n\t"

+                  "pandn     40(%%edi), %%mm6 \n\t"

+                  "por       %%mm6, %%mm7     \n\t"

+                  "movq      %%mm7, 40(%%edi) \n\t"

+                  "addl      $48, %%esi       \n\t" // inc by 48 bytes processed

+                  "addl      $48, %%edi       \n\t"

+                  "subl      $8, %%ecx        \n\t" // dec by 8 pixels processed

+                  "ja        mainloop48       \n\t"

+                "mainloop48end:               \n\t"

+// preload        "movl      diff, %%ecx      \n\t" // (diff is in eax)

+                  "movl      %%eax, %%ecx     \n\t"

+                  "cmpl      $0, %%ecx        \n\t"

+                  "jz        end48            \n\t"

+// preload        "movl      mask, %%edx      \n\t"

+                  "sall      $24, %%edx       \n\t" // make low byte, high byte

+                "secondloop48:                \n\t"

+                  "sall      %%edx            \n\t" // move high bit to CF

+                  "jnc       skip48           \n\t" // if CF = 0

+                  "movl      (%%esi), %%eax   \n\t"

+                  "movl      %%eax, (%%edi)   \n\t"

+                "skip48:                      \n\t"

+                  "addl      $4, %%esi        \n\t"

+                  "addl      $4, %%edi        \n\t"

+                  "decl      %%ecx            \n\t"

+                  "jnz       secondloop48     \n\t"

+                "end48:                       \n\t"

+                  "EMMS                       \n\t" // DONE

+                  : "=a" (dummy_value_a),           // output regs (dummy)

+                    "=d" (dummy_value_d),

+                    "=c" (dummy_value_c),

+                    "=S" (dummy_value_S),

+                    "=D" (dummy_value_D)

+                  : "3" (srcptr),      // esi       // input regs

+                    "4" (dstptr),      // edi

+                    "0" (diff),        // eax

+// was (unmask)     "b"    RESERVED    // ebx       // Global Offset Table idx

+                    "2" (len),         // ecx

+                    "1" (mask)         // edx

+#if 0  /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */

+                  : "%mm0", "%mm1", "%mm2", "%mm3"  // clobber list

+                  , "%mm4", "%mm5", "%mm6", "%mm7"

+#endif

+               );

+            }

+            else /* mmx _not supported - Use modified C routine */

+#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */

+            {

+               register png_uint_32 i;

+               png_uint_32 initial_val = BPP6 * png_pass_start[png_ptr->pass];

+                 /* png.c:  png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */

+               register int stride = BPP6 * png_pass_inc[png_ptr->pass];

+                 /* png.c:  png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */

+               register int rep_bytes = BPP6 * png_pass_width[png_ptr->pass];

+                 /* png.c:  png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */

+               png_uint_32 len = png_ptr->width &~7;  /* reduce to mult. of 8 */

+               int diff = (int) (png_ptr->width & 7); /* amount lost */

+               register png_uint_32 final_val = BPP6 * len;   /* GRR bugfix */

+               srcptr = png_ptr->row_buf + 1 + initial_val;

+               dstptr = row + initial_val;

+               for (i = initial_val; i < final_val; i += stride)

+               {

+                  png_memcpy(dstptr, srcptr, rep_bytes);

+                  srcptr += stride;

+                  dstptr += stride;

+               }

+               if (diff)  /* number of leftover pixels:  3 for pngtest */

+               {

+                  final_val+=diff*BPP6;

+                  for (; i < final_val; i += stride)

+                  {

+                     if (rep_bytes > (int)(final_val-i))

+                        rep_bytes = (int)(final_val-i);

+                     png_memcpy(dstptr, srcptr, rep_bytes);

+                     srcptr += stride;

+                     dstptr += stride;

+                  }

+               }

+            } /* end of else (_mmx_supported) */

+            break;

+         }       /* end 48 bpp */

+         case 64:       /* png_ptr->row_info.pixel_depth */

+         {

+            png_bytep srcptr;

+            png_bytep dstptr;

+            register png_uint_32 i;

+            png_uint_32 initial_val = BPP8 * png_pass_start[png_ptr->pass];

+              /* png.c:  png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */

+            register int stride = BPP8 * png_pass_inc[png_ptr->pass];

+              /* png.c:  png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */

+            register int rep_bytes = BPP8 * png_pass_width[png_ptr->pass];

+              /* png.c:  png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */

+            png_uint_32 len = png_ptr->width &~7;  /* reduce to mult. of 8 */

+            int diff = (int) (png_ptr->width & 7); /* amount lost */

+            register png_uint_32 final_val = BPP8 * len;   /* GRR bugfix */

+            srcptr = png_ptr->row_buf + 1 + initial_val;

+            dstptr = row + initial_val;

+            for (i = initial_val; i < final_val; i += stride)

+            {

+               png_memcpy(dstptr, srcptr, rep_bytes);

+               srcptr += stride;

+               dstptr += stride;

+            }

+            if (diff)  /* number of leftover pixels:  3 for pngtest */

+            {

+               final_val+=diff*BPP8;

+               for (; i < final_val; i += stride)

+               {

+                  if (rep_bytes > (int)(final_val-i))

+                     rep_bytes = (int)(final_val-i);

+                  png_memcpy(dstptr, srcptr, rep_bytes);

+                  srcptr += stride;

+                  dstptr += stride;

+               }

+            }

+            break;

+         }       /* end 64 bpp */

+         default: /* png_ptr->row_info.pixel_depth != 1,2,4,8,16,24,32,48,64 */

+         {

+            /* this should never happen */

+            png_warning(png_ptr, "Invalid row_info.pixel_depth in pnggccrd");

+            break;

+         }

+      } /* end switch (png_ptr->row_info.pixel_depth) */

+   } /* end if (non-trivial mask) */

+} /* end png_combine_row() */

+#endif /* PNG_HAVE_ASSEMBLER_COMBINE_ROW */

+/*===========================================================================*/

+/*                                                                           */

+/*                 P N G _ D O _ R E A D _ I N T E R L A C E                 */

+/*                                                                           */

+/*===========================================================================*/

+#if defined(PNG_READ_INTERLACING_SUPPORTED)

+#if defined(PNG_HAVE_ASSEMBLER_READ_INTERLACE)

+/* png_do_read_interlace() is called after any 16-bit to 8-bit conversion

+ * has taken place.  [GRR: what other steps come before and/or after?]

+ */

+void /* PRIVATE */

+png_do_read_interlace(png_structp png_ptr)

+{

+   png_row_infop row_info = &(png_ptr->row_info);

+   png_bytep row = png_ptr->row_buf + 1;

+   int pass = png_ptr->pass;

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+   png_uint_32 transformations = png_ptr->transformations;

+#endif

+   png_debug(1, "in png_do_read_interlace (pnggccrd.c)\n");

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)

+   if (_mmx_supported == 2) {

+#if !defined(PNG_1_0_X)

+       /* this should have happened in png_init_mmx_flags() already */

+       png_warning(png_ptr, "asm_flags may not have been initialized");

+#endif

+       png_mmx_support();

+   }

+#endif

+   if (row != NULL && row_info != NULL)

+   {

+      png_uint_32 final_width;

+      final_width = row_info->width * png_pass_inc[pass];

+      switch (row_info->pixel_depth)

+      {

+         case 1:

+         {

+            png_bytep sp, dp;

+            int sshift, dshift;

+            int s_start, s_end, s_inc;

+            png_byte v;

+            png_uint_32 i;

+            int j;

+            sp = row + (png_size_t)((row_info->width - 1) >> 3);

+            dp = row + (png_size_t)((final_width - 1) >> 3);

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+            if (transformations & PNG_PACKSWAP)

+            {

+               sshift = (int)((row_info->width + 7) & 7);

+               dshift = (int)((final_width + 7) & 7);

+               s_start = 7;

+               s_end = 0;

+               s_inc = -1;

+            }

+            else

+#endif

+            {

+               sshift = 7 - (int)((row_info->width + 7) & 7);

+               dshift = 7 - (int)((final_width + 7) & 7);

+               s_start = 0;

+               s_end = 7;

+               s_inc = 1;

+            }

+            for (i = row_info->width; i; i--)

+            {

+               v = (png_byte)((*sp >> sshift) & 0x1);

+               for (j = 0; j < png_pass_inc[pass]; j++)

+               {

+                  *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff);

+                  *dp |= (png_byte)(v << dshift);

+                  if (dshift == s_end)

+                  {

+                     dshift = s_start;

+                     dp--;

+                  }

+                  else

+                     dshift += s_inc;

+               }

+               if (sshift == s_end)

+               {

+                  sshift = s_start;

+                  sp--;

+               }

+               else

+                  sshift += s_inc;

+            }

+            break;

+         }

+         case 2:

+         {

+            png_bytep sp, dp;

+            int sshift, dshift;

+            int s_start, s_end, s_inc;

+            png_uint_32 i;

+            sp = row + (png_size_t)((row_info->width - 1) >> 2);

+            dp = row + (png_size_t)((final_width - 1) >> 2);

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+            if (transformations & PNG_PACKSWAP)

+            {

+               sshift = (png_size_t)(((row_info->width + 3) & 3) << 1);

+               dshift = (png_size_t)(((final_width + 3) & 3) << 1);

+               s_start = 6;

+               s_end = 0;

+               s_inc = -2;

+            }

+            else

+#endif

+            {

+               sshift = (png_size_t)((3 - ((row_info->width + 3) & 3)) << 1);

+               dshift = (png_size_t)((3 - ((final_width + 3) & 3)) << 1);

+               s_start = 0;

+               s_end = 6;

+               s_inc = 2;

+            }

+            for (i = row_info->width; i; i--)

+            {

+               png_byte v;

+               int j;

+               v = (png_byte)((*sp >> sshift) & 0x3);

+               for (j = 0; j < png_pass_inc[pass]; j++)

+               {

+                  *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff);

+                  *dp |= (png_byte)(v << dshift);

+                  if (dshift == s_end)

+                  {

+                     dshift = s_start;

+                     dp--;

+                  }

+                  else

+                     dshift += s_inc;

+               }

+               if (sshift == s_end)

+               {

+                  sshift = s_start;

+                  sp--;

+               }

+               else

+                  sshift += s_inc;

+            }

+            break;

+         }

+         case 4:

+         {

+            png_bytep sp, dp;

+            int sshift, dshift;

+            int s_start, s_end, s_inc;

+            png_uint_32 i;

+            sp = row + (png_size_t)((row_info->width - 1) >> 1);

+            dp = row + (png_size_t)((final_width - 1) >> 1);

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+            if (transformations & PNG_PACKSWAP)

+            {

+               sshift = (png_size_t)(((row_info->width + 1) & 1) << 2);

+               dshift = (png_size_t)(((final_width + 1) & 1) << 2);

+               s_start = 4;

+               s_end = 0;

+               s_inc = -4;

+            }

+            else

+#endif

+            {

+               sshift = (png_size_t)((1 - ((row_info->width + 1) & 1)) << 2);

+               dshift = (png_size_t)((1 - ((final_width + 1) & 1)) << 2);

+               s_start = 0;

+               s_end = 4;

+               s_inc = 4;

+            }

+            for (i = row_info->width; i; i--)

+            {

+               png_byte v;

+               int j;

+               v = (png_byte)((*sp >> sshift) & 0xf);

+               for (j = 0; j < png_pass_inc[pass]; j++)

+               {

+                  *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff);

+                  *dp |= (png_byte)(v << dshift);

+                  if (dshift == s_end)

+                  {

+                     dshift = s_start;

+                     dp--;

+                  }

+                  else

+                     dshift += s_inc;

+               }

+               if (sshift == s_end)

+               {

+                  sshift = s_start;

+                  sp--;

+               }

+               else

+                  sshift += s_inc;

+            }

+            break;

+         }

+       /*====================================================================*/

+         default: /* 8-bit or larger (this is where the routine is modified) */

+         {

+#if 0

+//          static unsigned long long _const4 = 0x0000000000FFFFFFLL;  no good

+//          static unsigned long long const4 = 0x0000000000FFFFFFLL;   no good

+//          unsigned long long _const4 = 0x0000000000FFFFFFLL;         no good

+//          unsigned long long const4 = 0x0000000000FFFFFFLL;          no good

+#endif

+            png_bytep sptr, dp;

+            png_uint_32 i;

+            png_size_t pixel_bytes;

+            int width = (int)row_info->width;

+            pixel_bytes = (row_info->pixel_depth >> 3);

+            /* point sptr at the last pixel in the pre-expanded row: */

+            sptr = row + (width - 1) * pixel_bytes;

+            /* point dp at the last pixel position in the expanded row: */

+            dp = row + (final_width - 1) * pixel_bytes;

+            /* New code by Nirav Chhatrapati - Intel Corporation */

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)

+#if !defined(PNG_1_0_X)

+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_INTERLACE)

+                /* && _mmx_supported */ )

+#else

+            if (_mmx_supported)

+#endif

+            {

+               //--------------------------------------------------------------

+               if (pixel_bytes == 3)

+               {

+                  if (((pass == 0) || (pass == 1)) && width)

+                  {

+                     int dummy_value_c;   // fix 'forbidden register spilled'

+                     int dummy_value_S;

+                     int dummy_value_D;

+                     __asm__ __volatile__ (

+                        "subl $21, %%edi         \n\t"

+                                     // (png_pass_inc[pass] - 1)*pixel_bytes

+                     ".loop3_pass0:              \n\t"

+                        "movd (%%esi), %%mm0     \n\t" // x x x x x 2 1 0

+                        "pand _const4, %%mm0     \n\t" // z z z z z 2 1 0

+                        "movq %%mm0, %%mm1       \n\t" // z z z z z 2 1 0

+                        "psllq $16, %%mm0        \n\t" // z z z 2 1 0 z z

+                        "movq %%mm0, %%mm2       \n\t" // z z z 2 1 0 z z

+                        "psllq $24, %%mm0        \n\t" // 2 1 0 z z z z z

+                        "psrlq $8, %%mm1         \n\t" // z z z z z z 2 1

+                        "por %%mm2, %%mm0        \n\t" // 2 1 0 2 1 0 z z

+                        "por %%mm1, %%mm0        \n\t" // 2 1 0 2 1 0 2 1

+                        "movq %%mm0, %%mm3       \n\t" // 2 1 0 2 1 0 2 1

+                        "psllq $16, %%mm0        \n\t" // 0 2 1 0 2 1 z z

+                        "movq %%mm3, %%mm4       \n\t" // 2 1 0 2 1 0 2 1

+                        "punpckhdq %%mm0, %%mm3  \n\t" // 0 2 1 0 2 1 0 2

+                        "movq %%mm4, 16(%%edi)   \n\t"

+                        "psrlq $32, %%mm0        \n\t" // z z z z 0 2 1 0

+                        "movq %%mm3, 8(%%edi)    \n\t"

+                        "punpckldq %%mm4, %%mm0  \n\t" // 1 0 2 1 0 2 1 0

+                        "subl $3, %%esi          \n\t"

+                        "movq %%mm0, (%%edi)     \n\t"

+                        "subl $24, %%edi         \n\t"

+                        "decl %%ecx              \n\t"

+                        "jnz .loop3_pass0        \n\t"

+                        "EMMS                    \n\t" // DONE

+                        : "=c" (dummy_value_c),        // output regs (dummy)

+                          "=S" (dummy_value_S),

+                          "=D" (dummy_value_D)

+                        : "1" (sptr),      // esi      // input regs

+                          "2" (dp),        // edi

+                          "0" (width),     // ecx

+                          "rim" (_const4)  // %1(?)  (0x0000000000FFFFFFLL)

+#if 0  /* %mm0, ..., %mm4 not supported by gcc 2.7.2.3 or egcs 1.1 */

+                        : "%mm0", "%mm1", "%mm2"       // clobber list

+                        , "%mm3", "%mm4"

+#endif

+                     );

+                  }

+                  else if (((pass == 2) || (pass == 3)) && width)

+                  {

+                     int dummy_value_c;   // fix 'forbidden register spilled'

+                     int dummy_value_S;

+                     int dummy_value_D;

+                     __asm__ __volatile__ (

+                        "subl $9, %%edi          \n\t"

+                                     // (png_pass_inc[pass] - 1)*pixel_bytes

+                     ".loop3_pass2:              \n\t"

+                        "movd (%%esi), %%mm0     \n\t" // x x x x x 2 1 0

+                        "pand _const4, %%mm0     \n\t" // z z z z z 2 1 0

+                        "movq %%mm0, %%mm1       \n\t" // z z z z z 2 1 0

+                        "psllq $16, %%mm0        \n\t" // z z z 2 1 0 z z

+                        "movq %%mm0, %%mm2       \n\t" // z z z 2 1 0 z z

+                        "psllq $24, %%mm0        \n\t" // 2 1 0 z z z z z

+                        "psrlq $8, %%mm1         \n\t" // z z z z z z 2 1

+                        "por %%mm2, %%mm0        \n\t" // 2 1 0 2 1 0 z z

+                        "por %%mm1, %%mm0        \n\t" // 2 1 0 2 1 0 2 1

+                        "movq %%mm0, 4(%%edi)    \n\t"

+                        "psrlq $16, %%mm0        \n\t" // z z 2 1 0 2 1 0

+                        "subl $3, %%esi          \n\t"

+                        "movd %%mm0, (%%edi)     \n\t"

+                        "subl $12, %%edi         \n\t"

+                        "decl %%ecx              \n\t"

+                        "jnz .loop3_pass2        \n\t"

+                        "EMMS                    \n\t" // DONE

+                        : "=c" (dummy_value_c),        // output regs (dummy)

+                          "=S" (dummy_value_S),

+                          "=D" (dummy_value_D)

+                        : "1" (sptr),      // esi      // input regs

+                          "2" (dp),        // edi

+                          "0" (width),     // ecx

+                          "rim" (_const4)  // (0x0000000000FFFFFFLL)

+#if 0  /* %mm0, ..., %mm2 not supported by gcc 2.7.2.3 or egcs 1.1 */

+                        : "%mm0", "%mm1", "%mm2"       // clobber list

+#endif

+                     );

+                  }

+                  else if (width) /* && ((pass == 4) || (pass == 5)) */

+                  {

+                     int width_mmx = ((width >> 1) << 1) - 8;   // GRR:  huh?

+                     if (width_mmx < 0)

+                         width_mmx = 0;

+                     width -= width_mmx;        // 8 or 9 pix, 24 or 27 bytes

+                     if (width_mmx)

+                     {

+                        // png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};

+                        // sptr points at last pixel in pre-expanded row

+                        // dp points at last pixel position in expanded row

+                        int dummy_value_c;  // fix 'forbidden register spilled'

+                        int dummy_value_S;

+                        int dummy_value_D;

+                        __asm__ __volatile__ (

+                           "subl $3, %%esi          \n\t"

+                           "subl $9, %%edi          \n\t"

+                                        // (png_pass_inc[pass] + 1)*pixel_bytes

+                        ".loop3_pass4:              \n\t"

+                           "movq (%%esi), %%mm0     \n\t" // x x 5 4 3 2 1 0

+                           "movq %%mm0, %%mm1       \n\t" // x x 5 4 3 2 1 0

+                           "movq %%mm0, %%mm2       \n\t" // x x 5 4 3 2 1 0

+                           "psllq $24, %%mm0        \n\t" // 4 3 2 1 0 z z z

+                           "pand _const4, %%mm1     \n\t" // z z z z z 2 1 0

+                           "psrlq $24, %%mm2        \n\t" // z z z x x 5 4 3

+                           "por %%mm1, %%mm0        \n\t" // 4 3 2 1 0 2 1 0

+                           "movq %%mm2, %%mm3       \n\t" // z z z x x 5 4 3

+                           "psllq $8, %%mm2         \n\t" // z z x x 5 4 3 z

+                           "movq %%mm0, (%%edi)     \n\t"

+                           "psrlq $16, %%mm3        \n\t" // z z z z z x x 5

+                           "pand _const6, %%mm3     \n\t" // z z z z z z z 5

+                           "por %%mm3, %%mm2        \n\t" // z z x x 5 4 3 5

+                           "subl $6, %%esi          \n\t"

+                           "movd %%mm2, 8(%%edi)    \n\t"

+                           "subl $12, %%edi         \n\t"

+                           "subl $2, %%ecx          \n\t"

+                           "jnz .loop3_pass4        \n\t"

+                           "EMMS                    \n\t" // DONE

+                           : "=c" (dummy_value_c),        // output regs (dummy)

+                             "=S" (dummy_value_S),

+                             "=D" (dummy_value_D)

+                           : "1" (sptr),      // esi      // input regs

+                             "2" (dp),        // edi

+                             "0" (width_mmx), // ecx

+                             "rim" (_const4), // 0x0000000000FFFFFFLL

+                             "rim" (_const6)  // 0x00000000000000FFLL

+#if 0  /* %mm0, ..., %mm3 not supported by gcc 2.7.2.3 or egcs 1.1 */

+                           : "%mm0", "%mm1"               // clobber list

+                           , "%mm2", "%mm3"

+#endif

+                        );

+                     }

+                     sptr -= width_mmx*3;

+                     dp -= width_mmx*6;

+                     for (i = width; i; i--)

+                     {

+                        png_byte v[8];

+                        int j;

+                        png_memcpy(v, sptr, 3);

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                        {

+                           png_memcpy(dp, v, 3);

+                           dp -= 3;

+                        }

+                        sptr -= 3;

+                     }

+                  }

+               } /* end of pixel_bytes == 3 */

+               //--------------------------------------------------------------

+               else if (pixel_bytes == 1)

+               {

+                  if (((pass == 0) || (pass == 1)) && width)

+                  {

+                     int width_mmx = ((width >> 2) << 2);

+                     width -= width_mmx;        // 0-3 pixels => 0-3 bytes

+                     if (width_mmx)

+                     {

+                        int dummy_value_c;  // fix 'forbidden register spilled'

+                        int dummy_value_S;

+                        int dummy_value_D;

+                        __asm__ __volatile__ (

+                           "subl $3, %%esi          \n\t"

+                           "subl $31, %%edi         \n\t"

+                        ".loop1_pass0:              \n\t"

+                           "movd (%%esi), %%mm0     \n\t" // x x x x 3 2 1 0

+                           "movq %%mm0, %%mm1       \n\t" // x x x x 3 2 1 0

+                           "punpcklbw %%mm0, %%mm0  \n\t" // 3 3 2 2 1 1 0 0

+                           "movq %%mm0, %%mm2       \n\t" // 3 3 2 2 1 1 0 0

+                           "punpcklwd %%mm0, %%mm0  \n\t" // 1 1 1 1 0 0 0 0

+                           "movq %%mm0, %%mm3       \n\t" // 1 1 1 1 0 0 0 0

+                           "punpckldq %%mm0, %%mm0  \n\t" // 0 0 0 0 0 0 0 0

+                           "punpckhdq %%mm3, %%mm3  \n\t" // 1 1 1 1 1 1 1 1

+                           "movq %%mm0, (%%edi)     \n\t"

+                           "punpckhwd %%mm2, %%mm2  \n\t" // 3 3 3 3 2 2 2 2

+                           "movq %%mm3, 8(%%edi)    \n\t"

+                           "movq %%mm2, %%mm4       \n\t" // 3 3 3 3 2 2 2 2

+                           "punpckldq %%mm2, %%mm2  \n\t" // 2 2 2 2 2 2 2 2

+                           "punpckhdq %%mm4, %%mm4  \n\t" // 3 3 3 3 3 3 3 3

+                           "movq %%mm2, 16(%%edi)   \n\t"

+                           "subl $4, %%esi          \n\t"

+                           "movq %%mm4, 24(%%edi)   \n\t"

+                           "subl $32, %%edi         \n\t"

+                           "subl $4, %%ecx          \n\t"

+                           "jnz .loop1_pass0        \n\t"

+                           "EMMS                    \n\t" // DONE

+                           : "=c" (dummy_value_c),        // output regs (dummy)

+                             "=S" (dummy_value_S),

+                             "=D" (dummy_value_D)

+                           : "1" (sptr),      // esi      // input regs

+                             "2" (dp),        // edi

+                             "0" (width_mmx)  // ecx

+#if 0  /* %mm0, ..., %mm4 not supported by gcc 2.7.2.3 or egcs 1.1 */

+                           : "%mm0", "%mm1", "%mm2"       // clobber list

+                           , "%mm3", "%mm4"

+#endif

+                        );

+                     }

+                     sptr -= width_mmx;

+                     dp -= width_mmx*8;

+                     for (i = width; i; i--)

+                     {

+                        int j;

+                       /* I simplified this part in version 1.0.4e

+                        * here and in several other instances where

+                        * pixel_bytes == 1  -- GR-P

+                        *

+                        * Original code:

+                        *

+                        * png_byte v[8];

+                        * png_memcpy(v, sptr, pixel_bytes);

+                        * for (j = 0; j < png_pass_inc[pass]; j++)

+                        * {

+                        *    png_memcpy(dp, v, pixel_bytes);

+                        *    dp -= pixel_bytes;

+                        * }

+                        * sptr -= pixel_bytes;

+                        *

+                        * Replacement code is in the next three lines:

+                        */

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                        {

+                           *dp-- = *sptr;

+                        }

+                        --sptr;

+                     }

+                  }

+                  else if (((pass == 2) || (pass == 3)) && width)

+                  {

+                     int width_mmx = ((width >> 2) << 2);

+                     width -= width_mmx;        // 0-3 pixels => 0-3 bytes

+                     if (width_mmx)

+                     {

+                        int dummy_value_c;  // fix 'forbidden register spilled'

+                        int dummy_value_S;

+                        int dummy_value_D;

+                        __asm__ __volatile__ (

+                           "subl $3, %%esi          \n\t"

+                           "subl $15, %%edi         \n\t"

+                        ".loop1_pass2:              \n\t"

+                           "movd (%%esi), %%mm0     \n\t" // x x x x 3 2 1 0

+                           "punpcklbw %%mm0, %%mm0  \n\t" // 3 3 2 2 1 1 0 0

+                           "movq %%mm0, %%mm1       \n\t" // 3 3 2 2 1 1 0 0

+                           "punpcklwd %%mm0, %%mm0  \n\t" // 1 1 1 1 0 0 0 0

+                           "punpckhwd %%mm1, %%mm1  \n\t" // 3 3 3 3 2 2 2 2

+                           "movq %%mm0, (%%edi)     \n\t"

+                           "subl $4, %%esi          \n\t"

+                           "movq %%mm1, 8(%%edi)    \n\t"

+                           "subl $16, %%edi         \n\t"

+                           "subl $4, %%ecx          \n\t"

+                           "jnz .loop1_pass2        \n\t"

+                           "EMMS                    \n\t" // DONE

+                           : "=c" (dummy_value_c),        // output regs (dummy)

+                             "=S" (dummy_value_S),

+                             "=D" (dummy_value_D)

+                           : "1" (sptr),      // esi      // input regs

+                             "2" (dp),        // edi

+                             "0" (width_mmx)  // ecx

+#if 0  /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */

+                           : "%mm0", "%mm1"               // clobber list

+#endif

+                        );

+                     }

+                     sptr -= width_mmx;

+                     dp -= width_mmx*4;

+                     for (i = width; i; i--)

+                     {

+                        int j;

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                        {

+                           *dp-- = *sptr;

+                        }

+                        --sptr;

+                     }

+                  }

+                  else if (width)  /* && ((pass == 4) || (pass == 5)) */

+                  {

+                     int width_mmx = ((width >> 3) << 3);

+                     width -= width_mmx;        // 0-3 pixels => 0-3 bytes

+                     if (width_mmx)

+                     {

+                        int dummy_value_c;  // fix 'forbidden register spilled'

+                        int dummy_value_S;

+                        int dummy_value_D;

+                        __asm__ __volatile__ (

+                           "subl $7, %%esi          \n\t"

+                           "subl $15, %%edi         \n\t"

+                        ".loop1_pass4:              \n\t"

+                           "movq (%%esi), %%mm0     \n\t" // 7 6 5 4 3 2 1 0

+                           "movq %%mm0, %%mm1       \n\t" // 7 6 5 4 3 2 1 0

+                           "punpcklbw %%mm0, %%mm0  \n\t" // 3 3 2 2 1 1 0 0

+                           "punpckhbw %%mm1, %%mm1  \n\t" // 7 7 6 6 5 5 4 4

+                           "movq %%mm1, 8(%%edi)    \n\t"

+                           "subl $8, %%esi          \n\t"

+                           "movq %%mm0, (%%edi)     \n\t"

+                           "subl $16, %%edi         \n\t"

+                           "subl $8, %%ecx          \n\t"

+                           "jnz .loop1_pass4        \n\t"

+                           "EMMS                    \n\t" // DONE

+                           : "=c" (dummy_value_c),        // output regs (none)

+                             "=S" (dummy_value_S),

+                             "=D" (dummy_value_D)

+                           : "1" (sptr),      // esi      // input regs

+                             "2" (dp),        // edi

+                             "0" (width_mmx)  // ecx

+#if 0  /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */

+                           : "%mm0", "%mm1"               // clobber list

+#endif

+                        );

+                     }

+                     sptr -= width_mmx;

+                     dp -= width_mmx*2;

+                     for (i = width; i; i--)

+                     {

+                        int j;

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                        {

+                           *dp-- = *sptr;

+                        }

+                        --sptr;

+                     }

+                  }

+               } /* end of pixel_bytes == 1 */

+               //--------------------------------------------------------------

+               else if (pixel_bytes == 2)

+               {

+                  if (((pass == 0) || (pass == 1)) && width)

+                  {

+                     int width_mmx = ((width >> 1) << 1);

+                     width -= width_mmx;        // 0,1 pixels => 0,2 bytes

+                     if (width_mmx)

+                     {

+                        int dummy_value_c;  // fix 'forbidden register spilled'

+                        int dummy_value_S;

+                        int dummy_value_D;

+                        __asm__ __volatile__ (

+                           "subl $2, %%esi          \n\t"

+                           "subl $30, %%edi         \n\t"

+                        ".loop2_pass0:              \n\t"

+                           "movd (%%esi), %%mm0     \n\t" // x x x x 3 2 1 0

+                           "punpcklwd %%mm0, %%mm0  \n\t" // 3 2 3 2 1 0 1 0

+                           "movq %%mm0, %%mm1       \n\t" // 3 2 3 2 1 0 1 0

+                           "punpckldq %%mm0, %%mm0  \n\t" // 1 0 1 0 1 0 1 0

+                           "punpckhdq %%mm1, %%mm1  \n\t" // 3 2 3 2 3 2 3 2

+                           "movq %%mm0, (%%edi)     \n\t"

+                           "movq %%mm0, 8(%%edi)    \n\t"

+                           "movq %%mm1, 16(%%edi)   \n\t"

+                           "subl $4, %%esi          \n\t"

+                           "movq %%mm1, 24(%%edi)   \n\t"

+                           "subl $32, %%edi         \n\t"

+                           "subl $2, %%ecx          \n\t"

+                           "jnz .loop2_pass0        \n\t"

+                           "EMMS                    \n\t" // DONE

+                           : "=c" (dummy_value_c),        // output regs (dummy)

+                             "=S" (dummy_value_S),

+                             "=D" (dummy_value_D)

+                           : "1" (sptr),      // esi      // input regs

+                             "2" (dp),        // edi

+                             "0" (width_mmx)  // ecx

+#if 0  /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */

+                           : "%mm0", "%mm1"               // clobber list

+#endif

+                        );

+                     }

+                     sptr -= (width_mmx*2 - 2); // sign fixed

+                     dp -= (width_mmx*16 - 2);  // sign fixed

+                     for (i = width; i; i--)

+                     {

+                        png_byte v[8];

+                        int j;

+                        sptr -= 2;

+                        png_memcpy(v, sptr, 2);

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                        {

+                           dp -= 2;

+                           png_memcpy(dp, v, 2);

+                        }

+                     }

+                  }

+                  else if (((pass == 2) || (pass == 3)) && width)

+                  {

+                     int width_mmx = ((width >> 1) << 1) ;

+                     width -= width_mmx;        // 0,1 pixels => 0,2 bytes

+                     if (width_mmx)

+                     {

+                        int dummy_value_c;  // fix 'forbidden register spilled'

+                        int dummy_value_S;

+                        int dummy_value_D;

+                        __asm__ __volatile__ (

+                           "subl $2, %%esi          \n\t"

+                           "subl $14, %%edi         \n\t"

+                        ".loop2_pass2:              \n\t"

+                           "movd (%%esi), %%mm0     \n\t" // x x x x 3 2 1 0

+                           "punpcklwd %%mm0, %%mm0  \n\t" // 3 2 3 2 1 0 1 0

+                           "movq %%mm0, %%mm1       \n\t" // 3 2 3 2 1 0 1 0

+                           "punpckldq %%mm0, %%mm0  \n\t" // 1 0 1 0 1 0 1 0

+                           "punpckhdq %%mm1, %%mm1  \n\t" // 3 2 3 2 3 2 3 2

+                           "movq %%mm0, (%%edi)     \n\t"

+                           "subl $4, %%esi          \n\t"

+                           "movq %%mm1, 8(%%edi)    \n\t"

+                           "subl $16, %%edi         \n\t"

+                           "subl $2, %%ecx          \n\t"

+                           "jnz .loop2_pass2        \n\t"

+                           "EMMS                    \n\t" // DONE

+                           : "=c" (dummy_value_c),        // output regs (dummy)

+                             "=S" (dummy_value_S),

+                             "=D" (dummy_value_D)

+                           : "1" (sptr),      // esi      // input regs

+                             "2" (dp),        // edi

+                             "0" (width_mmx)  // ecx

+#if 0  /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */

+                           : "%mm0", "%mm1"               // clobber list

+#endif

+                        );

+                     }

+                     sptr -= (width_mmx*2 - 2); // sign fixed

+                     dp -= (width_mmx*8 - 2);   // sign fixed

+                     for (i = width; i; i--)

+                     {

+                        png_byte v[8];

+                        int j;

+                        sptr -= 2;

+                        png_memcpy(v, sptr, 2);

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                        {

+                           dp -= 2;

+                           png_memcpy(dp, v, 2);

+                        }

+                     }

+                  }

+                  else if (width)  // pass == 4 or 5

+                  {

+                     int width_mmx = ((width >> 1) << 1) ;

+                     width -= width_mmx;        // 0,1 pixels => 0,2 bytes

+                     if (width_mmx)

+                     {

+                        int dummy_value_c;  // fix 'forbidden register spilled'

+                        int dummy_value_S;

+                        int dummy_value_D;

+                        __asm__ __volatile__ (

+                           "subl $2, %%esi          \n\t"

+                           "subl $6, %%edi          \n\t"

+                        ".loop2_pass4:              \n\t"

+                           "movd (%%esi), %%mm0     \n\t" // x x x x 3 2 1 0

+                           "punpcklwd %%mm0, %%mm0  \n\t" // 3 2 3 2 1 0 1 0

+                           "subl $4, %%esi          \n\t"

+                           "movq %%mm0, (%%edi)     \n\t"

+                           "subl $8, %%edi          \n\t"

+                           "subl $2, %%ecx          \n\t"

+                           "jnz .loop2_pass4        \n\t"

+                           "EMMS                    \n\t" // DONE

+                           : "=c" (dummy_value_c),        // output regs (dummy)

+                             "=S" (dummy_value_S),

+                             "=D" (dummy_value_D)

+                           : "1" (sptr),      // esi      // input regs

+                             "2" (dp),        // edi

+                             "0" (width_mmx)  // ecx

+#if 0  /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */

+                           : "%mm0"                       // clobber list

+#endif

+                        );

+                     }

+                     sptr -= (width_mmx*2 - 2); // sign fixed

+                     dp -= (width_mmx*4 - 2);   // sign fixed

+                     for (i = width; i; i--)

+                     {

+                        png_byte v[8];

+                        int j;

+                        sptr -= 2;

+                        png_memcpy(v, sptr, 2);

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                        {

+                           dp -= 2;

+                           png_memcpy(dp, v, 2);

+                        }

+                     }

+                  }

+               } /* end of pixel_bytes == 2 */

+               //--------------------------------------------------------------

+               else if (pixel_bytes == 4)

+               {

+                  if (((pass == 0) || (pass == 1)) && width)

+                  {

+                     int width_mmx = ((width >> 1) << 1);

+                     width -= width_mmx;        // 0,1 pixels => 0,4 bytes

+                     if (width_mmx)

+                     {

+                        int dummy_value_c;  // fix 'forbidden register spilled'

+                        int dummy_value_S;

+                        int dummy_value_D;

+                        __asm__ __volatile__ (

+                           "subl $4, %%esi          \n\t"

+                           "subl $60, %%edi         \n\t"

+                        ".loop4_pass0:              \n\t"

+                           "movq (%%esi), %%mm0     \n\t" // 7 6 5 4 3 2 1 0

+                           "movq %%mm0, %%mm1       \n\t" // 7 6 5 4 3 2 1 0

+                           "punpckldq %%mm0, %%mm0  \n\t" // 3 2 1 0 3 2 1 0

+                           "punpckhdq %%mm1, %%mm1  \n\t" // 7 6 5 4 7 6 5 4

+                           "movq %%mm0, (%%edi)     \n\t"

+                           "movq %%mm0, 8(%%edi)    \n\t"

+                           "movq %%mm0, 16(%%edi)   \n\t"

+                           "movq %%mm0, 24(%%edi)   \n\t"

+                           "movq %%mm1, 32(%%edi)   \n\t"

+                           "movq %%mm1, 40(%%edi)   \n\t"

+                           "movq %%mm1, 48(%%edi)   \n\t"

+                           "subl $8, %%esi          \n\t"

+                           "movq %%mm1, 56(%%edi)   \n\t"

+                           "subl $64, %%edi         \n\t"

+                           "subl $2, %%ecx          \n\t"

+                           "jnz .loop4_pass0        \n\t"

+                           "EMMS                    \n\t" // DONE

+                           : "=c" (dummy_value_c),        // output regs (dummy)

+                             "=S" (dummy_value_S),

+                             "=D" (dummy_value_D)

+                           : "1" (sptr),      // esi      // input regs

+                             "2" (dp),        // edi

+                             "0" (width_mmx)  // ecx

+#if 0  /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */

+                           : "%mm0", "%mm1"               // clobber list

+#endif

+                        );

+                     }

+                     sptr -= (width_mmx*4 - 4); // sign fixed

+                     dp -= (width_mmx*32 - 4);  // sign fixed

+                     for (i = width; i; i--)

+                     {

+                        png_byte v[8];

+                        int j;

+                        sptr -= 4;

+                        png_memcpy(v, sptr, 4);

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                        {

+                           dp -= 4;

+                           png_memcpy(dp, v, 4);

+                        }

+                     }

+                  }

+                  else if (((pass == 2) || (pass == 3)) && width)

+                  {

+                     int width_mmx = ((width >> 1) << 1);

+                     width -= width_mmx;        // 0,1 pixels => 0,4 bytes

+                     if (width_mmx)

+                     {

+                        int dummy_value_c;  // fix 'forbidden register spilled'

+                        int dummy_value_S;

+                        int dummy_value_D;

+                        __asm__ __volatile__ (

+                           "subl $4, %%esi          \n\t"

+                           "subl $28, %%edi         \n\t"

+                        ".loop4_pass2:              \n\t"

+                           "movq (%%esi), %%mm0     \n\t" // 7 6 5 4 3 2 1 0

+                           "movq %%mm0, %%mm1       \n\t" // 7 6 5 4 3 2 1 0

+                           "punpckldq %%mm0, %%mm0  \n\t" // 3 2 1 0 3 2 1 0

+                           "punpckhdq %%mm1, %%mm1  \n\t" // 7 6 5 4 7 6 5 4

+                           "movq %%mm0, (%%edi)     \n\t"

+                           "movq %%mm0, 8(%%edi)    \n\t"

+                           "movq %%mm1, 16(%%edi)   \n\t"

+                           "movq %%mm1, 24(%%edi)   \n\t"

+                           "subl $8, %%esi          \n\t"

+                           "subl $32, %%edi         \n\t"

+                           "subl $2, %%ecx          \n\t"

+                           "jnz .loop4_pass2        \n\t"

+                           "EMMS                    \n\t" // DONE

+                           : "=c" (dummy_value_c),        // output regs (dummy)

+                             "=S" (dummy_value_S),

+                             "=D" (dummy_value_D)

+                           : "1" (sptr),      // esi      // input regs

+                             "2" (dp),        // edi

+                             "0" (width_mmx)  // ecx

+#if 0  /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */

+                           : "%mm0", "%mm1"               // clobber list

+#endif

+                        );

+                     }

+                     sptr -= (width_mmx*4 - 4); // sign fixed

+                     dp -= (width_mmx*16 - 4);  // sign fixed

+                     for (i = width; i; i--)

+                     {

+                        png_byte v[8];

+                        int j;

+                        sptr -= 4;

+                        png_memcpy(v, sptr, 4);

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                        {

+                           dp -= 4;

+                           png_memcpy(dp, v, 4);

+                        }

+                     }

+                  }

+                  else if (width)  // pass == 4 or 5

+                  {

+                     int width_mmx = ((width >> 1) << 1) ;

+                     width -= width_mmx;        // 0,1 pixels => 0,4 bytes

+                     if (width_mmx)

+                     {

+                        int dummy_value_c;  // fix 'forbidden register spilled'

+                        int dummy_value_S;

+                        int dummy_value_D;

+                        __asm__ __volatile__ (

+                           "subl $4, %%esi          \n\t"

+                           "subl $12, %%edi         \n\t"

+                        ".loop4_pass4:              \n\t"

+                           "movq (%%esi), %%mm0     \n\t" // 7 6 5 4 3 2 1 0

+                           "movq %%mm0, %%mm1       \n\t" // 7 6 5 4 3 2 1 0

+                           "punpckldq %%mm0, %%mm0  \n\t" // 3 2 1 0 3 2 1 0

+                           "punpckhdq %%mm1, %%mm1  \n\t" // 7 6 5 4 7 6 5 4

+                           "movq %%mm0, (%%edi)     \n\t"

+                           "subl $8, %%esi          \n\t"

+                           "movq %%mm1, 8(%%edi)    \n\t"

+                           "subl $16, %%edi         \n\t"

+                           "subl $2, %%ecx          \n\t"

+                           "jnz .loop4_pass4        \n\t"

+                           "EMMS                    \n\t" // DONE

+                           : "=c" (dummy_value_c),        // output regs (dummy)

+                             "=S" (dummy_value_S),

+                             "=D" (dummy_value_D)

+                           : "1" (sptr),      // esi      // input regs

+                             "2" (dp),        // edi

+                             "0" (width_mmx)  // ecx

+#if 0  /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */

+                           : "%mm0", "%mm1"               // clobber list

+#endif

+                        );

+                     }

+                     sptr -= (width_mmx*4 - 4); // sign fixed

+                     dp -= (width_mmx*8 - 4);   // sign fixed

+                     for (i = width; i; i--)

+                     {

+                        png_byte v[8];

+                        int j;

+                        sptr -= 4;

+                        png_memcpy(v, sptr, 4);

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                        {

+                           dp -= 4;

+                           png_memcpy(dp, v, 4);

+                        }

+                     }

+                  }

+               } /* end of pixel_bytes == 4 */

+               //--------------------------------------------------------------

+               else if (pixel_bytes == 8)

+               {

+// GRR TEST:  should work, but needs testing (special 64-bit version of rpng2?)

+                  // GRR NOTE:  no need to combine passes here!

+                  if (((pass == 0) || (pass == 1)) && width)

+                  {

+                     int dummy_value_c;  // fix 'forbidden register spilled'

+                     int dummy_value_S;

+                     int dummy_value_D;

+                     // source is 8-byte RRGGBBAA

+                     // dest is 64-byte RRGGBBAA RRGGBBAA RRGGBBAA RRGGBBAA ...

+                     __asm__ __volatile__ (

+                        "subl $56, %%edi         \n\t" // start of last block

+                     ".loop8_pass0:              \n\t"

+                        "movq (%%esi), %%mm0     \n\t" // 7 6 5 4 3 2 1 0

+                        "movq %%mm0, (%%edi)     \n\t"

+                        "movq %%mm0, 8(%%edi)    \n\t"

+                        "movq %%mm0, 16(%%edi)   \n\t"

+                        "movq %%mm0, 24(%%edi)   \n\t"

+                        "movq %%mm0, 32(%%edi)   \n\t"

+                        "movq %%mm0, 40(%%edi)   \n\t"

+                        "movq %%mm0, 48(%%edi)   \n\t"

+                        "subl $8, %%esi          \n\t"

+                        "movq %%mm0, 56(%%edi)   \n\t"

+                        "subl $64, %%edi         \n\t"

+                        "decl %%ecx              \n\t"

+                        "jnz .loop8_pass0        \n\t"

+                        "EMMS                    \n\t" // DONE

+                        : "=c" (dummy_value_c),        // output regs (dummy)

+                          "=S" (dummy_value_S),

+                          "=D" (dummy_value_D)

+                        : "1" (sptr),      // esi      // input regs

+                          "2" (dp),        // edi

+                          "0" (width)      // ecx

+#if 0  /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */

+                        : "%mm0"                       // clobber list

+#endif

+                     );

+                  }

+                  else if (((pass == 2) || (pass == 3)) && width)

+                  {

+                     // source is 8-byte RRGGBBAA

+                     // dest is 32-byte RRGGBBAA RRGGBBAA RRGGBBAA RRGGBBAA

+                     // (recall that expansion is _in place_:  sptr and dp

+                     //  both point at locations within same row buffer)

+                     {

+                        int dummy_value_c;  // fix 'forbidden register spilled'

+                        int dummy_value_S;

+                        int dummy_value_D;

+                        __asm__ __volatile__ (

+                           "subl $24, %%edi         \n\t" // start of last block

+                        ".loop8_pass2:              \n\t"

+                           "movq (%%esi), %%mm0     \n\t" // 7 6 5 4 3 2 1 0

+                           "movq %%mm0, (%%edi)     \n\t"

+                           "movq %%mm0, 8(%%edi)    \n\t"

+                           "movq %%mm0, 16(%%edi)   \n\t"

+                           "subl $8, %%esi          \n\t"

+                           "movq %%mm0, 24(%%edi)   \n\t"

+                           "subl $32, %%edi         \n\t"

+                           "decl %%ecx              \n\t"

+                           "jnz .loop8_pass2        \n\t"

+                           "EMMS                    \n\t" // DONE

+                           : "=c" (dummy_value_c),        // output regs (dummy)

+                             "=S" (dummy_value_S),

+                             "=D" (dummy_value_D)

+                           : "1" (sptr),      // esi      // input regs

+                             "2" (dp),        // edi

+                             "0" (width)      // ecx

+#if 0  /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */

+                           : "%mm0"                       // clobber list

+#endif

+                        );

+                     }

+                  }

+                  else if (width)  // pass == 4 or 5

+                  {

+                     // source is 8-byte RRGGBBAA

+                     // dest is 16-byte RRGGBBAA RRGGBBAA

+                     {

+                        int dummy_value_c;  // fix 'forbidden register spilled'

+                        int dummy_value_S;

+                        int dummy_value_D;

+                        __asm__ __volatile__ (

+                           "subl $8, %%edi          \n\t" // start of last block

+                        ".loop8_pass4:              \n\t"

+                           "movq (%%esi), %%mm0     \n\t" // 7 6 5 4 3 2 1 0

+                           "movq %%mm0, (%%edi)     \n\t"

+                           "subl $8, %%esi          \n\t"

+                           "movq %%mm0, 8(%%edi)    \n\t"

+                           "subl $16, %%edi         \n\t"

+                           "decl %%ecx              \n\t"

+                           "jnz .loop8_pass4        \n\t"

+                           "EMMS                    \n\t" // DONE

+                           : "=c" (dummy_value_c),        // output regs (dummy)

+                             "=S" (dummy_value_S),

+                             "=D" (dummy_value_D)

+                           : "1" (sptr),      // esi      // input regs

+                             "2" (dp),        // edi

+                             "0" (width)      // ecx

+#if 0  /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */

+                           : "%mm0"                       // clobber list

+#endif

+                        );

+                     }

+                  }

+               } /* end of pixel_bytes == 8 */

+               //--------------------------------------------------------------

+               else if (pixel_bytes == 6)

+               {

+                  for (i = width; i; i--)

+                  {

+                     png_byte v[8];

+                     int j;

+                     png_memcpy(v, sptr, 6);

+                     for (j = 0; j < png_pass_inc[pass]; j++)

+                     {

+                        png_memcpy(dp, v, 6);

+                        dp -= 6;

+                     }

+                     sptr -= 6;

+                  }

+               } /* end of pixel_bytes == 6 */

+               //--------------------------------------------------------------

+               else

+               {

+                  for (i = width; i; i--)

+                  {

+                     png_byte v[8];

+                     int j;

+                     png_memcpy(v, sptr, pixel_bytes);

+                     for (j = 0; j < png_pass_inc[pass]; j++)

+                     {

+                        png_memcpy(dp, v, pixel_bytes);

+                        dp -= pixel_bytes;

+                     }

+                     sptr-= pixel_bytes;

+                  }

+               }

+            } // end of _mmx_supported ========================================

+            else /* MMX not supported:  use modified C code - takes advantage

+                  *   of inlining of png_memcpy for a constant */

+                 /* GRR 19991007:  does it?  or should pixel_bytes in each

+                  *   block be replaced with immediate value (e.g., 1)? */

+                 /* GRR 19991017:  replaced with constants in each case */

+#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */

+            {

+               if (pixel_bytes == 1)

+               {

+                  for (i = width; i; i--)

+                  {

+                     int j;

+                     for (j = 0; j < png_pass_inc[pass]; j++)

+                     {

+                        *dp-- = *sptr;

+                     }

+                     --sptr;

+                  }

+               }

+               else if (pixel_bytes == 3)

+               {

+                  for (i = width; i; i--)

+                  {

+                     png_byte v[8];

+                     int j;

+                     png_memcpy(v, sptr, 3);

+                     for (j = 0; j < png_pass_inc[pass]; j++)

+                     {

+                        png_memcpy(dp, v, 3);

+                        dp -= 3;

+                     }

+                     sptr -= 3;

+                  }

+               }

+               else if (pixel_bytes == 2)

+               {

+                  for (i = width; i; i--)

+                  {

+                     png_byte v[8];

+                     int j;

+                     png_memcpy(v, sptr, 2);

+                     for (j = 0; j < png_pass_inc[pass]; j++)

+                     {

+                        png_memcpy(dp, v, 2);

+                        dp -= 2;

+                     }

+                     sptr -= 2;

+                  }

+               }

+               else if (pixel_bytes == 4)

+               {

+                  for (i = width; i; i--)

+                  {

+                     png_byte v[8];

+                     int j;

+                     png_memcpy(v, sptr, 4);

+                     for (j = 0; j < png_pass_inc[pass]; j++)

+                     {

+#ifdef PNG_DEBUG

+                        if (dp < row || dp+3 > row+png_ptr->row_buf_size)

+                        {

+                           printf("dp out of bounds: row=%d, dp=%d, rp=%d\n",

+                             row, dp, row+png_ptr->row_buf_size);

+                           printf("row_buf=%d\n",png_ptr->row_buf_size);

+                        }

+#endif

+                        png_memcpy(dp, v, 4);

+                        dp -= 4;

+                     }

+                     sptr -= 4;

+                  }

+               }

+               else if (pixel_bytes == 6)

+               {

+                  for (i = width; i; i--)

+                  {

+                     png_byte v[8];

+                     int j;

+                     png_memcpy(v, sptr, 6);

+                     for (j = 0; j < png_pass_inc[pass]; j++)

+                     {

+                        png_memcpy(dp, v, 6);

+                        dp -= 6;

+                     }

+                     sptr -= 6;

+                  }

+               }

+               else if (pixel_bytes == 8)

+               {

+                  for (i = width; i; i--)

+                  {

+                     png_byte v[8];

+                     int j;

+                     png_memcpy(v, sptr, 8);

+                     for (j = 0; j < png_pass_inc[pass]; j++)

+                     {

+                        png_memcpy(dp, v, 8);

+                        dp -= 8;

+                     }

+                     sptr -= 8;

+                  }

+               }

+               else     /* GRR:  should never be reached */

+               {

+                  for (i = width; i; i--)

+                  {

+                     png_byte v[8];

+                     int j;

+                     png_memcpy(v, sptr, pixel_bytes);

+                     for (j = 0; j < png_pass_inc[pass]; j++)

+                     {

+                        png_memcpy(dp, v, pixel_bytes);

+                        dp -= pixel_bytes;

+                     }

+                     sptr -= pixel_bytes;

+                  }

+               }

+            } /* end if (MMX not supported) */

+            break;

+         }

+      } /* end switch (row_info->pixel_depth) */

+      row_info->width = final_width;

+      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,final_width);

+   }

+} /* end png_do_read_interlace() */

+#endif /* PNG_HAVE_ASSEMBLER_READ_INTERLACE */

+#endif /* PNG_READ_INTERLACING_SUPPORTED */

+#if defined(PNG_HAVE_ASSEMBLER_READ_FILTER_ROW)

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)

+// These variables are utilized in the functions below.  They are declared

+// globally here to ensure alignment on 8-byte boundaries.

+union uAll {

+   long long use;

+   double  align;

+} _LBCarryMask = {0x0101010101010101LL},

+  _HBClearMask = {0x7f7f7f7f7f7f7f7fLL},

+  _ActiveMask, _ActiveMask2, _ActiveMaskEnd, _ShiftBpp, _ShiftRem;

+#ifdef PNG_THREAD_UNSAFE_OK

+//===========================================================================//

+//                                                                           //

+//           P N G _ R E A D _ F I L T E R _ R O W _ M M X _ A V G           //

+//                                                                           //

+//===========================================================================//

+// Optimized code for PNG Average filter decoder

+static void /* PRIVATE */

+png_read_filter_row_mmx_avg(png_row_infop row_info, png_bytep row,

+                            png_bytep prev_row)

+{

+   int bpp;

+   int dummy_value_c;   // fix 'forbidden register 2 (cx) was spilled' error

+   int dummy_value_S;

+   int dummy_value_D;

+   bpp = (row_info->pixel_depth + 7) >> 3;  // get # bytes per pixel

+   _FullLength  = row_info->rowbytes;       // # of bytes to filter

+   __asm__ __volatile__ (

+      // initialize address pointers and offset

+#ifdef __PIC__

+      "pushl %%ebx                 \n\t" // save index to Global Offset Table

+#endif

+//pre "movl row, %%edi             \n\t" // edi:  Avg(x)

+      "xorl %%ebx, %%ebx           \n\t" // ebx:  x

+      "movl %%edi, %%edx           \n\t"

+//pre "movl prev_row, %%esi        \n\t" // esi:  Prior(x)

+//pre "subl bpp, %%edx             \n\t" // (bpp is preloaded into ecx)

+      "subl %%ecx, %%edx           \n\t" // edx:  Raw(x-bpp)

+      "xorl %%eax,%%eax            \n\t"

+      // Compute the Raw value for the first bpp bytes

+      //    Raw(x) = Avg(x) + (Prior(x)/2)

+   "avg_rlp:                       \n\t"

+      "movb (%%esi,%%ebx,),%%al    \n\t" // load al with Prior(x)

+      "incl %%ebx                  \n\t"

+      "shrb %%al                   \n\t" // divide by 2

+      "addb -1(%%edi,%%ebx,),%%al  \n\t" // add Avg(x); -1 to offset inc ebx

+//pre "cmpl bpp, %%ebx             \n\t" // (bpp is preloaded into ecx)

+      "cmpl %%ecx, %%ebx           \n\t"

+      "movb %%al,-1(%%edi,%%ebx,)  \n\t" // write Raw(x); -1 to offset inc ebx

+      "jb avg_rlp                  \n\t" // mov does not affect flags

+      // get # of bytes to alignment

+      "movl %%edi, _dif            \n\t" // take start of row

+      "addl %%ebx, _dif            \n\t" // add bpp

+      "addl $0xf, _dif             \n\t" // add 7+8 to incr past alignment bdry

+      "andl $0xfffffff8, _dif      \n\t" // mask to alignment boundary

+      "subl %%edi, _dif            \n\t" // subtract from start => value ebx at

+      "jz avg_go                   \n\t" //  alignment

+      // fix alignment

+      // Compute the Raw value for the bytes up to the alignment boundary

+      //    Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2)

+      "xorl %%ecx, %%ecx           \n\t"

+   "avg_lp1:                       \n\t"

+      "xorl %%eax, %%eax           \n\t"

+      "movb (%%esi,%%ebx,), %%cl   \n\t" // load cl with Prior(x)

+      "movb (%%edx,%%ebx,), %%al   \n\t" // load al with Raw(x-bpp)

+      "addw %%cx, %%ax             \n\t"

+      "incl %%ebx                  \n\t"

+      "shrw %%ax                   \n\t" // divide by 2

+      "addb -1(%%edi,%%ebx,), %%al \n\t" // add Avg(x); -1 to offset inc ebx

+      "cmpl _dif, %%ebx            \n\t" // check if at alignment boundary

+      "movb %%al, -1(%%edi,%%ebx,) \n\t" // write Raw(x); -1 to offset inc ebx

+      "jb avg_lp1                  \n\t" // repeat until at alignment boundary

+   "avg_go:                        \n\t"

+      "movl _FullLength, %%eax     \n\t"

+      "movl %%eax, %%ecx           \n\t"

+      "subl %%ebx, %%eax           \n\t" // subtract alignment fix

+      "andl $0x00000007, %%eax     \n\t" // calc bytes over mult of 8

+      "subl %%eax, %%ecx           \n\t" // drop over bytes from original length

+      "movl %%ecx, _MMXLength      \n\t"

+#ifdef __PIC__

+      "popl %%ebx                  \n\t" // restore index to Global Offset Table

+#endif

+      : "=c" (dummy_value_c),            // output regs (dummy)

+        "=S" (dummy_value_S),

+        "=D" (dummy_value_D)

+      : "0" (bpp),       // ecx          // input regs

+        "1" (prev_row),  // esi

+        "2" (row)        // edi

+      : "%eax", "%edx"                   // clobber list

+#ifndef __PIC__

+      , "%ebx"

+#endif

+      // GRR: INCLUDE "memory" as clobbered? (_dif, _MMXLength)

+      // (seems to work fine without...)

+   );

+   // now do the math for the rest of the row

+   switch (bpp)

+   {

+      case 3:

+      {

+         _ActiveMask.use  = 0x0000000000ffffffLL;

+         _ShiftBpp.use = 24;    // == 3 * 8

+         _ShiftRem.use = 40;    // == 64 - 24

+         __asm__ __volatile__ (

+            // re-init address pointers and offset

+            "movq _ActiveMask, %%mm7      \n\t"

+            "movl _dif, %%ecx             \n\t" // ecx:  x = offset to

+            "movq _LBCarryMask, %%mm5     \n\t" //  alignment boundary

+// preload  "movl row, %%edi              \n\t" // edi:  Avg(x)

+            "movq _HBClearMask, %%mm4     \n\t"

+// preload  "movl prev_row, %%esi         \n\t" // esi:  Prior(x)

+            // prime the pump:  load the first Raw(x-bpp) data set

+            "movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes

+                                                // (correct pos. in loop below)

+         "avg_3lp:                        \n\t"

+            "movq (%%edi,%%ecx,), %%mm0   \n\t" // load mm0 with Avg(x)

+            "movq %%mm5, %%mm3            \n\t"

+            "psrlq _ShiftRem, %%mm2       \n\t" // correct position Raw(x-bpp)

+                                                // data

+            "movq (%%esi,%%ecx,), %%mm1   \n\t" // load mm1 with Prior(x)

+            "movq %%mm7, %%mm6            \n\t"

+            "pand %%mm1, %%mm3            \n\t" // get lsb for each prev_row byte

+            "psrlq $1, %%mm1              \n\t" // divide prev_row bytes by 2

+            "pand  %%mm4, %%mm1           \n\t" // clear invalid bit 7 of each

+                                                // byte

+            "paddb %%mm1, %%mm0           \n\t" // add (Prev_row/2) to Avg for

+                                                // each byte

+            // add 1st active group (Raw(x-bpp)/2) to average with LBCarry

+            "movq %%mm3, %%mm1            \n\t" // now use mm1 for getting

+                                                // LBCarrys

+            "pand %%mm2, %%mm1            \n\t" // get LBCarrys for each byte

+                                                // where both

+                               // lsb's were == 1 (only valid for active group)

+            "psrlq $1, %%mm2              \n\t" // divide raw bytes by 2

+            "pand  %%mm4, %%mm2           \n\t" // clear invalid bit 7 of each

+                                                // byte

+            "paddb %%mm1, %%mm2           \n\t" // add LBCarrys to (Raw(x-bpp)/2)

+                                                // for each byte

+            "pand %%mm6, %%mm2            \n\t" // leave only Active Group 1

+                                                // bytes to add to Avg

+            "paddb %%mm2, %%mm0           \n\t" // add (Raw/2) + LBCarrys to

+                                                // Avg for each Active

+                               //  byte

+            // add 2nd active group (Raw(x-bpp)/2) to average with _LBCarry

+            "psllq _ShiftBpp, %%mm6       \n\t" // shift the mm6 mask to cover

+                                                // bytes 3-5

+            "movq %%mm0, %%mm2            \n\t" // mov updated Raws to mm2

+            "psllq _ShiftBpp, %%mm2       \n\t" // shift data to pos. correctly

+            "movq %%mm3, %%mm1            \n\t" // now use mm1 for getting

+                                                // LBCarrys

+            "pand %%mm2, %%mm1            \n\t" // get LBCarrys for each byte

+                                                // where both

+                               // lsb's were == 1 (only valid for active group)

+            "psrlq $1, %%mm2              \n\t" // divide raw bytes by 2

+            "pand  %%mm4, %%mm2           \n\t" // clear invalid bit 7 of each

+                                                // byte

+            "paddb %%mm1, %%mm2           \n\t" // add LBCarrys to (Raw(x-bpp)/2)

+                                                // for each byte

+            "pand %%mm6, %%mm2            \n\t" // leave only Active Group 2

+                                                // bytes to add to Avg

+            "paddb %%mm2, %%mm0           \n\t" // add (Raw/2) + LBCarrys to

+                                                // Avg for each Active

+                               //  byte

+            // add 3rd active group (Raw(x-bpp)/2) to average with _LBCarry

+            "psllq _ShiftBpp, %%mm6       \n\t" // shift mm6 mask to cover last

+                                                // two

+                                 // bytes

+            "movq %%mm0, %%mm2            \n\t" // mov updated Raws to mm2

+            "psllq _ShiftBpp, %%mm2       \n\t" // shift data to pos. correctly

+                              // Data only needs to be shifted once here to

+                              // get the correct x-bpp offset.

+            "movq %%mm3, %%mm1            \n\t" // now use mm1 for getting

+                                                // LBCarrys

+            "pand %%mm2, %%mm1            \n\t" // get LBCarrys for each byte

+                                                // where both

+                              // lsb's were == 1 (only valid for active group)

+            "psrlq $1, %%mm2              \n\t" // divide raw bytes by 2

+            "pand  %%mm4, %%mm2           \n\t" // clear invalid bit 7 of each

+                                                // byte

+            "paddb %%mm1, %%mm2           \n\t" // add LBCarrys to (Raw(x-bpp)/2)

+                                                // for each byte

+            "pand %%mm6, %%mm2            \n\t" // leave only Active Group 2

+                                                // bytes to add to Avg

+            "addl $8, %%ecx               \n\t"

+            "paddb %%mm2, %%mm0           \n\t" // add (Raw/2) + LBCarrys to

+                                                // Avg for each Active

+                                                // byte

+            // now ready to write back to memory

+            "movq %%mm0, -8(%%edi,%%ecx,) \n\t"

+            // move updated Raw(x) to use as Raw(x-bpp) for next loop

+            "cmpl _MMXLength, %%ecx       \n\t"

+            "movq %%mm0, %%mm2            \n\t" // mov updated Raw(x) to mm2

+            "jb avg_3lp                   \n\t"

+            : "=S" (dummy_value_S),             // output regs (dummy)

+              "=D" (dummy_value_D)

+            : "0" (prev_row),  // esi           // input regs

+              "1" (row)        // edi

+            : "%ecx"                            // clobber list

+#if 0  /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */

+            , "%mm0", "%mm1", "%mm2", "%mm3"

+            , "%mm4", "%mm5", "%mm6", "%mm7"

+#endif

+         );

+      }

+      break;  // end 3 bpp

+      case 6:

+      case 4:

+      //case 7:   // who wrote this?  PNG doesn't support 5 or 7 bytes/pixel

+      //case 5:   // GRR BOGUS

+      {

+         _ActiveMask.use  = 0xffffffffffffffffLL; // use shift below to clear

+                                                  // appropriate inactive bytes

+         _ShiftBpp.use = bpp << 3;

+         _ShiftRem.use = 64 - _ShiftBpp.use;

+         __asm__ __volatile__ (

+            "movq _HBClearMask, %%mm4    \n\t"

+            // re-init address pointers and offset

+            "movl _dif, %%ecx            \n\t" // ecx:  x = offset to

+                                               // alignment boundary

+            // load _ActiveMask and clear all bytes except for 1st active group

+            "movq _ActiveMask, %%mm7     \n\t"

+// preload  "movl row, %%edi             \n\t" // edi:  Avg(x)

+            "psrlq _ShiftRem, %%mm7      \n\t"

+// preload  "movl prev_row, %%esi        \n\t" // esi:  Prior(x)

+            "movq %%mm7, %%mm6           \n\t"

+            "movq _LBCarryMask, %%mm5    \n\t"

+            "psllq _ShiftBpp, %%mm6      \n\t" // create mask for 2nd active

+                                               // group

+            // prime the pump:  load the first Raw(x-bpp) data set

+            "movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes

+                                          // (we correct pos. in loop below)

+         "avg_4lp:                       \n\t"

+            "movq (%%edi,%%ecx,), %%mm0  \n\t"

+            "psrlq _ShiftRem, %%mm2      \n\t" // shift data to pos. correctly

+            "movq (%%esi,%%ecx,), %%mm1  \n\t"

+            // add (Prev_row/2) to average

+            "movq %%mm5, %%mm3           \n\t"

+            "pand %%mm1, %%mm3           \n\t" // get lsb for each prev_row byte

+            "psrlq $1, %%mm1             \n\t" // divide prev_row bytes by 2

+            "pand  %%mm4, %%mm1          \n\t" // clear invalid bit 7 of each

+                                               // byte

+            "paddb %%mm1, %%mm0          \n\t" // add (Prev_row/2) to Avg for

+                                               // each byte

+            // add 1st active group (Raw(x-bpp)/2) to average with _LBCarry

+            "movq %%mm3, %%mm1           \n\t" // now use mm1 for getting

+                                               // LBCarrys

+            "pand %%mm2, %%mm1           \n\t" // get LBCarrys for each byte

+                                               // where both

+                              // lsb's were == 1 (only valid for active group)

+            "psrlq $1, %%mm2             \n\t" // divide raw bytes by 2

+            "pand  %%mm4, %%mm2          \n\t" // clear invalid bit 7 of each

+                                               // byte

+            "paddb %%mm1, %%mm2          \n\t" // add LBCarrys to (Raw(x-bpp)/2)

+                                               // for each byte

+            "pand %%mm7, %%mm2           \n\t" // leave only Active Group 1

+                                               // bytes to add to Avg

+            "paddb %%mm2, %%mm0          \n\t" // add (Raw/2) + LBCarrys to Avg

+                                               // for each Active

+                              // byte

+            // add 2nd active group (Raw(x-bpp)/2) to average with _LBCarry

+            "movq %%mm0, %%mm2           \n\t" // mov updated Raws to mm2

+            "psllq _ShiftBpp, %%mm2      \n\t" // shift data to pos. correctly

+            "addl $8, %%ecx              \n\t"

+            "movq %%mm3, %%mm1           \n\t" // now use mm1 for getting

+                                               // LBCarrys

+            "pand %%mm2, %%mm1           \n\t" // get LBCarrys for each byte

+                                               // where both

+                              // lsb's were == 1 (only valid for active group)

+            "psrlq $1, %%mm2             \n\t" // divide raw bytes by 2

+            "pand  %%mm4, %%mm2          \n\t" // clear invalid bit 7 of each

+                                               // byte

+            "paddb %%mm1, %%mm2          \n\t" // add LBCarrys to (Raw(x-bpp)/2)

+                                               // for each byte

+            "pand %%mm6, %%mm2           \n\t" // leave only Active Group 2

+                                               // bytes to add to Avg

+            "paddb %%mm2, %%mm0          \n\t" // add (Raw/2) + LBCarrys to

+                                               // Avg for each Active

+                              // byte

+            "cmpl _MMXLength, %%ecx      \n\t"

+            // now ready to write back to memory

+            "movq %%mm0, -8(%%edi,%%ecx,) \n\t"

+            // prep Raw(x-bpp) for next loop

+            "movq %%mm0, %%mm2           \n\t" // mov updated Raws to mm2

+            "jb avg_4lp                  \n\t"

+            : "=S" (dummy_value_S),            // output regs (dummy)

+              "=D" (dummy_value_D)

+            : "0" (prev_row),  // esi          // input regs

+              "1" (row)        // edi

+            : "%ecx"                           // clobber list

+#if 0  /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */

+            , "%mm0", "%mm1", "%mm2", "%mm3"

+            , "%mm4", "%mm5", "%mm6", "%mm7"

+#endif

+         );

+      }

+      break;  // end 4,6 bpp

+      case 2:

+      {

+         _ActiveMask.use  = 0x000000000000ffffLL;

+         _ShiftBpp.use = 16;   // == 2 * 8

+         _ShiftRem.use = 48;   // == 64 - 16

+         __asm__ __volatile__ (

+            // load _ActiveMask

+            "movq _ActiveMask, %%mm7     \n\t"

+            // re-init address pointers and offset

+            "movl _dif, %%ecx            \n\t" // ecx:  x = offset to alignment

+                                               // boundary

+            "movq _LBCarryMask, %%mm5    \n\t"

+// preload  "movl row, %%edi             \n\t" // edi:  Avg(x)

+            "movq _HBClearMask, %%mm4    \n\t"

+// preload  "movl prev_row, %%esi        \n\t" // esi:  Prior(x)

+            // prime the pump:  load the first Raw(x-bpp) data set

+            "movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes

+                              // (we correct pos. in loop below)

+         "avg_2lp:                       \n\t"

+            "movq (%%edi,%%ecx,), %%mm0  \n\t"

+            "psrlq _ShiftRem, %%mm2      \n\t" // shift data to pos. correctly

+            "movq (%%esi,%%ecx,), %%mm1  \n\t" //  (GRR BUGFIX:  was psllq)

+            // add (Prev_row/2) to average

+            "movq %%mm5, %%mm3           \n\t"

+            "pand %%mm1, %%mm3           \n\t" // get lsb for each prev_row byte

+            "psrlq $1, %%mm1             \n\t" // divide prev_row bytes by 2

+            "pand  %%mm4, %%mm1          \n\t" // clear invalid bit 7 of each

+                                               // byte

+            "movq %%mm7, %%mm6           \n\t"

+            "paddb %%mm1, %%mm0          \n\t" // add (Prev_row/2) to Avg for

+                                               // each byte

+            // add 1st active group (Raw(x-bpp)/2) to average with _LBCarry

+            "movq %%mm3, %%mm1           \n\t" // now use mm1 for getting

+                                               // LBCarrys

+            "pand %%mm2, %%mm1           \n\t" // get LBCarrys for each byte

+                                               // where both

+                                               // lsb's were == 1 (only valid

+                                               // for active group)

+            "psrlq $1, %%mm2             \n\t" // divide raw bytes by 2

+            "pand  %%mm4, %%mm2          \n\t" // clear invalid bit 7 of each

+                                               // byte

+            "paddb %%mm1, %%mm2          \n\t" // add LBCarrys to (Raw(x-bpp)/2)

+                                               // for each byte

+            "pand %%mm6, %%mm2           \n\t" // leave only Active Group 1

+                                               // bytes to add to Avg

+            "paddb %%mm2, %%mm0          \n\t" // add (Raw/2) + LBCarrys to Avg

+                                               // for each Active byte

+            // add 2nd active group (Raw(x-bpp)/2) to average with _LBCarry

+            "psllq _ShiftBpp, %%mm6      \n\t" // shift the mm6 mask to cover

+                                               // bytes 2 & 3

+            "movq %%mm0, %%mm2           \n\t" // mov updated Raws to mm2

+            "psllq _ShiftBpp, %%mm2      \n\t" // shift data to pos. correctly

+            "movq %%mm3, %%mm1           \n\t" // now use mm1 for getting

+                                               // LBCarrys

+            "pand %%mm2, %%mm1           \n\t" // get LBCarrys for each byte

+                                               // where both

+                                               // lsb's were == 1 (only valid

+                                               // for active group)

+            "psrlq $1, %%mm2             \n\t" // divide raw bytes by 2

+            "pand  %%mm4, %%mm2          \n\t" // clear invalid bit 7 of each

+                                               // byte

+            "paddb %%mm1, %%mm2          \n\t" // add LBCarrys to (Raw(x-bpp)/2)

+                                               // for each byte

+            "pand %%mm6, %%mm2           \n\t" // leave only Active Group 2

+                                               // bytes to add to Avg

+            "paddb %%mm2, %%mm0          \n\t" // add (Raw/2) + LBCarrys to

+                                               // Avg for each Active byte

+            // add 3rd active group (Raw(x-bpp)/2) to average with _LBCarry

+            "psllq _ShiftBpp, %%mm6      \n\t" // shift the mm6 mask to cover

+                                               // bytes 4 & 5

+            "movq %%mm0, %%mm2           \n\t" // mov updated Raws to mm2

+            "psllq _ShiftBpp, %%mm2      \n\t" // shift data to pos. correctly

+            "movq %%mm3, %%mm1           \n\t" // now use mm1 for getting

+                                               // LBCarrys

+            "pand %%mm2, %%mm1           \n\t" // get LBCarrys for each byte

+                                               // where both lsb's were == 1

+                                               // (only valid for active group)

+            "psrlq $1, %%mm2             \n\t" // divide raw bytes by 2

+            "pand  %%mm4, %%mm2          \n\t" // clear invalid bit 7 of each

+                                               // byte

+            "paddb %%mm1, %%mm2          \n\t" // add LBCarrys to (Raw(x-bpp)/2)

+                                               // for each byte

+            "pand %%mm6, %%mm2           \n\t" // leave only Active Group 2

+                                               // bytes to add to Avg

+            "paddb %%mm2, %%mm0          \n\t" // add (Raw/2) + LBCarrys to

+                                               // Avg for each Active byte

+            // add 4th active group (Raw(x-bpp)/2) to average with _LBCarry

+            "psllq _ShiftBpp, %%mm6      \n\t" // shift the mm6 mask to cover

+                                               // bytes 6 & 7

+            "movq %%mm0, %%mm2           \n\t" // mov updated Raws to mm2

+            "psllq _ShiftBpp, %%mm2      \n\t" // shift data to pos. correctly

+            "addl $8, %%ecx              \n\t"

+            "movq %%mm3, %%mm1           \n\t" // now use mm1 for getting

+                                               // LBCarrys

+            "pand %%mm2, %%mm1           \n\t" // get LBCarrys for each byte

+                                               // where both

+                                               // lsb's were == 1 (only valid

+                                               // for active group)

+            "psrlq $1, %%mm2             \n\t" // divide raw bytes by 2

+            "pand  %%mm4, %%mm2          \n\t" // clear invalid bit 7 of each

+                                               // byte

+            "paddb %%mm1, %%mm2          \n\t" // add LBCarrys to (Raw(x-bpp)/2)

+                                               // for each byte

+            "pand %%mm6, %%mm2           \n\t" // leave only Active Group 2

+                                               // bytes to add to Avg

+            "paddb %%mm2, %%mm0          \n\t" // add (Raw/2) + LBCarrys to

+                                               // Avg for each Active byte

+            "cmpl _MMXLength, %%ecx      \n\t"

+            // now ready to write back to memory

+            "movq %%mm0, -8(%%edi,%%ecx,) \n\t"

+            // prep Raw(x-bpp) for next loop

+            "movq %%mm0, %%mm2           \n\t" // mov updated Raws to mm2

+            "jb avg_2lp                  \n\t"

+            : "=S" (dummy_value_S),            // output regs (dummy)

+              "=D" (dummy_value_D)

+            : "0" (prev_row),  // esi          // input regs

+              "1" (row)        // edi

+            : "%ecx"                           // clobber list

+#if 0  /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */

+            , "%mm0", "%mm1", "%mm2", "%mm3"

+            , "%mm4", "%mm5", "%mm6", "%mm7"

+#endif

+         );

+      }

+      break;  // end 2 bpp

+      case 1:

+      {

+         __asm__ __volatile__ (

+            // re-init address pointers and offset

+#ifdef __PIC__

+            "pushl %%ebx                 \n\t" // save Global Offset Table index

+#endif

+            "movl _dif, %%ebx            \n\t" // ebx:  x = offset to alignment

+                                               // boundary

+// preload  "movl row, %%edi             \n\t" // edi:  Avg(x)

+            "cmpl _FullLength, %%ebx     \n\t" // test if offset at end of array

+            "jnb avg_1end                \n\t"

+            // do Paeth decode for remaining bytes

+// preload  "movl prev_row, %%esi        \n\t" // esi:  Prior(x)

+            "movl %%edi, %%edx           \n\t"

+// preload  "subl bpp, %%edx             \n\t" // (bpp is preloaded into ecx)

+            "subl %%ecx, %%edx           \n\t" // edx:  Raw(x-bpp)

+            "xorl %%ecx, %%ecx           \n\t" // zero ecx before using cl & cx

+                                               //  in loop below

+         "avg_1lp:                       \n\t"

+            // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2)

+            "xorl %%eax, %%eax           \n\t"

+            "movb (%%esi,%%ebx,), %%cl   \n\t" // load cl with Prior(x)

+            "movb (%%edx,%%ebx,), %%al   \n\t" // load al with Raw(x-bpp)

+            "addw %%cx, %%ax             \n\t"

+            "incl %%ebx                  \n\t"

+            "shrw %%ax                   \n\t" // divide by 2

+            "addb -1(%%edi,%%ebx,), %%al \n\t" // add Avg(x); -1 to offset

+                                               // inc ebx

+            "cmpl _FullLength, %%ebx     \n\t" // check if at end of array

+            "movb %%al, -1(%%edi,%%ebx,) \n\t" // write back Raw(x);

+                         // mov does not affect flags; -1 to offset inc ebx

+            "jb avg_1lp                  \n\t"

+         "avg_1end:                      \n\t"

+#ifdef __PIC__

+            "popl %%ebx                  \n\t" // Global Offset Table index

+#endif

+            : "=c" (dummy_value_c),            // output regs (dummy)

+              "=S" (dummy_value_S),

+              "=D" (dummy_value_D)

+            : "0" (bpp),       // ecx          // input regs

+              "1" (prev_row),  // esi

+              "2" (row)        // edi

+            : "%eax", "%edx"                   // clobber list

+#ifndef __PIC__

+            , "%ebx"

+#endif

+         );

+      }

+      return;  // end 1 bpp

+      case 8:

+      {

+         __asm__ __volatile__ (

+            // re-init address pointers and offset

+            "movl _dif, %%ecx            \n\t" // ecx:  x == offset to alignment

+            "movq _LBCarryMask, %%mm5    \n\t" //            boundary

+// preload  "movl row, %%edi             \n\t" // edi:  Avg(x)

+            "movq _HBClearMask, %%mm4    \n\t"

+// preload  "movl prev_row, %%esi        \n\t" // esi:  Prior(x)

+            // prime the pump:  load the first Raw(x-bpp) data set

+            "movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes

+                                      // (NO NEED to correct pos. in loop below)

+         "avg_8lp:                       \n\t"

+            "movq (%%edi,%%ecx,), %%mm0  \n\t"

+            "movq %%mm5, %%mm3           \n\t"

+            "movq (%%esi,%%ecx,), %%mm1  \n\t"

+            "addl $8, %%ecx              \n\t"

+            "pand %%mm1, %%mm3           \n\t" // get lsb for each prev_row byte

+            "psrlq $1, %%mm1             \n\t" // divide prev_row bytes by 2

+            "pand %%mm2, %%mm3           \n\t" // get LBCarrys for each byte

+                                               //  where both lsb's were == 1

+            "psrlq $1, %%mm2             \n\t" // divide raw bytes by 2

+            "pand  %%mm4, %%mm1          \n\t" // clear invalid bit 7, each byte

+            "paddb %%mm3, %%mm0          \n\t" // add LBCarrys to Avg, each byte

+            "pand  %%mm4, %%mm2          \n\t" // clear invalid bit 7, each byte

+            "paddb %%mm1, %%mm0          \n\t" // add (Prev_row/2) to Avg, each

+            "paddb %%mm2, %%mm0          \n\t" // add (Raw/2) to Avg for each

+            "cmpl _MMXLength, %%ecx      \n\t"

+            "movq %%mm0, -8(%%edi,%%ecx,) \n\t"

+            "movq %%mm0, %%mm2           \n\t" // reuse as Raw(x-bpp)

+            "jb avg_8lp                  \n\t"

+            : "=S" (dummy_value_S),            // output regs (dummy)

+              "=D" (dummy_value_D)

+            : "0" (prev_row),  // esi          // input regs

+              "1" (row)        // edi

+            : "%ecx"                           // clobber list

+#if 0  /* %mm0, ..., %mm5 not supported by gcc 2.7.2.3 or egcs 1.1 */

+            , "%mm0", "%mm1", "%mm2"

+            , "%mm3", "%mm4", "%mm5"

+#endif

+         );

+      }

+      break;  // end 8 bpp

+      default:                  // bpp greater than 8 (!= 1,2,3,4,[5],6,[7],8)

+      {

+#ifdef PNG_DEBUG

+         // GRR:  PRINT ERROR HERE:  SHOULD NEVER BE REACHED

+        png_debug(1,

+        "Internal logic error in pnggccrd (png_read_filter_row_mmx_avg())\n");

+#endif

+#if 0

+        __asm__ __volatile__ (

+            "movq _LBCarryMask, %%mm5    \n\t"

+            // re-init address pointers and offset

+            "movl _dif, %%ebx            \n\t" // ebx:  x = offset to

+                                               // alignment boundary

+            "movl row, %%edi             \n\t" // edi:  Avg(x)

+            "movq _HBClearMask, %%mm4    \n\t"

+            "movl %%edi, %%edx           \n\t"

+            "movl prev_row, %%esi        \n\t" // esi:  Prior(x)

+            "subl bpp, %%edx             \n\t" // edx:  Raw(x-bpp)

+         "avg_Alp:                       \n\t"

+            "movq (%%edi,%%ebx,), %%mm0  \n\t"

+            "movq %%mm5, %%mm3           \n\t"

+            "movq (%%esi,%%ebx,), %%mm1  \n\t"

+            "pand %%mm1, %%mm3           \n\t" // get lsb for each prev_row byte

+            "movq (%%edx,%%ebx,), %%mm2  \n\t"

+            "psrlq $1, %%mm1             \n\t" // divide prev_row bytes by 2

+            "pand %%mm2, %%mm3           \n\t" // get LBCarrys for each byte

+                                               // where both lsb's were == 1

+            "psrlq $1, %%mm2             \n\t" // divide raw bytes by 2

+            "pand  %%mm4, %%mm1          \n\t" // clear invalid bit 7 of each

+                                               // byte

+            "paddb %%mm3, %%mm0          \n\t" // add LBCarrys to Avg for each

+                                               // byte

+            "pand  %%mm4, %%mm2          \n\t" // clear invalid bit 7 of each

+                                               // byte

+            "paddb %%mm1, %%mm0          \n\t" // add (Prev_row/2) to Avg for

+                                               // each byte

+            "addl $8, %%ebx              \n\t"

+            "paddb %%mm2, %%mm0          \n\t" // add (Raw/2) to Avg for each

+                                               // byte

+            "cmpl _MMXLength, %%ebx      \n\t"

+            "movq %%mm0, -8(%%edi,%%ebx,) \n\t"

+            "jb avg_Alp                  \n\t"

+            : // FIXASM: output regs/vars go here, e.g.:  "=m" (memory_var)

+            : // FIXASM: input regs, e.g.:  "c" (count), "S" (src), "D" (dest)

+            : "%ebx", "%edx", "%edi", "%esi" // CHECKASM: clobber list

+         );

+#endif /* 0 - NEVER REACHED */

+      }

+      break;

+   } // end switch (bpp)

+   __asm__ __volatile__ (

+      // MMX acceleration complete; now do clean-up

+      // check if any remaining bytes left to decode

+#ifdef __PIC__

+      "pushl %%ebx                 \n\t" // save index to Global Offset Table

+#endif

+      "movl _MMXLength, %%ebx      \n\t" // ebx:  x == offset bytes after MMX

+//pre "movl row, %%edi             \n\t" // edi:  Avg(x)

+      "cmpl _FullLength, %%ebx     \n\t" // test if offset at end of array

+      "jnb avg_end                 \n\t"

+      // do Avg decode for remaining bytes

+//pre "movl prev_row, %%esi        \n\t" // esi:  Prior(x)

+      "movl %%edi, %%edx           \n\t"

+//pre "subl bpp, %%edx             \n\t" // (bpp is preloaded into ecx)

+      "subl %%ecx, %%edx           \n\t" // edx:  Raw(x-bpp)

+      "xorl %%ecx, %%ecx           \n\t" // zero ecx before using cl & cx below

+   "avg_lp2:                       \n\t"

+      // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2)

+      "xorl %%eax, %%eax           \n\t"

+      "movb (%%esi,%%ebx,), %%cl   \n\t" // load cl with Prior(x)

+      "movb (%%edx,%%ebx,), %%al   \n\t" // load al with Raw(x-bpp)

+      "addw %%cx, %%ax             \n\t"

+      "incl %%ebx                  \n\t"

+      "shrw %%ax                   \n\t" // divide by 2

+      "addb -1(%%edi,%%ebx,), %%al \n\t" // add Avg(x); -1 to offset inc ebx

+      "cmpl _FullLength, %%ebx     \n\t" // check if at end of array

+      "movb %%al, -1(%%edi,%%ebx,) \n\t" // write back Raw(x) [mov does not

+      "jb avg_lp2                  \n\t" //  affect flags; -1 to offset inc ebx]

+   "avg_end:                       \n\t"

+      "EMMS                        \n\t" // end MMX; prep for poss. FP instrs.

+#ifdef __PIC__

+      "popl %%ebx                  \n\t" // restore index to Global Offset Table

+#endif

+      : "=c" (dummy_value_c),            // output regs (dummy)

+        "=S" (dummy_value_S),

+        "=D" (dummy_value_D)

+      : "0" (bpp),       // ecx          // input regs

+        "1" (prev_row),  // esi

+        "2" (row)        // edi

+      : "%eax", "%edx"                   // clobber list

+#ifndef __PIC__

+      , "%ebx"

+#endif

+   );

+} /* end png_read_filter_row_mmx_avg() */

+#endif

+#ifdef PNG_THREAD_UNSAFE_OK

+//===========================================================================//

+//                                                                           //

+//         P N G _ R E A D _ F I L T E R _ R O W _ M M X _ P A E T H         //

+//                                                                           //

+//===========================================================================//

+// Optimized code for PNG Paeth filter decoder

+static void /* PRIVATE */

+png_read_filter_row_mmx_paeth(png_row_infop row_info, png_bytep row,

+                              png_bytep prev_row)

+{

+   int bpp;

+   int dummy_value_c;   // fix 'forbidden register 2 (cx) was spilled' error

+   int dummy_value_S;

+   int dummy_value_D;

+   bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel

+   _FullLength  = row_info->rowbytes; // # of bytes to filter

+   __asm__ __volatile__ (

+#ifdef __PIC__

+      "pushl %%ebx                 \n\t" // save index to Global Offset Table

+#endif

+      "xorl %%ebx, %%ebx           \n\t" // ebx:  x offset

+//pre "movl row, %%edi             \n\t"

+      "xorl %%edx, %%edx           \n\t" // edx:  x-bpp offset

+//pre "movl prev_row, %%esi        \n\t"

+      "xorl %%eax, %%eax           \n\t"

+      // Compute the Raw value for the first bpp bytes

+      // Note: the formula works out to be always

+      //   Paeth(x) = Raw(x) + Prior(x)      where x < bpp

+   "paeth_rlp:                     \n\t"

+      "movb (%%edi,%%ebx,), %%al   \n\t"

+      "addb (%%esi,%%ebx,), %%al   \n\t"

+      "incl %%ebx                  \n\t"

+//pre "cmpl bpp, %%ebx             \n\t" (bpp is preloaded into ecx)

+      "cmpl %%ecx, %%ebx           \n\t"

+      "movb %%al, -1(%%edi,%%ebx,) \n\t"

+      "jb paeth_rlp                \n\t"

+      // get # of bytes to alignment

+      "movl %%edi, _dif            \n\t" // take start of row

+      "addl %%ebx, _dif            \n\t" // add bpp

+      "xorl %%ecx, %%ecx           \n\t"

+      "addl $0xf, _dif             \n\t" // add 7 + 8 to incr past alignment

+                                         // boundary

+      "andl $0xfffffff8, _dif      \n\t" // mask to alignment boundary

+      "subl %%edi, _dif            \n\t" // subtract from start ==> value ebx

+                                         // at alignment

+      "jz paeth_go                 \n\t"

+      // fix alignment

+   "paeth_lp1:                     \n\t"

+      "xorl %%eax, %%eax           \n\t"

+      // pav = p - a = (a + b - c) - a = b - c

+      "movb (%%esi,%%ebx,), %%al   \n\t" // load Prior(x) into al

+      "movb (%%esi,%%edx,), %%cl   \n\t" // load Prior(x-bpp) into cl

+      "subl %%ecx, %%eax           \n\t" // subtract Prior(x-bpp)

+      "movl %%eax, _patemp         \n\t" // Save pav for later use

+      "xorl %%eax, %%eax           \n\t"

+      // pbv = p - b = (a + b - c) - b = a - c

+      "movb (%%edi,%%edx,), %%al   \n\t" // load Raw(x-bpp) into al

+      "subl %%ecx, %%eax           \n\t" // subtract Prior(x-bpp)

+      "movl %%eax, %%ecx           \n\t"

+      // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+      "addl _patemp, %%eax         \n\t" // pcv = pav + pbv

+      // pc = abs(pcv)

+      "testl $0x80000000, %%eax    \n\t"

+      "jz paeth_pca                \n\t"

+      "negl %%eax                  \n\t" // reverse sign of neg values

+   "paeth_pca:                     \n\t"

+      "movl %%eax, _pctemp         \n\t" // save pc for later use

+      // pb = abs(pbv)

+      "testl $0x80000000, %%ecx    \n\t"

+      "jz paeth_pba                \n\t"

+      "negl %%ecx                  \n\t" // reverse sign of neg values

+   "paeth_pba:                     \n\t"

+      "movl %%ecx, _pbtemp         \n\t" // save pb for later use

+      // pa = abs(pav)

+      "movl _patemp, %%eax         \n\t"

+      "testl $0x80000000, %%eax    \n\t"

+      "jz paeth_paa                \n\t"

+      "negl %%eax                  \n\t" // reverse sign of neg values

+   "paeth_paa:                     \n\t"

+      "movl %%eax, _patemp         \n\t" // save pa for later use

+      // test if pa <= pb

+      "cmpl %%ecx, %%eax           \n\t"

+      "jna paeth_abb               \n\t"

+      // pa > pb; now test if pb <= pc

+      "cmpl _pctemp, %%ecx         \n\t"

+      "jna paeth_bbc               \n\t"

+      // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp)

+      "movb (%%esi,%%edx,), %%cl   \n\t" // load Prior(x-bpp) into cl

+      "jmp paeth_paeth             \n\t"

+   "paeth_bbc:                     \n\t"

+      // pb <= pc; Raw(x) = Paeth(x) + Prior(x)

+      "movb (%%esi,%%ebx,), %%cl   \n\t" // load Prior(x) into cl

+      "jmp paeth_paeth             \n\t"

+   "paeth_abb:                     \n\t"

+      // pa <= pb; now test if pa <= pc

+      "cmpl _pctemp, %%eax         \n\t"

+      "jna paeth_abc               \n\t"

+      // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp)

+      "movb (%%esi,%%edx,), %%cl   \n\t" // load Prior(x-bpp) into cl

+      "jmp paeth_paeth             \n\t"

+   "paeth_abc:                     \n\t"

+      // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp)

+      "movb (%%edi,%%edx,), %%cl   \n\t" // load Raw(x-bpp) into cl

+   "paeth_paeth:                   \n\t"

+      "incl %%ebx                  \n\t"

+      "incl %%edx                  \n\t"

+      // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256

+      "addb %%cl, -1(%%edi,%%ebx,) \n\t"

+      "cmpl _dif, %%ebx            \n\t"

+      "jb paeth_lp1                \n\t"

+   "paeth_go:                      \n\t"

+      "movl _FullLength, %%ecx     \n\t"

+      "movl %%ecx, %%eax           \n\t"

+      "subl %%ebx, %%eax           \n\t" // subtract alignment fix

+      "andl $0x00000007, %%eax     \n\t" // calc bytes over mult of 8

+      "subl %%eax, %%ecx           \n\t" // drop over bytes from original length

+      "movl %%ecx, _MMXLength      \n\t"

+#ifdef __PIC__

+      "popl %%ebx                  \n\t" // restore index to Global Offset Table

+#endif

+      : "=c" (dummy_value_c),            // output regs (dummy)

+        "=S" (dummy_value_S),

+        "=D" (dummy_value_D)

+      : "0" (bpp),       // ecx          // input regs

+        "1" (prev_row),  // esi

+        "2" (row)        // edi

+      : "%eax", "%edx"                   // clobber list

+#ifndef __PIC__

+      , "%ebx"

+#endif

+   );

+   // now do the math for the rest of the row

+   switch (bpp)

+   {

+      case 3:

+      {

+         _ActiveMask.use = 0x0000000000ffffffLL;

+         _ActiveMaskEnd.use = 0xffff000000000000LL;

+         _ShiftBpp.use = 24;    // == bpp(3) * 8

+         _ShiftRem.use = 40;    // == 64 - 24

+         __asm__ __volatile__ (

+            "movl _dif, %%ecx            \n\t"

+// preload  "movl row, %%edi             \n\t"

+// preload  "movl prev_row, %%esi        \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            // prime the pump:  load the first Raw(x-bpp) data set

+            "movq -8(%%edi,%%ecx,), %%mm1 \n\t"

+         "paeth_3lp:                     \n\t"

+            "psrlq _ShiftRem, %%mm1      \n\t" // shift last 3 bytes to 1st

+                                               // 3 bytes

+            "movq (%%esi,%%ecx,), %%mm2  \n\t" // load b=Prior(x)

+            "punpcklbw %%mm0, %%mm1      \n\t" // unpack High bytes of a

+            "movq -8(%%esi,%%ecx,), %%mm3 \n\t" // prep c=Prior(x-bpp) bytes

+            "punpcklbw %%mm0, %%mm2      \n\t" // unpack High bytes of b

+            "psrlq _ShiftRem, %%mm3      \n\t" // shift last 3 bytes to 1st

+                                               // 3 bytes

+            // pav = p - a = (a + b - c) - a = b - c

+            "movq %%mm2, %%mm4           \n\t"

+            "punpcklbw %%mm0, %%mm3      \n\t" // unpack High bytes of c

+            // pbv = p - b = (a + b - c) - b = a - c

+            "movq %%mm1, %%mm5           \n\t"

+            "psubw %%mm3, %%mm4          \n\t"

+            "pxor %%mm7, %%mm7           \n\t"

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+            "movq %%mm4, %%mm6           \n\t"

+            "psubw %%mm3, %%mm5          \n\t"

+            // pa = abs(p-a) = abs(pav)

+            // pb = abs(p-b) = abs(pbv)

+            // pc = abs(p-c) = abs(pcv)

+            "pcmpgtw %%mm4, %%mm0        \n\t" // create mask pav bytes < 0

+            "paddw %%mm5, %%mm6          \n\t"

+            "pand %%mm4, %%mm0           \n\t" // only pav bytes < 0 in mm7

+            "pcmpgtw %%mm5, %%mm7        \n\t" // create mask pbv bytes < 0

+            "psubw %%mm0, %%mm4          \n\t"

+            "pand %%mm5, %%mm7           \n\t" // only pbv bytes < 0 in mm0

+            "psubw %%mm0, %%mm4          \n\t"

+            "psubw %%mm7, %%mm5          \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            "pcmpgtw %%mm6, %%mm0        \n\t" // create mask pcv bytes < 0

+            "pand %%mm6, %%mm0           \n\t" // only pav bytes < 0 in mm7

+            "psubw %%mm7, %%mm5          \n\t"

+            "psubw %%mm0, %%mm6          \n\t"

+            //  test pa <= pb

+            "movq %%mm4, %%mm7           \n\t"

+            "psubw %%mm0, %%mm6          \n\t"

+            "pcmpgtw %%mm5, %%mm7        \n\t" // pa > pb?

+            "movq %%mm7, %%mm0           \n\t"

+            // use mm7 mask to merge pa & pb

+            "pand %%mm7, %%mm5           \n\t"

+            // use mm0 mask copy to merge a & b

+            "pand %%mm0, %%mm2           \n\t"

+            "pandn %%mm4, %%mm7          \n\t"

+            "pandn %%mm1, %%mm0          \n\t"

+            "paddw %%mm5, %%mm7          \n\t"

+            "paddw %%mm2, %%mm0          \n\t"

+            //  test  ((pa <= pb)? pa:pb) <= pc

+            "pcmpgtw %%mm6, %%mm7        \n\t" // pab > pc?

+            "pxor %%mm1, %%mm1           \n\t"

+            "pand %%mm7, %%mm3           \n\t"

+            "pandn %%mm0, %%mm7          \n\t"

+            "paddw %%mm3, %%mm7          \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            "packuswb %%mm1, %%mm7       \n\t"

+            "movq (%%esi,%%ecx,), %%mm3  \n\t" // load c=Prior(x-bpp)

+            "pand _ActiveMask, %%mm7     \n\t"

+            "movq %%mm3, %%mm2           \n\t" // load b=Prior(x) step 1

+            "paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x)

+            "punpcklbw %%mm0, %%mm3      \n\t" // unpack High bytes of c

+            "movq %%mm7, (%%edi,%%ecx,)  \n\t" // write back updated value

+            "movq %%mm7, %%mm1           \n\t" // now mm1 will be used as

+                                               // Raw(x-bpp)

+            // now do Paeth for 2nd set of bytes (3-5)

+            "psrlq _ShiftBpp, %%mm2      \n\t" // load b=Prior(x) step 2

+            "punpcklbw %%mm0, %%mm1      \n\t" // unpack High bytes of a

+            "pxor %%mm7, %%mm7           \n\t"

+            "punpcklbw %%mm0, %%mm2      \n\t" // unpack High bytes of b

+            // pbv = p - b = (a + b - c) - b = a - c

+            "movq %%mm1, %%mm5           \n\t"

+            // pav = p - a = (a + b - c) - a = b - c

+            "movq %%mm2, %%mm4           \n\t"

+            "psubw %%mm3, %%mm5          \n\t"

+            "psubw %%mm3, %%mm4          \n\t"

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) =

+            //       pav + pbv = pbv + pav

+            "movq %%mm5, %%mm6           \n\t"

+            "paddw %%mm4, %%mm6          \n\t"

+            // pa = abs(p-a) = abs(pav)

+            // pb = abs(p-b) = abs(pbv)

+            // pc = abs(p-c) = abs(pcv)

+            "pcmpgtw %%mm5, %%mm0        \n\t" // create mask pbv bytes < 0

+            "pcmpgtw %%mm4, %%mm7        \n\t" // create mask pav bytes < 0

+            "pand %%mm5, %%mm0           \n\t" // only pbv bytes < 0 in mm0

+            "pand %%mm4, %%mm7           \n\t" // only pav bytes < 0 in mm7

+            "psubw %%mm0, %%mm5          \n\t"

+            "psubw %%mm7, %%mm4          \n\t"

+            "psubw %%mm0, %%mm5          \n\t"

+            "psubw %%mm7, %%mm4          \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            "pcmpgtw %%mm6, %%mm0        \n\t" // create mask pcv bytes < 0

+            "pand %%mm6, %%mm0           \n\t" // only pav bytes < 0 in mm7

+            "psubw %%mm0, %%mm6          \n\t"

+            //  test pa <= pb

+            "movq %%mm4, %%mm7           \n\t"

+            "psubw %%mm0, %%mm6          \n\t"

+            "pcmpgtw %%mm5, %%mm7        \n\t" // pa > pb?

+            "movq %%mm7, %%mm0           \n\t"

+            // use mm7 mask to merge pa & pb

+            "pand %%mm7, %%mm5           \n\t"

+            // use mm0 mask copy to merge a & b

+            "pand %%mm0, %%mm2           \n\t"

+            "pandn %%mm4, %%mm7          \n\t"

+            "pandn %%mm1, %%mm0          \n\t"

+            "paddw %%mm5, %%mm7          \n\t"

+            "paddw %%mm2, %%mm0          \n\t"

+            //  test  ((pa <= pb)? pa:pb) <= pc

+            "pcmpgtw %%mm6, %%mm7        \n\t" // pab > pc?

+            "movq (%%esi,%%ecx,), %%mm2  \n\t" // load b=Prior(x)

+            "pand %%mm7, %%mm3           \n\t"

+            "pandn %%mm0, %%mm7          \n\t"

+            "pxor %%mm1, %%mm1           \n\t"

+            "paddw %%mm3, %%mm7          \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            "packuswb %%mm1, %%mm7       \n\t"

+            "movq %%mm2, %%mm3           \n\t" // load c=Prior(x-bpp) step 1

+            "pand _ActiveMask, %%mm7     \n\t"

+            "punpckhbw %%mm0, %%mm2      \n\t" // unpack High bytes of b

+            "psllq _ShiftBpp, %%mm7      \n\t" // shift bytes to 2nd group of

+                                               // 3 bytes

+             // pav = p - a = (a + b - c) - a = b - c

+            "movq %%mm2, %%mm4           \n\t"

+            "paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x)

+            "psllq _ShiftBpp, %%mm3      \n\t" // load c=Prior(x-bpp) step 2

+            "movq %%mm7, (%%edi,%%ecx,)  \n\t" // write back updated value

+            "movq %%mm7, %%mm1           \n\t"

+            "punpckhbw %%mm0, %%mm3      \n\t" // unpack High bytes of c

+            "psllq _ShiftBpp, %%mm1      \n\t" // shift bytes

+                                    // now mm1 will be used as Raw(x-bpp)

+            // now do Paeth for 3rd, and final, set of bytes (6-7)

+            "pxor %%mm7, %%mm7           \n\t"

+            "punpckhbw %%mm0, %%mm1      \n\t" // unpack High bytes of a

+            "psubw %%mm3, %%mm4          \n\t"

+            // pbv = p - b = (a + b - c) - b = a - c

+            "movq %%mm1, %%mm5           \n\t"

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+            "movq %%mm4, %%mm6           \n\t"

+            "psubw %%mm3, %%mm5          \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            "paddw %%mm5, %%mm6          \n\t"

+            // pa = abs(p-a) = abs(pav)

+            // pb = abs(p-b) = abs(pbv)

+            // pc = abs(p-c) = abs(pcv)

+            "pcmpgtw %%mm4, %%mm0        \n\t" // create mask pav bytes < 0

+            "pcmpgtw %%mm5, %%mm7        \n\t" // create mask pbv bytes < 0

+            "pand %%mm4, %%mm0           \n\t" // only pav bytes < 0 in mm7

+            "pand %%mm5, %%mm7           \n\t" // only pbv bytes < 0 in mm0

+            "psubw %%mm0, %%mm4          \n\t"

+            "psubw %%mm7, %%mm5          \n\t"

+            "psubw %%mm0, %%mm4          \n\t"

+            "psubw %%mm7, %%mm5          \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            "pcmpgtw %%mm6, %%mm0        \n\t" // create mask pcv bytes < 0

+            "pand %%mm6, %%mm0           \n\t" // only pav bytes < 0 in mm7

+            "psubw %%mm0, %%mm6          \n\t"

+            //  test pa <= pb

+            "movq %%mm4, %%mm7           \n\t"

+            "psubw %%mm0, %%mm6          \n\t"

+            "pcmpgtw %%mm5, %%mm7        \n\t" // pa > pb?

+            "movq %%mm7, %%mm0           \n\t"

+            // use mm0 mask copy to merge a & b

+            "pand %%mm0, %%mm2           \n\t"

+            // use mm7 mask to merge pa & pb

+            "pand %%mm7, %%mm5           \n\t"

+            "pandn %%mm1, %%mm0          \n\t"

+            "pandn %%mm4, %%mm7          \n\t"

+            "paddw %%mm2, %%mm0          \n\t"

+            "paddw %%mm5, %%mm7          \n\t"

+            //  test  ((pa <= pb)? pa:pb) <= pc

+            "pcmpgtw %%mm6, %%mm7        \n\t" // pab > pc?

+            "pand %%mm7, %%mm3           \n\t"

+            "pandn %%mm0, %%mm7          \n\t"

+            "paddw %%mm3, %%mm7          \n\t"

+            "pxor %%mm1, %%mm1           \n\t"

+            "packuswb %%mm7, %%mm1       \n\t"

+            // step ecx to next set of 8 bytes and repeat loop til done

+            "addl $8, %%ecx              \n\t"

+            "pand _ActiveMaskEnd, %%mm1  \n\t"

+            "paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add Paeth predictor with

+                                                 // Raw(x)

+            "cmpl _MMXLength, %%ecx      \n\t"

+            "pxor %%mm0, %%mm0           \n\t" // pxor does not affect flags

+            "movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value

+                                 // mm1 will be used as Raw(x-bpp) next loop

+                           // mm3 ready to be used as Prior(x-bpp) next loop

+            "jb paeth_3lp                \n\t"

+            : "=S" (dummy_value_S),             // output regs (dummy)

+              "=D" (dummy_value_D)

+            : "0" (prev_row),  // esi           // input regs

+              "1" (row)        // edi

+            : "%ecx"                            // clobber list

+#if 0  /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */

+            , "%mm0", "%mm1", "%mm2", "%mm3"

+            , "%mm4", "%mm5", "%mm6", "%mm7"

+#endif

+         );

+      }

+      break;  // end 3 bpp

+      case 6:

+      //case 7:   // GRR BOGUS

+      //case 5:   // GRR BOGUS

+      {

+         _ActiveMask.use  = 0x00000000ffffffffLL;

+         _ActiveMask2.use = 0xffffffff00000000LL;

+         _ShiftBpp.use = bpp << 3;    // == bpp * 8

+         _ShiftRem.use = 64 - _ShiftBpp.use;

+         __asm__ __volatile__ (

+            "movl _dif, %%ecx            \n\t"

+// preload  "movl row, %%edi             \n\t"

+// preload  "movl prev_row, %%esi        \n\t"

+            // prime the pump:  load the first Raw(x-bpp) data set

+            "movq -8(%%edi,%%ecx,), %%mm1 \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+         "paeth_6lp:                     \n\t"

+            // must shift to position Raw(x-bpp) data

+            "psrlq _ShiftRem, %%mm1      \n\t"

+            // do first set of 4 bytes

+            "movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes

+            "punpcklbw %%mm0, %%mm1      \n\t" // unpack Low bytes of a

+            "movq (%%esi,%%ecx,), %%mm2  \n\t" // load b=Prior(x)

+            "punpcklbw %%mm0, %%mm2      \n\t" // unpack Low bytes of b

+            // must shift to position Prior(x-bpp) data

+            "psrlq _ShiftRem, %%mm3      \n\t"

+            // pav = p - a = (a + b - c) - a = b - c

+            "movq %%mm2, %%mm4           \n\t"

+            "punpcklbw %%mm0, %%mm3      \n\t" // unpack Low bytes of c

+            // pbv = p - b = (a + b - c) - b = a - c

+            "movq %%mm1, %%mm5           \n\t"

+            "psubw %%mm3, %%mm4          \n\t"

+            "pxor %%mm7, %%mm7           \n\t"

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+            "movq %%mm4, %%mm6           \n\t"

+            "psubw %%mm3, %%mm5          \n\t"

+            // pa = abs(p-a) = abs(pav)

+            // pb = abs(p-b) = abs(pbv)

+            // pc = abs(p-c) = abs(pcv)

+            "pcmpgtw %%mm4, %%mm0        \n\t" // create mask pav bytes < 0

+            "paddw %%mm5, %%mm6          \n\t"

+            "pand %%mm4, %%mm0           \n\t" // only pav bytes < 0 in mm7

+            "pcmpgtw %%mm5, %%mm7        \n\t" // create mask pbv bytes < 0

+            "psubw %%mm0, %%mm4          \n\t"

+            "pand %%mm5, %%mm7           \n\t" // only pbv bytes < 0 in mm0

+            "psubw %%mm0, %%mm4          \n\t"

+            "psubw %%mm7, %%mm5          \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            "pcmpgtw %%mm6, %%mm0        \n\t" // create mask pcv bytes < 0

+            "pand %%mm6, %%mm0           \n\t" // only pav bytes < 0 in mm7

+            "psubw %%mm7, %%mm5          \n\t"

+            "psubw %%mm0, %%mm6          \n\t"

+            //  test pa <= pb

+            "movq %%mm4, %%mm7           \n\t"

+            "psubw %%mm0, %%mm6          \n\t"

+            "pcmpgtw %%mm5, %%mm7        \n\t" // pa > pb?

+            "movq %%mm7, %%mm0           \n\t"

+            // use mm7 mask to merge pa & pb

+            "pand %%mm7, %%mm5           \n\t"

+            // use mm0 mask copy to merge a & b

+            "pand %%mm0, %%mm2           \n\t"

+            "pandn %%mm4, %%mm7          \n\t"

+            "pandn %%mm1, %%mm0          \n\t"

+            "paddw %%mm5, %%mm7          \n\t"

+            "paddw %%mm2, %%mm0          \n\t"

+            //  test  ((pa <= pb)? pa:pb) <= pc

+            "pcmpgtw %%mm6, %%mm7        \n\t" // pab > pc?

+            "pxor %%mm1, %%mm1           \n\t"

+            "pand %%mm7, %%mm3           \n\t"

+            "pandn %%mm0, %%mm7          \n\t"

+            "paddw %%mm3, %%mm7          \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            "packuswb %%mm1, %%mm7       \n\t"

+            "movq -8(%%esi,%%ecx,), %%mm3 \n\t" // load c=Prior(x-bpp)

+            "pand _ActiveMask, %%mm7     \n\t"

+            "psrlq _ShiftRem, %%mm3      \n\t"

+            "movq (%%esi,%%ecx,), %%mm2  \n\t" // load b=Prior(x) step 1

+            "paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor and Raw(x)

+            "movq %%mm2, %%mm6           \n\t"

+            "movq %%mm7, (%%edi,%%ecx,)  \n\t" // write back updated value

+            "movq -8(%%edi,%%ecx,), %%mm1 \n\t"

+            "psllq _ShiftBpp, %%mm6      \n\t"

+            "movq %%mm7, %%mm5           \n\t"

+            "psrlq _ShiftRem, %%mm1      \n\t"

+            "por %%mm6, %%mm3            \n\t"

+            "psllq _ShiftBpp, %%mm5      \n\t"

+            "punpckhbw %%mm0, %%mm3      \n\t" // unpack High bytes of c

+            "por %%mm5, %%mm1            \n\t"

+            // do second set of 4 bytes

+            "punpckhbw %%mm0, %%mm2      \n\t" // unpack High bytes of b

+            "punpckhbw %%mm0, %%mm1      \n\t" // unpack High bytes of a

+            // pav = p - a = (a + b - c) - a = b - c

+            "movq %%mm2, %%mm4           \n\t"

+            // pbv = p - b = (a + b - c) - b = a - c

+            "movq %%mm1, %%mm5           \n\t"

+            "psubw %%mm3, %%mm4          \n\t"

+            "pxor %%mm7, %%mm7           \n\t"

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+            "movq %%mm4, %%mm6           \n\t"

+            "psubw %%mm3, %%mm5          \n\t"

+            // pa = abs(p-a) = abs(pav)

+            // pb = abs(p-b) = abs(pbv)

+            // pc = abs(p-c) = abs(pcv)

+            "pcmpgtw %%mm4, %%mm0        \n\t" // create mask pav bytes < 0

+            "paddw %%mm5, %%mm6          \n\t"

+            "pand %%mm4, %%mm0           \n\t" // only pav bytes < 0 in mm7

+            "pcmpgtw %%mm5, %%mm7        \n\t" // create mask pbv bytes < 0

+            "psubw %%mm0, %%mm4          \n\t"

+            "pand %%mm5, %%mm7           \n\t" // only pbv bytes < 0 in mm0

+            "psubw %%mm0, %%mm4          \n\t"

+            "psubw %%mm7, %%mm5          \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            "pcmpgtw %%mm6, %%mm0        \n\t" // create mask pcv bytes < 0

+            "pand %%mm6, %%mm0           \n\t" // only pav bytes < 0 in mm7

+            "psubw %%mm7, %%mm5          \n\t"

+            "psubw %%mm0, %%mm6          \n\t"

+            //  test pa <= pb

+            "movq %%mm4, %%mm7           \n\t"

+            "psubw %%mm0, %%mm6          \n\t"

+            "pcmpgtw %%mm5, %%mm7        \n\t" // pa > pb?

+            "movq %%mm7, %%mm0           \n\t"

+            // use mm7 mask to merge pa & pb

+            "pand %%mm7, %%mm5           \n\t"

+            // use mm0 mask copy to merge a & b

+            "pand %%mm0, %%mm2           \n\t"

+            "pandn %%mm4, %%mm7          \n\t"

+            "pandn %%mm1, %%mm0          \n\t"

+            "paddw %%mm5, %%mm7          \n\t"

+            "paddw %%mm2, %%mm0          \n\t"

+            //  test  ((pa <= pb)? pa:pb) <= pc

+            "pcmpgtw %%mm6, %%mm7        \n\t" // pab > pc?

+            "pxor %%mm1, %%mm1           \n\t"

+            "pand %%mm7, %%mm3           \n\t"

+            "pandn %%mm0, %%mm7          \n\t"

+            "pxor %%mm1, %%mm1           \n\t"

+            "paddw %%mm3, %%mm7          \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            // step ecx to next set of 8 bytes and repeat loop til done

+            "addl $8, %%ecx              \n\t"

+            "packuswb %%mm7, %%mm1       \n\t"

+            "paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add Paeth predictor with Raw(x)

+            "cmpl _MMXLength, %%ecx      \n\t"

+            "movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value

+                                // mm1 will be used as Raw(x-bpp) next loop

+            "jb paeth_6lp                \n\t"

+            : "=S" (dummy_value_S),             // output regs (dummy)

+              "=D" (dummy_value_D)

+            : "0" (prev_row),  // esi           // input regs

+              "1" (row)        // edi

+            : "%ecx"                            // clobber list

+#if 0  /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */

+            , "%mm0", "%mm1", "%mm2", "%mm3"

+            , "%mm4", "%mm5", "%mm6", "%mm7"

+#endif

+         );

+      }

+      break;  // end 6 bpp

+      case 4:

+      {

+         _ActiveMask.use  = 0x00000000ffffffffLL;

+         __asm__ __volatile__ (

+            "movl _dif, %%ecx            \n\t"

+// preload  "movl row, %%edi             \n\t"

+// preload  "movl prev_row, %%esi        \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            // prime the pump:  load the first Raw(x-bpp) data set

+            "movq -8(%%edi,%%ecx,), %%mm1 \n\t" // only time should need to read

+                                     //  a=Raw(x-bpp) bytes

+         "paeth_4lp:                     \n\t"

+            // do first set of 4 bytes

+            "movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes

+            "punpckhbw %%mm0, %%mm1      \n\t" // unpack Low bytes of a

+            "movq (%%esi,%%ecx,), %%mm2  \n\t" // load b=Prior(x)

+            "punpcklbw %%mm0, %%mm2      \n\t" // unpack High bytes of b

+            // pav = p - a = (a + b - c) - a = b - c

+            "movq %%mm2, %%mm4           \n\t"

+            "punpckhbw %%mm0, %%mm3      \n\t" // unpack High bytes of c

+            // pbv = p - b = (a + b - c) - b = a - c

+            "movq %%mm1, %%mm5           \n\t"

+            "psubw %%mm3, %%mm4          \n\t"

+            "pxor %%mm7, %%mm7           \n\t"

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+            "movq %%mm4, %%mm6           \n\t"

+            "psubw %%mm3, %%mm5          \n\t"

+            // pa = abs(p-a) = abs(pav)

+            // pb = abs(p-b) = abs(pbv)

+            // pc = abs(p-c) = abs(pcv)

+            "pcmpgtw %%mm4, %%mm0        \n\t" // create mask pav bytes < 0

+            "paddw %%mm5, %%mm6          \n\t"

+            "pand %%mm4, %%mm0           \n\t" // only pav bytes < 0 in mm7

+            "pcmpgtw %%mm5, %%mm7        \n\t" // create mask pbv bytes < 0

+            "psubw %%mm0, %%mm4          \n\t"

+            "pand %%mm5, %%mm7           \n\t" // only pbv bytes < 0 in mm0

+            "psubw %%mm0, %%mm4          \n\t"

+            "psubw %%mm7, %%mm5          \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            "pcmpgtw %%mm6, %%mm0        \n\t" // create mask pcv bytes < 0

+            "pand %%mm6, %%mm0           \n\t" // only pav bytes < 0 in mm7

+            "psubw %%mm7, %%mm5          \n\t"

+            "psubw %%mm0, %%mm6          \n\t"

+            //  test pa <= pb

+            "movq %%mm4, %%mm7           \n\t"

+            "psubw %%mm0, %%mm6          \n\t"

+            "pcmpgtw %%mm5, %%mm7        \n\t" // pa > pb?

+            "movq %%mm7, %%mm0           \n\t"

+            // use mm7 mask to merge pa & pb

+            "pand %%mm7, %%mm5           \n\t"

+            // use mm0 mask copy to merge a & b

+            "pand %%mm0, %%mm2           \n\t"

+            "pandn %%mm4, %%mm7          \n\t"

+            "pandn %%mm1, %%mm0          \n\t"

+            "paddw %%mm5, %%mm7          \n\t"

+            "paddw %%mm2, %%mm0          \n\t"

+            //  test  ((pa <= pb)? pa:pb) <= pc

+            "pcmpgtw %%mm6, %%mm7        \n\t" // pab > pc?

+            "pxor %%mm1, %%mm1           \n\t"

+            "pand %%mm7, %%mm3           \n\t"

+            "pandn %%mm0, %%mm7          \n\t"

+            "paddw %%mm3, %%mm7          \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            "packuswb %%mm1, %%mm7       \n\t"

+            "movq (%%esi,%%ecx,), %%mm3  \n\t" // load c=Prior(x-bpp)

+            "pand _ActiveMask, %%mm7     \n\t"

+            "movq %%mm3, %%mm2           \n\t" // load b=Prior(x) step 1

+            "paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x)

+            "punpcklbw %%mm0, %%mm3      \n\t" // unpack High bytes of c

+            "movq %%mm7, (%%edi,%%ecx,)  \n\t" // write back updated value

+            "movq %%mm7, %%mm1           \n\t" // now mm1 will be used as Raw(x-bpp)

+            // do second set of 4 bytes

+            "punpckhbw %%mm0, %%mm2      \n\t" // unpack Low bytes of b

+            "punpcklbw %%mm0, %%mm1      \n\t" // unpack Low bytes of a

+            // pav = p - a = (a + b - c) - a = b - c

+            "movq %%mm2, %%mm4           \n\t"

+            // pbv = p - b = (a + b - c) - b = a - c

+            "movq %%mm1, %%mm5           \n\t"

+            "psubw %%mm3, %%mm4          \n\t"

+            "pxor %%mm7, %%mm7           \n\t"

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+            "movq %%mm4, %%mm6           \n\t"

+            "psubw %%mm3, %%mm5          \n\t"

+            // pa = abs(p-a) = abs(pav)

+            // pb = abs(p-b) = abs(pbv)

+            // pc = abs(p-c) = abs(pcv)

+            "pcmpgtw %%mm4, %%mm0        \n\t" // create mask pav bytes < 0

+            "paddw %%mm5, %%mm6          \n\t"

+            "pand %%mm4, %%mm0           \n\t" // only pav bytes < 0 in mm7

+            "pcmpgtw %%mm5, %%mm7        \n\t" // create mask pbv bytes < 0

+            "psubw %%mm0, %%mm4          \n\t"

+            "pand %%mm5, %%mm7           \n\t" // only pbv bytes < 0 in mm0

+            "psubw %%mm0, %%mm4          \n\t"

+            "psubw %%mm7, %%mm5          \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            "pcmpgtw %%mm6, %%mm0        \n\t" // create mask pcv bytes < 0

+            "pand %%mm6, %%mm0           \n\t" // only pav bytes < 0 in mm7

+            "psubw %%mm7, %%mm5          \n\t"

+            "psubw %%mm0, %%mm6          \n\t"

+            //  test pa <= pb

+            "movq %%mm4, %%mm7           \n\t"

+            "psubw %%mm0, %%mm6          \n\t"

+            "pcmpgtw %%mm5, %%mm7        \n\t" // pa > pb?

+            "movq %%mm7, %%mm0           \n\t"

+            // use mm7 mask to merge pa & pb

+            "pand %%mm7, %%mm5           \n\t"

+            // use mm0 mask copy to merge a & b

+            "pand %%mm0, %%mm2           \n\t"

+            "pandn %%mm4, %%mm7          \n\t"

+            "pandn %%mm1, %%mm0          \n\t"

+            "paddw %%mm5, %%mm7          \n\t"

+            "paddw %%mm2, %%mm0          \n\t"

+            //  test  ((pa <= pb)? pa:pb) <= pc

+            "pcmpgtw %%mm6, %%mm7        \n\t" // pab > pc?

+            "pxor %%mm1, %%mm1           \n\t"

+            "pand %%mm7, %%mm3           \n\t"

+            "pandn %%mm0, %%mm7          \n\t"

+            "pxor %%mm1, %%mm1           \n\t"

+            "paddw %%mm3, %%mm7          \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            // step ecx to next set of 8 bytes and repeat loop til done

+            "addl $8, %%ecx              \n\t"

+            "packuswb %%mm7, %%mm1       \n\t"

+            "paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add predictor with Raw(x)

+            "cmpl _MMXLength, %%ecx      \n\t"

+            "movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value

+                                // mm1 will be used as Raw(x-bpp) next loop

+            "jb paeth_4lp                \n\t"

+            : "=S" (dummy_value_S),             // output regs (dummy)

+              "=D" (dummy_value_D)

+            : "0" (prev_row),  // esi           // input regs

+              "1" (row)        // edi

+            : "%ecx"                            // clobber list

+#if 0  /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */

+            , "%mm0", "%mm1", "%mm2", "%mm3"

+            , "%mm4", "%mm5", "%mm6", "%mm7"

+#endif

+         );

+      }

+      break;  // end 4 bpp

+      case 8:                          // bpp == 8

+      {

+         _ActiveMask.use  = 0x00000000ffffffffLL;

+         __asm__ __volatile__ (

+            "movl _dif, %%ecx            \n\t"

+// preload  "movl row, %%edi             \n\t"

+// preload  "movl prev_row, %%esi        \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            // prime the pump:  load the first Raw(x-bpp) data set

+            "movq -8(%%edi,%%ecx,), %%mm1 \n\t" // only time should need to read

+                                       //  a=Raw(x-bpp) bytes

+         "paeth_8lp:                     \n\t"

+            // do first set of 4 bytes

+            "movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes

+            "punpcklbw %%mm0, %%mm1      \n\t" // unpack Low bytes of a

+            "movq (%%esi,%%ecx,), %%mm2  \n\t" // load b=Prior(x)

+            "punpcklbw %%mm0, %%mm2      \n\t" // unpack Low bytes of b

+            // pav = p - a = (a + b - c) - a = b - c

+            "movq %%mm2, %%mm4           \n\t"

+            "punpcklbw %%mm0, %%mm3      \n\t" // unpack Low bytes of c

+            // pbv = p - b = (a + b - c) - b = a - c

+            "movq %%mm1, %%mm5           \n\t"

+            "psubw %%mm3, %%mm4          \n\t"

+            "pxor %%mm7, %%mm7           \n\t"

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+            "movq %%mm4, %%mm6           \n\t"

+            "psubw %%mm3, %%mm5          \n\t"

+            // pa = abs(p-a) = abs(pav)

+            // pb = abs(p-b) = abs(pbv)

+            // pc = abs(p-c) = abs(pcv)

+            "pcmpgtw %%mm4, %%mm0        \n\t" // create mask pav bytes < 0

+            "paddw %%mm5, %%mm6          \n\t"

+            "pand %%mm4, %%mm0           \n\t" // only pav bytes < 0 in mm7

+            "pcmpgtw %%mm5, %%mm7        \n\t" // create mask pbv bytes < 0

+            "psubw %%mm0, %%mm4          \n\t"

+            "pand %%mm5, %%mm7           \n\t" // only pbv bytes < 0 in mm0

+            "psubw %%mm0, %%mm4          \n\t"

+            "psubw %%mm7, %%mm5          \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            "pcmpgtw %%mm6, %%mm0        \n\t" // create mask pcv bytes < 0

+            "pand %%mm6, %%mm0           \n\t" // only pav bytes < 0 in mm7

+            "psubw %%mm7, %%mm5          \n\t"

+            "psubw %%mm0, %%mm6          \n\t"

+            //  test pa <= pb

+            "movq %%mm4, %%mm7           \n\t"

+            "psubw %%mm0, %%mm6          \n\t"

+            "pcmpgtw %%mm5, %%mm7        \n\t" // pa > pb?

+            "movq %%mm7, %%mm0           \n\t"

+            // use mm7 mask to merge pa & pb

+            "pand %%mm7, %%mm5           \n\t"

+            // use mm0 mask copy to merge a & b

+            "pand %%mm0, %%mm2           \n\t"

+            "pandn %%mm4, %%mm7          \n\t"

+            "pandn %%mm1, %%mm0          \n\t"

+            "paddw %%mm5, %%mm7          \n\t"

+            "paddw %%mm2, %%mm0          \n\t"

+            //  test  ((pa <= pb)? pa:pb) <= pc

+            "pcmpgtw %%mm6, %%mm7        \n\t" // pab > pc?

+            "pxor %%mm1, %%mm1           \n\t"

+            "pand %%mm7, %%mm3           \n\t"

+            "pandn %%mm0, %%mm7          \n\t"

+            "paddw %%mm3, %%mm7          \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            "packuswb %%mm1, %%mm7       \n\t"

+            "movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes

+            "pand _ActiveMask, %%mm7     \n\t"

+            "movq (%%esi,%%ecx,), %%mm2  \n\t" // load b=Prior(x)

+            "paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x)

+            "punpckhbw %%mm0, %%mm3      \n\t" // unpack High bytes of c

+            "movq %%mm7, (%%edi,%%ecx,)  \n\t" // write back updated value

+            "movq -8(%%edi,%%ecx,), %%mm1 \n\t" // read a=Raw(x-bpp) bytes

+            // do second set of 4 bytes

+            "punpckhbw %%mm0, %%mm2      \n\t" // unpack High bytes of b

+            "punpckhbw %%mm0, %%mm1      \n\t" // unpack High bytes of a

+            // pav = p - a = (a + b - c) - a = b - c

+            "movq %%mm2, %%mm4           \n\t"

+            // pbv = p - b = (a + b - c) - b = a - c

+            "movq %%mm1, %%mm5           \n\t"

+            "psubw %%mm3, %%mm4          \n\t"

+            "pxor %%mm7, %%mm7           \n\t"

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+            "movq %%mm4, %%mm6           \n\t"

+            "psubw %%mm3, %%mm5          \n\t"

+            // pa = abs(p-a) = abs(pav)

+            // pb = abs(p-b) = abs(pbv)

+            // pc = abs(p-c) = abs(pcv)

+            "pcmpgtw %%mm4, %%mm0        \n\t" // create mask pav bytes < 0

+            "paddw %%mm5, %%mm6          \n\t"

+            "pand %%mm4, %%mm0           \n\t" // only pav bytes < 0 in mm7

+            "pcmpgtw %%mm5, %%mm7        \n\t" // create mask pbv bytes < 0

+            "psubw %%mm0, %%mm4          \n\t"

+            "pand %%mm5, %%mm7           \n\t" // only pbv bytes < 0 in mm0

+            "psubw %%mm0, %%mm4          \n\t"

+            "psubw %%mm7, %%mm5          \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            "pcmpgtw %%mm6, %%mm0        \n\t" // create mask pcv bytes < 0

+            "pand %%mm6, %%mm0           \n\t" // only pav bytes < 0 in mm7

+            "psubw %%mm7, %%mm5          \n\t"

+            "psubw %%mm0, %%mm6          \n\t"

+            //  test pa <= pb

+            "movq %%mm4, %%mm7           \n\t"

+            "psubw %%mm0, %%mm6          \n\t"

+            "pcmpgtw %%mm5, %%mm7        \n\t" // pa > pb?

+            "movq %%mm7, %%mm0           \n\t"

+            // use mm7 mask to merge pa & pb

+            "pand %%mm7, %%mm5           \n\t"

+            // use mm0 mask copy to merge a & b

+            "pand %%mm0, %%mm2           \n\t"

+            "pandn %%mm4, %%mm7          \n\t"

+            "pandn %%mm1, %%mm0          \n\t"

+            "paddw %%mm5, %%mm7          \n\t"

+            "paddw %%mm2, %%mm0          \n\t"

+            //  test  ((pa <= pb)? pa:pb) <= pc

+            "pcmpgtw %%mm6, %%mm7        \n\t" // pab > pc?

+            "pxor %%mm1, %%mm1           \n\t"

+            "pand %%mm7, %%mm3           \n\t"

+            "pandn %%mm0, %%mm7          \n\t"

+            "pxor %%mm1, %%mm1           \n\t"

+            "paddw %%mm3, %%mm7          \n\t"

+            "pxor %%mm0, %%mm0           \n\t"

+            // step ecx to next set of 8 bytes and repeat loop til done

+            "addl $8, %%ecx              \n\t"

+            "packuswb %%mm7, %%mm1       \n\t"

+            "paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add Paeth predictor with Raw(x)

+            "cmpl _MMXLength, %%ecx      \n\t"

+            "movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value

+                            // mm1 will be used as Raw(x-bpp) next loop

+            "jb paeth_8lp                \n\t"

+            : "=S" (dummy_value_S),             // output regs (dummy)

+              "=D" (dummy_value_D)

+            : "0" (prev_row),  // esi           // input regs

+              "1" (row)        // edi

+            : "%ecx"                            // clobber list

+#if 0  /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */

+            , "%mm0", "%mm1", "%mm2", "%mm3"

+            , "%mm4", "%mm5", "%mm6", "%mm7"

+#endif

+         );

+      }

+      break;  // end 8 bpp

+      case 1:                // bpp = 1

+      case 2:                // bpp = 2

+      default:               // bpp > 8

+      {

+         __asm__ __volatile__ (

+#ifdef __PIC__

+            "pushl %%ebx                 \n\t" // save Global Offset Table index

+#endif

+            "movl _dif, %%ebx            \n\t"

+            "cmpl _FullLength, %%ebx     \n\t"

+            "jnb paeth_dend              \n\t"

+// preload  "movl row, %%edi             \n\t"

+// preload  "movl prev_row, %%esi        \n\t"

+            // do Paeth decode for remaining bytes

+            "movl %%ebx, %%edx           \n\t"

+// preload  "subl bpp, %%edx             \n\t" // (bpp is preloaded into ecx)

+            "subl %%ecx, %%edx           \n\t" // edx = ebx - bpp

+            "xorl %%ecx, %%ecx           \n\t" // zero ecx before using cl & cx

+         "paeth_dlp:                     \n\t"

+            "xorl %%eax, %%eax           \n\t"

+            // pav = p - a = (a + b - c) - a = b - c

+            "movb (%%esi,%%ebx,), %%al   \n\t" // load Prior(x) into al

+            "movb (%%esi,%%edx,), %%cl   \n\t" // load Prior(x-bpp) into cl

+            "subl %%ecx, %%eax           \n\t" // subtract Prior(x-bpp)

+            "movl %%eax, _patemp         \n\t" // Save pav for later use

+            "xorl %%eax, %%eax           \n\t"

+            // pbv = p - b = (a + b - c) - b = a - c

+            "movb (%%edi,%%edx,), %%al   \n\t" // load Raw(x-bpp) into al

+            "subl %%ecx, %%eax           \n\t" // subtract Prior(x-bpp)

+            "movl %%eax, %%ecx           \n\t"

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+            "addl _patemp, %%eax         \n\t" // pcv = pav + pbv

+            // pc = abs(pcv)

+            "testl $0x80000000, %%eax    \n\t"

+            "jz paeth_dpca               \n\t"

+            "negl %%eax                  \n\t" // reverse sign of neg values

+         "paeth_dpca:                    \n\t"

+            "movl %%eax, _pctemp         \n\t" // save pc for later use

+            // pb = abs(pbv)

+            "testl $0x80000000, %%ecx    \n\t"

+            "jz paeth_dpba               \n\t"

+            "negl %%ecx                  \n\t" // reverse sign of neg values

+         "paeth_dpba:                    \n\t"

+            "movl %%ecx, _pbtemp         \n\t" // save pb for later use

+            // pa = abs(pav)

+            "movl _patemp, %%eax         \n\t"

+            "testl $0x80000000, %%eax    \n\t"

+            "jz paeth_dpaa               \n\t"

+            "negl %%eax                  \n\t" // reverse sign of neg values

+         "paeth_dpaa:                    \n\t"

+            "movl %%eax, _patemp         \n\t" // save pa for later use

+            // test if pa <= pb

+            "cmpl %%ecx, %%eax           \n\t"

+            "jna paeth_dabb              \n\t"

+            // pa > pb; now test if pb <= pc

+            "cmpl _pctemp, %%ecx         \n\t"

+            "jna paeth_dbbc              \n\t"

+            // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp)

+            "movb (%%esi,%%edx,), %%cl   \n\t" // load Prior(x-bpp) into cl

+            "jmp paeth_dpaeth            \n\t"

+         "paeth_dbbc:                    \n\t"

+            // pb <= pc; Raw(x) = Paeth(x) + Prior(x)

+            "movb (%%esi,%%ebx,), %%cl   \n\t" // load Prior(x) into cl

+            "jmp paeth_dpaeth            \n\t"

+         "paeth_dabb:                    \n\t"

+            // pa <= pb; now test if pa <= pc

+            "cmpl _pctemp, %%eax         \n\t"

+            "jna paeth_dabc              \n\t"

+            // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp)

+            "movb (%%esi,%%edx,), %%cl   \n\t" // load Prior(x-bpp) into cl

+            "jmp paeth_dpaeth            \n\t"

+         "paeth_dabc:                    \n\t"

+            // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp)

+            "movb (%%edi,%%edx,), %%cl   \n\t" // load Raw(x-bpp) into cl

+         "paeth_dpaeth:                  \n\t"

+            "incl %%ebx                  \n\t"

+            "incl %%edx                  \n\t"

+            // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256

+            "addb %%cl, -1(%%edi,%%ebx,) \n\t"

+            "cmpl _FullLength, %%ebx     \n\t"

+            "jb paeth_dlp                \n\t"

+         "paeth_dend:                    \n\t"

+#ifdef __PIC__

+            "popl %%ebx                  \n\t" // index to Global Offset Table

+#endif

+            : "=c" (dummy_value_c),            // output regs (dummy)

+              "=S" (dummy_value_S),

+              "=D" (dummy_value_D)

+            : "0" (bpp),       // ecx          // input regs

+              "1" (prev_row),  // esi

+              "2" (row)        // edi

+            : "%eax", "%edx"                   // clobber list

+#ifndef __PIC__

+            , "%ebx"

+#endif

+         );

+      }

+      return;                   // No need to go further with this one

+   } // end switch (bpp)

+   __asm__ __volatile__ (

+      // MMX acceleration complete; now do clean-up

+      // check if any remaining bytes left to decode

+#ifdef __PIC__

+      "pushl %%ebx                 \n\t" // save index to Global Offset Table

+#endif

+      "movl _MMXLength, %%ebx      \n\t"

+      "cmpl _FullLength, %%ebx     \n\t"

+      "jnb paeth_end               \n\t"

+//pre "movl row, %%edi             \n\t"

+//pre "movl prev_row, %%esi        \n\t"

+      // do Paeth decode for remaining bytes

+      "movl %%ebx, %%edx           \n\t"

+//pre "subl bpp, %%edx             \n\t" // (bpp is preloaded into ecx)

+      "subl %%ecx, %%edx           \n\t" // edx = ebx - bpp

+      "xorl %%ecx, %%ecx           \n\t" // zero ecx before using cl & cx below

+   "paeth_lp2:                     \n\t"

+      "xorl %%eax, %%eax           \n\t"

+      // pav = p - a = (a + b - c) - a = b - c

+      "movb (%%esi,%%ebx,), %%al   \n\t" // load Prior(x) into al

+      "movb (%%esi,%%edx,), %%cl   \n\t" // load Prior(x-bpp) into cl

+      "subl %%ecx, %%eax           \n\t" // subtract Prior(x-bpp)

+      "movl %%eax, _patemp         \n\t" // Save pav for later use

+      "xorl %%eax, %%eax           \n\t"

+      // pbv = p - b = (a + b - c) - b = a - c

+      "movb (%%edi,%%edx,), %%al   \n\t" // load Raw(x-bpp) into al

+      "subl %%ecx, %%eax           \n\t" // subtract Prior(x-bpp)

+      "movl %%eax, %%ecx           \n\t"

+      // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+      "addl _patemp, %%eax         \n\t" // pcv = pav + pbv

+      // pc = abs(pcv)

+      "testl $0x80000000, %%eax    \n\t"

+      "jz paeth_pca2               \n\t"

+      "negl %%eax                  \n\t" // reverse sign of neg values

+   "paeth_pca2:                    \n\t"

+      "movl %%eax, _pctemp         \n\t" // save pc for later use

+      // pb = abs(pbv)

+      "testl $0x80000000, %%ecx    \n\t"

+      "jz paeth_pba2               \n\t"

+      "negl %%ecx                  \n\t" // reverse sign of neg values

+   "paeth_pba2:                    \n\t"

+      "movl %%ecx, _pbtemp         \n\t" // save pb for later use

+      // pa = abs(pav)

+      "movl _patemp, %%eax         \n\t"

+      "testl $0x80000000, %%eax    \n\t"

+      "jz paeth_paa2               \n\t"

+      "negl %%eax                  \n\t" // reverse sign of neg values

+   "paeth_paa2:                    \n\t"

+      "movl %%eax, _patemp         \n\t" // save pa for later use

+      // test if pa <= pb

+      "cmpl %%ecx, %%eax           \n\t"

+      "jna paeth_abb2              \n\t"

+      // pa > pb; now test if pb <= pc

+      "cmpl _pctemp, %%ecx         \n\t"

+      "jna paeth_bbc2              \n\t"

+      // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp)

+      "movb (%%esi,%%edx,), %%cl   \n\t" // load Prior(x-bpp) into cl

+      "jmp paeth_paeth2            \n\t"

+   "paeth_bbc2:                    \n\t"

+      // pb <= pc; Raw(x) = Paeth(x) + Prior(x)

+      "movb (%%esi,%%ebx,), %%cl   \n\t" // load Prior(x) into cl

+      "jmp paeth_paeth2            \n\t"

+   "paeth_abb2:                    \n\t"

+      // pa <= pb; now test if pa <= pc

+      "cmpl _pctemp, %%eax         \n\t"

+      "jna paeth_abc2              \n\t"

+      // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp)

+      "movb (%%esi,%%edx,), %%cl   \n\t" // load Prior(x-bpp) into cl

+      "jmp paeth_paeth2            \n\t"

+   "paeth_abc2:                    \n\t"

+      // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp)

+      "movb (%%edi,%%edx,), %%cl   \n\t" // load Raw(x-bpp) into cl

+   "paeth_paeth2:                  \n\t"

+      "incl %%ebx                  \n\t"

+      "incl %%edx                  \n\t"

+      // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256

+      "addb %%cl, -1(%%edi,%%ebx,) \n\t"

+      "cmpl _FullLength, %%ebx     \n\t"

+      "jb paeth_lp2                \n\t"

+   "paeth_end:                     \n\t"

+      "EMMS                        \n\t" // end MMX; prep for poss. FP instrs.

+#ifdef __PIC__

+      "popl %%ebx                  \n\t" // restore index to Global Offset Table

+#endif

+      : "=c" (dummy_value_c),            // output regs (dummy)

+        "=S" (dummy_value_S),

+        "=D" (dummy_value_D)

+      : "0" (bpp),       // ecx          // input regs

+        "1" (prev_row),  // esi

+        "2" (row)        // edi

+      : "%eax", "%edx"                   // clobber list (no input regs!)

+#ifndef __PIC__

+      , "%ebx"

+#endif

+   );

+} /* end png_read_filter_row_mmx_paeth() */

+#endif

+#ifdef PNG_THREAD_UNSAFE_OK

+//===========================================================================//

+//                                                                           //

+//           P N G _ R E A D _ F I L T E R _ R O W _ M M X _ S U B           //

+//                                                                           //

+//===========================================================================//

+// Optimized code for PNG Sub filter decoder

+static void /* PRIVATE */

+png_read_filter_row_mmx_sub(png_row_infop row_info, png_bytep row)

+{

+   int bpp;

+   int dummy_value_a;

+   int dummy_value_D;

+   bpp = (row_info->pixel_depth + 7) >> 3;   // calc number of bytes per pixel

+   _FullLength = row_info->rowbytes - bpp;   // number of bytes to filter

+   __asm__ __volatile__ (

+//pre "movl row, %%edi             \n\t"

+      "movl %%edi, %%esi           \n\t" // lp = row

+//pre "movl bpp, %%eax             \n\t"

+      "addl %%eax, %%edi           \n\t" // rp = row + bpp

+//irr "xorl %%eax, %%eax           \n\t"

+      // get # of bytes to alignment

+      "movl %%edi, _dif            \n\t" // take start of row

+      "addl $0xf, _dif             \n\t" // add 7 + 8 to incr past

+                                         //  alignment boundary

+      "xorl %%ecx, %%ecx           \n\t"

+      "andl $0xfffffff8, _dif      \n\t" // mask to alignment boundary

+      "subl %%edi, _dif            \n\t" // subtract from start ==> value

+      "jz sub_go                   \n\t" //  ecx at alignment

+   "sub_lp1:                       \n\t" // fix alignment

+      "movb (%%esi,%%ecx,), %%al   \n\t"

+      "addb %%al, (%%edi,%%ecx,)   \n\t"

+      "incl %%ecx                  \n\t"

+      "cmpl _dif, %%ecx            \n\t"

+      "jb sub_lp1                  \n\t"

+   "sub_go:                        \n\t"

+      "movl _FullLength, %%eax     \n\t"

+      "movl %%eax, %%edx           \n\t"

+      "subl %%ecx, %%edx           \n\t" // subtract alignment fix

+      "andl $0x00000007, %%edx     \n\t" // calc bytes over mult of 8

+      "subl %%edx, %%eax           \n\t" // drop over bytes from length

+      "movl %%eax, _MMXLength      \n\t"

+      : "=a" (dummy_value_a),   // 0      // output regs (dummy)

+        "=D" (dummy_value_D)    // 1

+      : "0" (bpp),              // eax    // input regs

+        "1" (row)               // edi

+      : "%esi", "%ecx", "%edx"            // clobber list

+#if 0  /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */

+      , "%mm0", "%mm1", "%mm2", "%mm3"

+      , "%mm4", "%mm5", "%mm6", "%mm7"

+#endif

+   );

+   // now do the math for the rest of the row

+   switch (bpp)

+   {

+      case 3:

+      {

+         _ActiveMask.use  = 0x0000ffffff000000LL;

+         _ShiftBpp.use = 24;       // == 3 * 8

+         _ShiftRem.use  = 40;      // == 64 - 24

+         __asm__ __volatile__ (

+// preload  "movl row, %%edi              \n\t"

+            "movq _ActiveMask, %%mm7       \n\t" // load _ActiveMask for 2nd

+                                                //  active byte group

+            "movl %%edi, %%esi            \n\t" // lp = row

+// preload  "movl bpp, %%eax              \n\t"

+            "addl %%eax, %%edi            \n\t" // rp = row + bpp

+            "movq %%mm7, %%mm6            \n\t"

+            "movl _dif, %%edx             \n\t"

+            "psllq _ShiftBpp, %%mm6       \n\t" // move mask in mm6 to cover

+                                                //  3rd active byte group

+            // prime the pump:  load the first Raw(x-bpp) data set

+            "movq -8(%%edi,%%edx,), %%mm1 \n\t"

+         "sub_3lp:                        \n\t" // shift data for adding first

+            "psrlq _ShiftRem, %%mm1       \n\t" //  bpp bytes (no need for mask;

+                                                //  shift clears inactive bytes)

+            // add 1st active group

+            "movq (%%edi,%%edx,), %%mm0   \n\t"

+            "paddb %%mm1, %%mm0           \n\t"

+            // add 2nd active group

+            "movq %%mm0, %%mm1            \n\t" // mov updated Raws to mm1

+            "psllq _ShiftBpp, %%mm1       \n\t" // shift data to pos. correctly

+            "pand %%mm7, %%mm1            \n\t" // mask to use 2nd active group

+            "paddb %%mm1, %%mm0           \n\t"

+            // add 3rd active group

+            "movq %%mm0, %%mm1            \n\t" // mov updated Raws to mm1

+            "psllq _ShiftBpp, %%mm1       \n\t" // shift data to pos. correctly

+            "pand %%mm6, %%mm1            \n\t" // mask to use 3rd active group

+            "addl $8, %%edx               \n\t"

+            "paddb %%mm1, %%mm0           \n\t"

+            "cmpl _MMXLength, %%edx       \n\t"

+            "movq %%mm0, -8(%%edi,%%edx,) \n\t" // write updated Raws to array

+            "movq %%mm0, %%mm1            \n\t" // prep 1st add at top of loop

+            "jb sub_3lp                   \n\t"

+            : "=a" (dummy_value_a),   // 0      // output regs (dummy)

+              "=D" (dummy_value_D)    // 1

+            : "0" (bpp),              // eax    // input regs

+              "1" (row)               // edi

+            : "%edx", "%esi"                    // clobber list

+#if 0  /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */

+            , "%mm0", "%mm1", "%mm6", "%mm7"

+#endif

+         );

+      }

+      break;

+      case 1:

+      {

+         __asm__ __volatile__ (

+            "movl _dif, %%edx            \n\t"

+// preload  "movl row, %%edi             \n\t"

+            "cmpl _FullLength, %%edx     \n\t"

+            "jnb sub_1end                \n\t"

+            "movl %%edi, %%esi           \n\t" // lp = row

+            "xorl %%eax, %%eax           \n\t"

+// preload  "movl bpp, %%eax             \n\t"

+            "addl %%eax, %%edi           \n\t" // rp = row + bpp

+         "sub_1lp:                       \n\t"

+            "movb (%%esi,%%edx,), %%al   \n\t"

+            "addb %%al, (%%edi,%%edx,)   \n\t"

+            "incl %%edx                  \n\t"

+            "cmpl _FullLength, %%edx     \n\t"

+            "jb sub_1lp                  \n\t"

+         "sub_1end:                      \n\t"

+            : "=a" (dummy_value_a),   // 0      // output regs (dummy)

+              "=D" (dummy_value_D)    // 1

+            : "0" (bpp),              // eax    // input regs

+              "1" (row)               // edi

+            : "%edx", "%esi"                    // clobber list

+         );

+      }

+      return;

+      case 6:

+      case 4:

+      //case 7:   // GRR BOGUS

+      //case 5:   // GRR BOGUS

+      {

+         _ShiftBpp.use = bpp << 3;

+         _ShiftRem.use = 64 - _ShiftBpp.use;

+         __asm__ __volatile__ (

+// preload  "movl row, %%edi              \n\t"

+            "movl _dif, %%edx             \n\t"

+            "movl %%edi, %%esi            \n\t" // lp = row

+// preload  "movl bpp, %%eax              \n\t"

+            "addl %%eax, %%edi            \n\t" // rp = row + bpp

+            // prime the pump:  load the first Raw(x-bpp) data set

+            "movq -8(%%edi,%%edx,), %%mm1 \n\t"

+         "sub_4lp:                        \n\t" // shift data for adding first

+            "psrlq _ShiftRem, %%mm1       \n\t" //  bpp bytes (no need for mask;

+                                                //  shift clears inactive bytes)

+            "movq (%%edi,%%edx,), %%mm0   \n\t"

+            "paddb %%mm1, %%mm0           \n\t"

+            // add 2nd active group

+            "movq %%mm0, %%mm1            \n\t" // mov updated Raws to mm1

+            "psllq _ShiftBpp, %%mm1       \n\t" // shift data to pos. correctly

+            "addl $8, %%edx               \n\t"

+            "paddb %%mm1, %%mm0           \n\t"

+            "cmpl _MMXLength, %%edx       \n\t"

+            "movq %%mm0, -8(%%edi,%%edx,) \n\t"

+            "movq %%mm0, %%mm1            \n\t" // prep 1st add at top of loop

+            "jb sub_4lp                   \n\t"

+            : "=a" (dummy_value_a),   // 0      // output regs (dummy)

+              "=D" (dummy_value_D)    // 1

+            : "0" (bpp),              // eax    // input regs

+              "1" (row)               // edi

+            : "%edx", "%esi"                    // clobber list

+#if 0  /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */

+            , "%mm0", "%mm1"

+#endif

+         );

+      }

+      break;

+      case 2:

+      {

+         _ActiveMask.use = 0x00000000ffff0000LL;

+         _ShiftBpp.use = 16;       // == 2 * 8

+         _ShiftRem.use = 48;       // == 64 - 16

+         __asm__ __volatile__ (

+            "movq _ActiveMask, %%mm7      \n\t" // load _ActiveMask for 2nd

+                                                //  active byte group

+            "movl _dif, %%edx             \n\t"

+            "movq %%mm7, %%mm6            \n\t"

+// preload  "movl row, %%edi              \n\t"

+            "psllq _ShiftBpp, %%mm6       \n\t" // move mask in mm6 to cover

+                                                //  3rd active byte group

+            "movl %%edi, %%esi            \n\t" // lp = row

+            "movq %%mm6, %%mm5            \n\t"

+// preload  "movl bpp, %%eax              \n\t"

+            "addl %%eax, %%edi            \n\t" // rp = row + bpp

+            "psllq _ShiftBpp, %%mm5       \n\t" // move mask in mm5 to cover

+                                                //  4th active byte group

+            // prime the pump:  load the first Raw(x-bpp) data set

+            "movq -8(%%edi,%%edx,), %%mm1 \n\t"

+         "sub_2lp:                        \n\t" // shift data for adding first

+            "psrlq _ShiftRem, %%mm1       \n\t" //  bpp bytes (no need for mask;

+                                                //  shift clears inactive bytes)

+            // add 1st active group

+            "movq (%%edi,%%edx,), %%mm0   \n\t"

+            "paddb %%mm1, %%mm0           \n\t"

+            // add 2nd active group

+            "movq %%mm0, %%mm1            \n\t" // mov updated Raws to mm1

+            "psllq _ShiftBpp, %%mm1       \n\t" // shift data to pos. correctly

+            "pand %%mm7, %%mm1            \n\t" // mask to use 2nd active group

+            "paddb %%mm1, %%mm0           \n\t"

+            // add 3rd active group

+            "movq %%mm0, %%mm1            \n\t" // mov updated Raws to mm1

+            "psllq _ShiftBpp, %%mm1       \n\t" // shift data to pos. correctly

+            "pand %%mm6, %%mm1            \n\t" // mask to use 3rd active group

+            "paddb %%mm1, %%mm0           \n\t"

+            // add 4th active group

+            "movq %%mm0, %%mm1            \n\t" // mov updated Raws to mm1

+            "psllq _ShiftBpp, %%mm1       \n\t" // shift data to pos. correctly

+            "pand %%mm5, %%mm1            \n\t" // mask to use 4th active group

+            "addl $8, %%edx               \n\t"

+            "paddb %%mm1, %%mm0           \n\t"

+            "cmpl _MMXLength, %%edx       \n\t"

+            "movq %%mm0, -8(%%edi,%%edx,) \n\t" // write updated Raws to array

+            "movq %%mm0, %%mm1            \n\t" // prep 1st add at top of loop

+            "jb sub_2lp                   \n\t"

+            : "=a" (dummy_value_a),   // 0      // output regs (dummy)

+              "=D" (dummy_value_D)    // 1

+            : "0" (bpp),              // eax    // input regs

+              "1" (row)               // edi

+            : "%edx", "%esi"                    // clobber list

+#if 0  /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */

+            , "%mm0", "%mm1", "%mm5", "%mm6", "%mm7"

+#endif

+         );

+      }

+      break;

+      case 8:

+      {

+         __asm__ __volatile__ (

+// preload  "movl row, %%edi              \n\t"

+            "movl _dif, %%edx             \n\t"

+            "movl %%edi, %%esi            \n\t" // lp = row

+// preload  "movl bpp, %%eax              \n\t"

+            "addl %%eax, %%edi            \n\t" // rp = row + bpp

+            "movl _MMXLength, %%ecx       \n\t"

+            // prime the pump:  load the first Raw(x-bpp) data set

+            "movq -8(%%edi,%%edx,), %%mm7 \n\t"

+            "andl $0x0000003f, %%ecx      \n\t" // calc bytes over mult of 64

+         "sub_8lp:                        \n\t"

+            "movq (%%edi,%%edx,), %%mm0   \n\t" // load Sub(x) for 1st 8 bytes

+            "paddb %%mm7, %%mm0           \n\t"

+            "movq 8(%%edi,%%edx,), %%mm1  \n\t" // load Sub(x) for 2nd 8 bytes

+            "movq %%mm0, (%%edi,%%edx,)   \n\t" // write Raw(x) for 1st 8 bytes

+            // Now mm0 will be used as Raw(x-bpp) for the 2nd group of 8 bytes.

+            // This will be repeated for each group of 8 bytes with the 8th

+            // group being used as the Raw(x-bpp) for the 1st group of the

+            // next loop.

+            "paddb %%mm0, %%mm1           \n\t"

+            "movq 16(%%edi,%%edx,), %%mm2 \n\t" // load Sub(x) for 3rd 8 bytes

+            "movq %%mm1, 8(%%edi,%%edx,)  \n\t" // write Raw(x) for 2nd 8 bytes

+            "paddb %%mm1, %%mm2           \n\t"

+            "movq 24(%%edi,%%edx,), %%mm3 \n\t" // load Sub(x) for 4th 8 bytes

+            "movq %%mm2, 16(%%edi,%%edx,) \n\t" // write Raw(x) for 3rd 8 bytes

+            "paddb %%mm2, %%mm3           \n\t"

+            "movq 32(%%edi,%%edx,), %%mm4 \n\t" // load Sub(x) for 5th 8 bytes

+            "movq %%mm3, 24(%%edi,%%edx,) \n\t" // write Raw(x) for 4th 8 bytes

+            "paddb %%mm3, %%mm4           \n\t"

+            "movq 40(%%edi,%%edx,), %%mm5 \n\t" // load Sub(x) for 6th 8 bytes

+            "movq %%mm4, 32(%%edi,%%edx,) \n\t" // write Raw(x) for 5th 8 bytes

+            "paddb %%mm4, %%mm5           \n\t"

+            "movq 48(%%edi,%%edx,), %%mm6 \n\t" // load Sub(x) for 7th 8 bytes

+            "movq %%mm5, 40(%%edi,%%edx,) \n\t" // write Raw(x) for 6th 8 bytes

+            "paddb %%mm5, %%mm6           \n\t"

+            "movq 56(%%edi,%%edx,), %%mm7 \n\t" // load Sub(x) for 8th 8 bytes

+            "movq %%mm6, 48(%%edi,%%edx,) \n\t" // write Raw(x) for 7th 8 bytes

+            "addl $64, %%edx              \n\t"

+            "paddb %%mm6, %%mm7           \n\t"

+            "cmpl %%ecx, %%edx            \n\t"

+            "movq %%mm7, -8(%%edi,%%edx,) \n\t" // write Raw(x) for 8th 8 bytes

+            "jb sub_8lp                   \n\t"

+            "cmpl _MMXLength, %%edx       \n\t"

+            "jnb sub_8lt8                 \n\t"

+         "sub_8lpA:                       \n\t"

+            "movq (%%edi,%%edx,), %%mm0   \n\t"

+            "addl $8, %%edx               \n\t"

+            "paddb %%mm7, %%mm0           \n\t"

+            "cmpl _MMXLength, %%edx       \n\t"

+            "movq %%mm0, -8(%%edi,%%edx,) \n\t" // -8 to offset early addl edx

+            "movq %%mm0, %%mm7            \n\t" // move calculated Raw(x) data

+                                                //  to mm1 to be new Raw(x-bpp)

+                                                //  for next loop

+            "jb sub_8lpA                  \n\t"

+         "sub_8lt8:                       \n\t"

+            : "=a" (dummy_value_a),   // 0      // output regs (dummy)

+              "=D" (dummy_value_D)    // 1

+            : "0" (bpp),              // eax    // input regs

+              "1" (row)               // edi

+            : "%ecx", "%edx", "%esi"            // clobber list

+#if 0  /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */

+            , "%mm0", "%mm1", "%mm2", "%mm3", "%mm4", "%mm5", "%mm6", "%mm7"

+#endif

+         );

+      }

+      break;

+      default:                // bpp greater than 8 bytes   GRR BOGUS

+      {

+         __asm__ __volatile__ (

+            "movl _dif, %%edx             \n\t"

+// preload  "movl row, %%edi              \n\t"

+            "movl %%edi, %%esi            \n\t" // lp = row

+// preload  "movl bpp, %%eax              \n\t"

+            "addl %%eax, %%edi            \n\t" // rp = row + bpp

+         "sub_Alp:                        \n\t"

+            "movq (%%edi,%%edx,), %%mm0   \n\t"

+            "movq (%%esi,%%edx,), %%mm1   \n\t"

+            "addl $8, %%edx               \n\t"

+            "paddb %%mm1, %%mm0           \n\t"

+            "cmpl _MMXLength, %%edx       \n\t"

+            "movq %%mm0, -8(%%edi,%%edx,) \n\t" // mov does not affect flags;

+                                                //  -8 to offset addl edx

+            "jb sub_Alp                   \n\t"

+            : "=a" (dummy_value_a),   // 0      // output regs (dummy)

+              "=D" (dummy_value_D)    // 1

+            : "0" (bpp),              // eax    // input regs

+              "1" (row)               // edi

+            : "%edx", "%esi"                    // clobber list

+#if 0  /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */

+            , "%mm0", "%mm1"

+#endif

+         );

+      }

+      break;

+   } // end switch (bpp)

+   __asm__ __volatile__ (

+      "movl _MMXLength, %%edx       \n\t"

+//pre "movl row, %%edi              \n\t"

+      "cmpl _FullLength, %%edx      \n\t"

+      "jnb sub_end                  \n\t"

+      "movl %%edi, %%esi            \n\t" // lp = row

+//pre "movl bpp, %%eax              \n\t"

+      "addl %%eax, %%edi            \n\t" // rp = row + bpp

+      "xorl %%eax, %%eax            \n\t"

+   "sub_lp2:                        \n\t"

+      "movb (%%esi,%%edx,), %%al    \n\t"

+      "addb %%al, (%%edi,%%edx,)    \n\t"

+      "incl %%edx                   \n\t"

+      "cmpl _FullLength, %%edx      \n\t"

+      "jb sub_lp2                   \n\t"

+   "sub_end:                        \n\t"

+      "EMMS                         \n\t" // end MMX instructions

+      : "=a" (dummy_value_a),   // 0      // output regs (dummy)

+        "=D" (dummy_value_D)    // 1

+      : "0" (bpp),              // eax    // input regs

+        "1" (row)               // edi

+      : "%edx", "%esi"                    // clobber list

+   );

+} // end of png_read_filter_row_mmx_sub()

+#endif

+//===========================================================================//

+//                                                                           //

+//            P N G _ R E A D _ F I L T E R _ R O W _ M M X _ U P            //

+//                                                                           //

+//===========================================================================//

+// Optimized code for PNG Up filter decoder

+static void /* PRIVATE */

+png_read_filter_row_mmx_up(png_row_infop row_info, png_bytep row,

+                           png_bytep prev_row)

+{

+   png_uint_32 len;

+   int dummy_value_d;   // fix 'forbidden register 3 (dx) was spilled' error

+   int dummy_value_S;

+   int dummy_value_D;

+   len = row_info->rowbytes;              // number of bytes to filter

+   __asm__ __volatile__ (

+//pre "movl row, %%edi              \n\t"

+      // get # of bytes to alignment

+#ifdef __PIC__

+      "pushl %%ebx                  \n\t"

+#endif

+      "movl %%edi, %%ecx            \n\t"

+      "xorl %%ebx, %%ebx            \n\t"

+      "addl $0x7, %%ecx             \n\t"

+      "xorl %%eax, %%eax            \n\t"

+      "andl $0xfffffff8, %%ecx      \n\t"

+//pre "movl prev_row, %%esi         \n\t"

+      "subl %%edi, %%ecx            \n\t"

+      "jz up_go                     \n\t"

+   "up_lp1:                         \n\t" // fix alignment

+      "movb (%%edi,%%ebx,), %%al    \n\t"

+      "addb (%%esi,%%ebx,), %%al    \n\t"

+      "incl %%ebx                   \n\t"

+      "cmpl %%ecx, %%ebx            \n\t"

+      "movb %%al, -1(%%edi,%%ebx,)  \n\t" // mov does not affect flags; -1 to

+      "jb up_lp1                    \n\t" //  offset incl ebx

+   "up_go:                          \n\t"

+//pre "movl len, %%edx              \n\t"

+      "movl %%edx, %%ecx            \n\t"

+      "subl %%ebx, %%edx            \n\t" // subtract alignment fix

+      "andl $0x0000003f, %%edx      \n\t" // calc bytes over mult of 64

+      "subl %%edx, %%ecx            \n\t" // drop over bytes from length

+      // unrolled loop - use all MMX registers and interleave to reduce

+      // number of branch instructions (loops) and reduce partial stalls

+   "up_loop:                        \n\t"

+      "movq (%%esi,%%ebx,), %%mm1   \n\t"

+      "movq (%%edi,%%ebx,), %%mm0   \n\t"

+      "movq 8(%%esi,%%ebx,), %%mm3  \n\t"

+      "paddb %%mm1, %%mm0           \n\t"

+      "movq 8(%%edi,%%ebx,), %%mm2  \n\t"

+      "movq %%mm0, (%%edi,%%ebx,)   \n\t"

+      "paddb %%mm3, %%mm2           \n\t"

+      "movq 16(%%esi,%%ebx,), %%mm5 \n\t"

+      "movq %%mm2, 8(%%edi,%%ebx,)  \n\t"

+      "movq 16(%%edi,%%ebx,), %%mm4 \n\t"

+      "movq 24(%%esi,%%ebx,), %%mm7 \n\t"

+      "paddb %%mm5, %%mm4           \n\t"

+      "movq 24(%%edi,%%ebx,), %%mm6 \n\t"

+      "movq %%mm4, 16(%%edi,%%ebx,) \n\t"

+      "paddb %%mm7, %%mm6           \n\t"

+      "movq 32(%%esi,%%ebx,), %%mm1 \n\t"

+      "movq %%mm6, 24(%%edi,%%ebx,) \n\t"

+      "movq 32(%%edi,%%ebx,), %%mm0 \n\t"

+      "movq 40(%%esi,%%ebx,), %%mm3 \n\t"

+      "paddb %%mm1, %%mm0           \n\t"

+      "movq 40(%%edi,%%ebx,), %%mm2 \n\t"

+      "movq %%mm0, 32(%%edi,%%ebx,) \n\t"

+      "paddb %%mm3, %%mm2           \n\t"

+      "movq 48(%%esi,%%ebx,), %%mm5 \n\t"

+      "movq %%mm2, 40(%%edi,%%ebx,) \n\t"

+      "movq 48(%%edi,%%ebx,), %%mm4 \n\t"

+      "movq 56(%%esi,%%ebx,), %%mm7 \n\t"

+      "paddb %%mm5, %%mm4           \n\t"

+      "movq 56(%%edi,%%ebx,), %%mm6 \n\t"

+      "movq %%mm4, 48(%%edi,%%ebx,) \n\t"

+      "addl $64, %%ebx              \n\t"

+      "paddb %%mm7, %%mm6           \n\t"

+      "cmpl %%ecx, %%ebx            \n\t"

+      "movq %%mm6, -8(%%edi,%%ebx,) \n\t" // (+56)movq does not affect flags;

+      "jb up_loop                   \n\t" //  -8 to offset addl ebx

+      "cmpl $0, %%edx               \n\t" // test for bytes over mult of 64

+      "jz up_end                    \n\t"

+      "cmpl $8, %%edx               \n\t" // test for less than 8 bytes

+      "jb up_lt8                    \n\t" //  [added by lcreeve at netins.net]

+      "addl %%edx, %%ecx            \n\t"

+      "andl $0x00000007, %%edx      \n\t" // calc bytes over mult of 8

+      "subl %%edx, %%ecx            \n\t" // drop over bytes from length

+      "jz up_lt8                    \n\t"

+   "up_lpA:                         \n\t" // use MMX regs to update 8 bytes sim.

+      "movq (%%esi,%%ebx,), %%mm1   \n\t"

+      "movq (%%edi,%%ebx,), %%mm0   \n\t"

+      "addl $8, %%ebx               \n\t"

+      "paddb %%mm1, %%mm0           \n\t"

+      "cmpl %%ecx, %%ebx            \n\t"

+      "movq %%mm0, -8(%%edi,%%ebx,) \n\t" // movq does not affect flags; -8 to

+      "jb up_lpA                    \n\t" //  offset add ebx

+      "cmpl $0, %%edx               \n\t" // test for bytes over mult of 8

+      "jz up_end                    \n\t"

+   "up_lt8:                         \n\t"

+      "xorl %%eax, %%eax            \n\t"

+      "addl %%edx, %%ecx            \n\t" // move over byte count into counter

+   "up_lp2:                         \n\t" // use x86 regs for remaining bytes

+      "movb (%%edi,%%ebx,), %%al    \n\t"

+      "addb (%%esi,%%ebx,), %%al    \n\t"

+      "incl %%ebx                   \n\t"

+      "cmpl %%ecx, %%ebx            \n\t"

+      "movb %%al, -1(%%edi,%%ebx,)  \n\t" // mov does not affect flags; -1 to

+      "jb up_lp2                    \n\t" //  offset inc ebx

+   "up_end:                         \n\t"

+      "EMMS                         \n\t" // conversion of filtered row complete

+#ifdef __PIC__

+      "popl %%ebx                   \n\t"

+#endif

+      : "=d" (dummy_value_d),   // 0      // output regs (dummy)

+        "=S" (dummy_value_S),   // 1

+        "=D" (dummy_value_D)    // 2

+      : "0" (len),              // edx    // input regs

+        "1" (prev_row),         // esi

+        "2" (row)               // edi

+      : "%eax", "%ecx"            // clobber list (no input regs!)

+#ifndef __PIC__

+      , "%ebx"

+#endif

+#if 0  /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */

+      , "%mm0", "%mm1", "%mm2", "%mm3"

+      , "%mm4", "%mm5", "%mm6", "%mm7"

+#endif

+   );

+} // end of png_read_filter_row_mmx_up()

+#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */

+/*===========================================================================*/

+/*                                                                           */

+/*                   P N G _ R E A D _ F I L T E R _ R O W                   */

+/*                                                                           */

+/*===========================================================================*/

+/* Optimized png_read_filter_row routines */

+void /* PRIVATE */

+png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep

+   row, png_bytep prev_row, int filter)

+{

+#ifdef PNG_DEBUG

+   char filnm[10];

+#endif

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)

+/* GRR:  these are superseded by png_ptr->asm_flags: */

+#define UseMMX_sub    1   // GRR:  converted 20000730

+#define UseMMX_up     1   // GRR:  converted 20000729

+#define UseMMX_avg    1   // GRR:  converted 20000828 (+ 16-bit bugfix 20000916)

+#define UseMMX_paeth  1   // GRR:  converted 20000828

+   if (_mmx_supported == 2) {

+       /* this should have happened in png_init_mmx_flags() already */

+#if !defined(PNG_1_0_X)

+       png_warning(png_ptr, "asm_flags may not have been initialized");

+#endif

+       png_mmx_support();

+   }

+#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */

+#ifdef PNG_DEBUG

+   png_debug(1, "in png_read_filter_row (pnggccrd.c)\n");

+   switch (filter)

+   {

+      case 0: sprintf(filnm, "none");

+         break;

+      case 1: sprintf(filnm, "sub-%s",

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK)

+#if !defined(PNG_1_0_X)

+        (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)? "MMX" :

+#endif

+#endif

+"x86");

+         break;

+      case 2: sprintf(filnm, "up-%s",

+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED

+#if !defined(PNG_1_0_X)

+        (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP)? "MMX" :

+#endif

+#endif

+ "x86");

+         break;

+      case 3: sprintf(filnm, "avg-%s",

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK)

+#if !defined(PNG_1_0_X)

+        (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)? "MMX" :

+#endif

+#endif

+ "x86");

+         break;

+      case 4: sprintf(filnm, "Paeth-%s",

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK)

+#if !defined(PNG_1_0_X)

+        (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)? "MMX":

+#endif

+#endif

+"x86");

+         break;

+      default: sprintf(filnm, "unknw");

+         break;

+   }

+   png_debug2(0, "row_number=%5ld, %5s, ", png_ptr->row_number, filnm);

+   png_debug1(0, "row=0x%08lx, ", (unsigned long)row);

+   png_debug2(0, "pixdepth=%2d, bytes=%d, ", (int)row_info->pixel_depth,

+      (int)((row_info->pixel_depth + 7) >> 3));

+   png_debug1(0,"rowbytes=%8ld\n", row_info->rowbytes);

+#endif /* PNG_DEBUG */

+   switch (filter)

+   {

+      case PNG_FILTER_VALUE_NONE:

+         break;

+      case PNG_FILTER_VALUE_SUB:

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK)

+#if !defined(PNG_1_0_X)

+         if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB) &&

+             (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) &&

+             (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold))

+#else

+         if (_mmx_supported)

+#endif

+         {

+            png_read_filter_row_mmx_sub(row_info, row);

+         }

+         else

+#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */

+         {

+            png_uint_32 i;

+            png_uint_32 istop = row_info->rowbytes;

+            png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;

+            png_bytep rp = row + bpp;

+            png_bytep lp = row;

+            for (i = bpp; i < istop; i++)

+            {

+               *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff);

+               rp++;

+            }

+         }  /* end !UseMMX_sub */

+         break;

+      case PNG_FILTER_VALUE_UP:

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)

+#if !defined(PNG_1_0_X)

+         if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP) &&

+             (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) &&

+             (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold))

+#else

+         if (_mmx_supported)

+#endif

+         {

+            png_read_filter_row_mmx_up(row_info, row, prev_row);

+         }

+          else

+#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */

+         {

+            png_uint_32 i;

+            png_uint_32 istop = row_info->rowbytes;

+            png_bytep rp = row;

+            png_bytep pp = prev_row;

+            for (i = 0; i < istop; ++i)

+            {

+               *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);

+               rp++;

+            }

+         }  /* end !UseMMX_up */

+         break;

+      case PNG_FILTER_VALUE_AVG:

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK)

+#if !defined(PNG_1_0_X)

+         if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG) &&

+             (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) &&

+             (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold))

+#else

+         if (_mmx_supported)

+#endif

+         {

+            png_read_filter_row_mmx_avg(row_info, row, prev_row);

+         }

+         else

+#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */

+         {

+            png_uint_32 i;

+            png_bytep rp = row;

+            png_bytep pp = prev_row;

+            png_bytep lp = row;

+            png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;

+            png_uint_32 istop = row_info->rowbytes - bpp;

+            for (i = 0; i < bpp; i++)

+            {

+               *rp = (png_byte)(((int)(*rp) +

+                  ((int)(*pp++) >> 1)) & 0xff);

+               rp++;

+            }

+            for (i = 0; i < istop; i++)

+            {

+               *rp = (png_byte)(((int)(*rp) +

+                  ((int)(*pp++ + *lp++) >> 1)) & 0xff);

+               rp++;

+            }

+         }  /* end !UseMMX_avg */

+         break;

+      case PNG_FILTER_VALUE_PAETH:

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK)

+#if !defined(PNG_1_0_X)

+         if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH) &&

+             (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) &&

+             (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold))

+#else

+         if (_mmx_supported)

+#endif

+         {

+            png_read_filter_row_mmx_paeth(row_info, row, prev_row);

+         }

+         else

+#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */

+         {

+            png_uint_32 i;

+            png_bytep rp = row;

+            png_bytep pp = prev_row;

+            png_bytep lp = row;

+            png_bytep cp = prev_row;

+            png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;

+            png_uint_32 istop = row_info->rowbytes - bpp;

+            for (i = 0; i < bpp; i++)

+            {

+               *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);

+               rp++;

+            }

+            for (i = 0; i < istop; i++)   /* use leftover rp,pp */

+            {

+               int a, b, c, pa, pb, pc, p;

+               a = *lp++;

+               b = *pp++;

+               c = *cp++;

+               p = b - c;

+               pc = a - c;

+#ifdef PNG_USE_ABS

+               pa = abs(p);

+               pb = abs(pc);

+               pc = abs(p + pc);

+#else

+               pa = p < 0 ? -p : p;

+               pb = pc < 0 ? -pc : pc;

+               pc = (p + pc) < 0 ? -(p + pc) : p + pc;

+#endif

+               /*

+                  if (pa <= pb && pa <= pc)

+                     p = a;

+                  else if (pb <= pc)

+                     p = b;

+                  else

+                     p = c;

+                */

+               p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c;

+               *rp = (png_byte)(((int)(*rp) + p) & 0xff);

+               rp++;

+            }

+         }  /* end !UseMMX_paeth */

+         break;

+      default:

+         png_warning(png_ptr, "Ignoring bad row-filter type");

+         *row=0;

+         break;

+   }

+}

+#endif /* PNG_HAVE_ASSEMBLER_READ_FILTER_ROW */

+/*===========================================================================*/

+/*                                                                           */

+/*                      P N G _ M M X _ S U P P O R T                        */

+/*                                                                           */

+/*===========================================================================*/

+/* GRR NOTES:  (1) the following code assumes 386 or better (pushfl/popfl)

+ *             (2) all instructions compile with gcc 2.7.2.3 and later

+ *             (3) the function is moved down here to prevent gcc from

+ *                  inlining it in multiple places and then barfing be-

+ *                  cause the ".NOT_SUPPORTED" label is multiply defined

+ *             [is there a way to signal that a *single* function should

+ *              not be inlined?  is there a way to modify the label for

+ *              each inlined instance, e.g., by appending _1, _2, etc.?

+ *              maybe if don't use leading "." in label name? (nope...sigh)]

+ */

+int PNGAPI

+png_mmx_support(void)

+{

+#if defined(PNG_MMX_CODE_SUPPORTED)

+    __asm__ __volatile__ (

+        "pushl %%ebx          \n\t"  // ebx gets clobbered by CPUID instruction

+        "pushl %%ecx          \n\t"  // so does ecx...

+        "pushl %%edx          \n\t"  // ...and edx (but ecx & edx safe on Linux)

+//      ".byte  0x66          \n\t"  // convert 16-bit pushf to 32-bit pushfd

+//      "pushf                \n\t"  // 16-bit pushf

+        "pushfl               \n\t"  // save Eflag to stack

+        "popl %%eax           \n\t"  // get Eflag from stack into eax

+        "movl %%eax, %%ecx    \n\t"  // make another copy of Eflag in ecx

+        "xorl $0x200000, %%eax \n\t" // toggle ID bit in Eflag (i.e., bit 21)

+        "pushl %%eax          \n\t"  // save modified Eflag back to stack

+//      ".byte  0x66          \n\t"  // convert 16-bit popf to 32-bit popfd

+//      "popf                 \n\t"  // 16-bit popf

+        "popfl                \n\t"  // restore modified value to Eflag reg

+        "pushfl               \n\t"  // save Eflag to stack

+        "popl %%eax           \n\t"  // get Eflag from stack

+        "pushl %%ecx          \n\t"  // save original Eflag to stack

+        "popfl                \n\t"  // restore original Eflag

+        "xorl %%ecx, %%eax    \n\t"  // compare new Eflag with original Eflag

+        "jz 0f                \n\t"  // if same, CPUID instr. is not supported

+        "xorl %%eax, %%eax    \n\t"  // set eax to zero

+//      ".byte  0x0f, 0xa2    \n\t"  // CPUID instruction (two-byte opcode)

+        "cpuid                \n\t"  // get the CPU identification info

+        "cmpl $1, %%eax       \n\t"  // make sure eax return non-zero value

+        "jl 0f                \n\t"  // if eax is zero, MMX is not supported

+        "xorl %%eax, %%eax    \n\t"  // set eax to zero and...

+        "incl %%eax           \n\t"  // ...increment eax to 1.  This pair is

+                                     // faster than the instruction "mov eax, 1"

+        "cpuid                \n\t"  // get the CPU identification info again

+        "andl $0x800000, %%edx \n\t" // mask out all bits but MMX bit (23)

+        "cmpl $0, %%edx       \n\t"  // 0 = MMX not supported

+        "jz 0f                \n\t"  // non-zero = yes, MMX IS supported

+        "movl $1, %%eax       \n\t"  // set return value to 1

+        "jmp  1f              \n\t"  // DONE:  have MMX support

+    "0:                       \n\t"  // .NOT_SUPPORTED: target label for jump instructions

+        "movl $0, %%eax       \n\t"  // set return value to 0

+    "1:                       \n\t"  // .RETURN: target label for jump instructions

+        "movl %%eax, _mmx_supported \n\t" // save in global static variable, too

+        "popl %%edx           \n\t"  // restore edx

+        "popl %%ecx           \n\t"  // restore ecx

+        "popl %%ebx           \n\t"  // restore ebx

+//      "ret                  \n\t"  // DONE:  no MMX support

+                                     // (fall through to standard C "ret")

+        :                            // output list (none)

+        :                            // any variables used on input (none)

+        : "%eax"                     // clobber list

+//      , "%ebx", "%ecx", "%edx"     // GRR:  we handle these manually

+//      , "memory"   // if write to a variable gcc thought was in a reg

+//      , "cc"       // "condition codes" (flag bits)

+    );

+#else

+    _mmx_supported = 0;

+#endif /* PNG_MMX_CODE_SUPPORTED */

+    return _mmx_supported;

+}

+#endif /* PNG_USE_PNGGCCRD */

--- /dev/null

+++ b/src/gfx/libpng/pngget.c

@@ -1,0 +1,934 @@

+/* pngget.c - retrieval of values from info struct

+ *

+ * libpng 1.2.8 - December 3, 2004

+ * For conditions of distribution and use, see copyright notice in png.h

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

+ */

+#define PNG_INTERNAL

+#include "png.h"

+png_uint_32 PNGAPI

+png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag)

+{

+   if (png_ptr != NULL && info_ptr != NULL)

+      return(info_ptr->valid & flag);

+   else

+      return(0);

+}

+png_uint_32 PNGAPI

+png_get_rowbytes(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr != NULL && info_ptr != NULL)

+      return(info_ptr->rowbytes);

+   else

+      return(0);

+}

+#if defined(PNG_INFO_IMAGE_SUPPORTED)

+png_bytepp PNGAPI

+png_get_rows(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr != NULL && info_ptr != NULL)

+      return(info_ptr->row_pointers);

+   else

+      return(0);

+}

+#endif

+#ifdef PNG_EASY_ACCESS_SUPPORTED

+/* easy access to info, added in libpng-0.99 */

+png_uint_32 PNGAPI

+png_get_image_width(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr != NULL && info_ptr != NULL)

+   {

+      return info_ptr->width;

+   }

+   return (0);

+}

+png_uint_32 PNGAPI

+png_get_image_height(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr != NULL && info_ptr != NULL)

+   {

+      return info_ptr->height;

+   }

+   return (0);

+}

+png_byte PNGAPI

+png_get_bit_depth(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr != NULL && info_ptr != NULL)

+   {

+      return info_ptr->bit_depth;

+   }

+   return (0);

+}

+png_byte PNGAPI

+png_get_color_type(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr != NULL && info_ptr != NULL)

+   {

+      return info_ptr->color_type;

+   }

+   return (0);

+}

+png_byte PNGAPI

+png_get_filter_type(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr != NULL && info_ptr != NULL)

+   {

+      return info_ptr->filter_type;

+   }

+   return (0);

+}

+png_byte PNGAPI

+png_get_interlace_type(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr != NULL && info_ptr != NULL)

+   {

+      return info_ptr->interlace_type;

+   }

+   return (0);

+}

+png_byte PNGAPI

+png_get_compression_type(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr != NULL && info_ptr != NULL)

+   {

+      return info_ptr->compression_type;

+   }

+   return (0);

+}

+png_uint_32 PNGAPI

+png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr != NULL && info_ptr != NULL)

+#if defined(PNG_pHYs_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_pHYs)

+   {

+      png_debug1(1, "in %s retrieval function\n", "png_get_x_pixels_per_meter");

+      if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER)

+          return (0);

+      else return (info_ptr->x_pixels_per_unit);

+   }

+#else

+   return (0);

+#endif

+   return (0);

+}

+png_uint_32 PNGAPI

+png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr != NULL && info_ptr != NULL)

+#if defined(PNG_pHYs_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_pHYs)

+   {

+      png_debug1(1, "in %s retrieval function\n", "png_get_y_pixels_per_meter");

+      if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER)

+          return (0);

+      else return (info_ptr->y_pixels_per_unit);

+   }

+#else

+   return (0);

+#endif

+   return (0);

+}

+png_uint_32 PNGAPI

+png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr != NULL && info_ptr != NULL)

+#if defined(PNG_pHYs_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_pHYs)

+   {

+      png_debug1(1, "in %s retrieval function\n", "png_get_pixels_per_meter");

+      if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER ||

+         info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit)

+          return (0);

+      else return (info_ptr->x_pixels_per_unit);

+   }

+#else

+   return (0);

+#endif

+   return (0);

+}

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+float PNGAPI

+png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr)

+   {

+   if (png_ptr != NULL && info_ptr != NULL)

+#if defined(PNG_pHYs_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_pHYs)

+   {

+      png_debug1(1, "in %s retrieval function\n", "png_get_aspect_ratio");

+      if (info_ptr->x_pixels_per_unit == 0)

+         return ((float)0.0);

+      else

+         return ((float)((float)info_ptr->y_pixels_per_unit

+            /(float)info_ptr->x_pixels_per_unit));

+   }

+#else

+   return (0.0);

+#endif

+   return ((float)0.0);

+}

+#endif

+png_int_32 PNGAPI

+png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr != NULL && info_ptr != NULL)

+#if defined(PNG_oFFs_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_oFFs)

+   {

+      png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns");

+      if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)

+          return (0);

+      else return (info_ptr->x_offset);

+   }

+#else

+   return (0);

+#endif

+   return (0);

+}

+png_int_32 PNGAPI

+png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr != NULL && info_ptr != NULL)

+#if defined(PNG_oFFs_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_oFFs)

+   {

+      png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns");

+      if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)

+          return (0);

+      else return (info_ptr->y_offset);

+   }

+#else

+   return (0);

+#endif

+   return (0);

+}

+png_int_32 PNGAPI

+png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr != NULL && info_ptr != NULL)

+#if defined(PNG_oFFs_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_oFFs)

+   {

+      png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns");

+      if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)

+          return (0);

+      else return (info_ptr->x_offset);

+   }

+#else

+   return (0);

+#endif

+   return (0);

+}

+png_int_32 PNGAPI

+png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr != NULL && info_ptr != NULL)

+#if defined(PNG_oFFs_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_oFFs)

+   {

+      png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns");

+      if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)

+          return (0);

+      else return (info_ptr->y_offset);

+   }

+#else

+   return (0);

+#endif

+   return (0);

+}

+#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED)

+png_uint_32 PNGAPI

+png_get_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)

+{

+   return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr)

+     *.0254 +.5));

+}

+png_uint_32 PNGAPI

+png_get_x_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)

+{

+   return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr)

+     *.0254 +.5));

+}

+png_uint_32 PNGAPI

+png_get_y_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)

+{

+   return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr)

+     *.0254 +.5));

+}

+float PNGAPI

+png_get_x_offset_inches(png_structp png_ptr, png_infop info_ptr)

+{

+   return ((float)png_get_x_offset_microns(png_ptr, info_ptr)

+     *.00003937);

+}

+float PNGAPI

+png_get_y_offset_inches(png_structp png_ptr, png_infop info_ptr)

+{

+   return ((float)png_get_y_offset_microns(png_ptr, info_ptr)

+     *.00003937);

+}

+#if defined(PNG_pHYs_SUPPORTED)

+png_uint_32 PNGAPI

+png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)

+{

+   png_uint_32 retval = 0;

+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))

+   {

+      png_debug1(1, "in %s retrieval function\n", "pHYs");

+      if (res_x != NULL)

+      {

+         *res_x = info_ptr->x_pixels_per_unit;

+         retval |= PNG_INFO_pHYs;

+      }

+      if (res_y != NULL)

+      {

+         *res_y = info_ptr->y_pixels_per_unit;

+         retval |= PNG_INFO_pHYs;

+      }

+      if (unit_type != NULL)

+      {

+         *unit_type = (int)info_ptr->phys_unit_type;

+         retval |= PNG_INFO_pHYs;

+         if(*unit_type == 1)

+         {

+            if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);

+            if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);

+         }

+      }

+   }

+   return (retval);

+}

+#endif /* PNG_pHYs_SUPPORTED */

+#endif  /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */

+/* png_get_channels really belongs in here, too, but it's been around longer */

+#endif  /* PNG_EASY_ACCESS_SUPPORTED */

+png_byte PNGAPI

+png_get_channels(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr != NULL && info_ptr != NULL)

+      return(info_ptr->channels);

+   else

+      return (0);

+}

+png_bytep PNGAPI

+png_get_signature(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr != NULL && info_ptr != NULL)

+      return(info_ptr->signature);

+   else

+      return (NULL);

+}

+#if defined(PNG_bKGD_SUPPORTED)

+png_uint_32 PNGAPI

+png_get_bKGD(png_structp png_ptr, png_infop info_ptr,

+   png_color_16p *background)

+{

+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)

+      && background != NULL)

+   {

+      png_debug1(1, "in %s retrieval function\n", "bKGD");

+      *background = &(info_ptr->background);

+      return (PNG_INFO_bKGD);

+   }

+   return (0);

+}

+#endif

+#if defined(PNG_cHRM_SUPPORTED)

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+png_uint_32 PNGAPI

+png_get_cHRM(png_structp png_ptr, png_infop info_ptr,

+   double *white_x, double *white_y, double *red_x, double *red_y,

+   double *green_x, double *green_y, double *blue_x, double *blue_y)

+{

+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))

+   {

+      png_debug1(1, "in %s retrieval function\n", "cHRM");

+      if (white_x != NULL)

+         *white_x = (double)info_ptr->x_white;

+      if (white_y != NULL)

+         *white_y = (double)info_ptr->y_white;

+      if (red_x != NULL)

+         *red_x = (double)info_ptr->x_red;

+      if (red_y != NULL)

+         *red_y = (double)info_ptr->y_red;

+      if (green_x != NULL)

+         *green_x = (double)info_ptr->x_green;

+      if (green_y != NULL)

+         *green_y = (double)info_ptr->y_green;

+      if (blue_x != NULL)

+         *blue_x = (double)info_ptr->x_blue;

+      if (blue_y != NULL)

+         *blue_y = (double)info_ptr->y_blue;

+      return (PNG_INFO_cHRM);

+   }

+   return (0);

+}

+#endif

+#ifdef PNG_FIXED_POINT_SUPPORTED

+png_uint_32 PNGAPI

+png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,

+   png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x,

+   png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y,

+   png_fixed_point *blue_x, png_fixed_point *blue_y)

+{

+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))

+   {

+      png_debug1(1, "in %s retrieval function\n", "cHRM");

+      if (white_x != NULL)

+         *white_x = info_ptr->int_x_white;

+      if (white_y != NULL)

+         *white_y = info_ptr->int_y_white;

+      if (red_x != NULL)

+         *red_x = info_ptr->int_x_red;

+      if (red_y != NULL)

+         *red_y = info_ptr->int_y_red;

+      if (green_x != NULL)

+         *green_x = info_ptr->int_x_green;

+      if (green_y != NULL)

+         *green_y = info_ptr->int_y_green;

+      if (blue_x != NULL)

+         *blue_x = info_ptr->int_x_blue;

+      if (blue_y != NULL)

+         *blue_y = info_ptr->int_y_blue;

+      return (PNG_INFO_cHRM);

+   }

+   return (0);

+}

+#endif

+#endif

+#if defined(PNG_gAMA_SUPPORTED)

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+png_uint_32 PNGAPI

+png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)

+{

+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)

+      && file_gamma != NULL)

+   {

+      png_debug1(1, "in %s retrieval function\n", "gAMA");

+      *file_gamma = (double)info_ptr->gamma;

+      return (PNG_INFO_gAMA);

+   }

+   return (0);

+}

+#endif

+#ifdef PNG_FIXED_POINT_SUPPORTED

+png_uint_32 PNGAPI

+png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr,

+    png_fixed_point *int_file_gamma)

+{

+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)

+      && int_file_gamma != NULL)

+   {

+      png_debug1(1, "in %s retrieval function\n", "gAMA");

+      *int_file_gamma = info_ptr->int_gamma;

+      return (PNG_INFO_gAMA);

+   }

+   return (0);

+}

+#endif

+#endif

+#if defined(PNG_sRGB_SUPPORTED)

+png_uint_32 PNGAPI

+png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent)

+{

+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)

+      && file_srgb_intent != NULL)

+   {

+      png_debug1(1, "in %s retrieval function\n", "sRGB");

+      *file_srgb_intent = (int)info_ptr->srgb_intent;

+      return (PNG_INFO_sRGB);

+   }

+   return (0);

+}

+#endif

+#if defined(PNG_iCCP_SUPPORTED)

+png_uint_32 PNGAPI

+png_get_iCCP(png_structp png_ptr, png_infop info_ptr,

+             png_charpp name, int *compression_type,

+             png_charpp profile, png_uint_32 *proflen)

+{

+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)

+      && name != NULL && profile != NULL && proflen != NULL)

+   {

+      png_debug1(1, "in %s retrieval function\n", "iCCP");

+      *name = info_ptr->iccp_name;

+      *profile = info_ptr->iccp_profile;

+      /* compression_type is a dummy so the API won't have to change

+         if we introduce multiple compression types later. */

+      *proflen = (int)info_ptr->iccp_proflen;

+      *compression_type = (int)info_ptr->iccp_compression;

+      return (PNG_INFO_iCCP);

+   }

+   return (0);

+}

+#endif

+#if defined(PNG_sPLT_SUPPORTED)

+png_uint_32 PNGAPI

+png_get_sPLT(png_structp png_ptr, png_infop info_ptr,

+             png_sPLT_tpp spalettes)

+{

+   if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)

+     *spalettes = info_ptr->splt_palettes;

+   return ((png_uint_32)info_ptr->splt_palettes_num);

+}

+#endif

+#if defined(PNG_hIST_SUPPORTED)

+png_uint_32 PNGAPI

+png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist)

+{

+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)

+      && hist != NULL)

+   {

+      png_debug1(1, "in %s retrieval function\n", "hIST");

+      *hist = info_ptr->hist;

+      return (PNG_INFO_hIST);

+   }

+   return (0);

+}

+#endif

+png_uint_32 PNGAPI

+png_get_IHDR(png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 *width, png_uint_32 *height, int *bit_depth,

+   int *color_type, int *interlace_type, int *compression_type,

+   int *filter_type)

+{

+   if (png_ptr != NULL && info_ptr != NULL && width != NULL && height != NULL &&

+      bit_depth != NULL && color_type != NULL)

+   {

+      png_debug1(1, "in %s retrieval function\n", "IHDR");

+      *width = info_ptr->width;

+      *height = info_ptr->height;

+      *bit_depth = info_ptr->bit_depth;

+      if (info_ptr->bit_depth < 1 || info_ptr->bit_depth > 16)

+        png_error(png_ptr, "Invalid bit depth");

+      *color_type = info_ptr->color_type;

+      if (info_ptr->color_type > 6)

+        png_error(png_ptr, "Invalid color type");

+      if (compression_type != NULL)

+         *compression_type = info_ptr->compression_type;

+      if (filter_type != NULL)

+         *filter_type = info_ptr->filter_type;

+      if (interlace_type != NULL)

+         *interlace_type = info_ptr->interlace_type;

+      /* check for potential overflow of rowbytes */

+      if (*width == 0 || *width > PNG_UINT_31_MAX)

+        png_error(png_ptr, "Invalid image width");

+      if (*height == 0 || *height > PNG_UINT_31_MAX)

+        png_error(png_ptr, "Invalid image height");

+      if (info_ptr->width > (PNG_UINT_32_MAX

+                 >> 3)      /* 8-byte RGBA pixels */

+                 - 64       /* bigrowbuf hack */

+                 - 1        /* filter byte */

+                 - 7*8      /* rounding of width to multiple of 8 pixels */

+                 - 8)       /* extra max_pixel_depth pad */

+      {

+         png_warning(png_ptr,

+            "Width too large for libpng to process image data.");

+      }

+      return (1);

+   }

+   return (0);

+}

+#if defined(PNG_oFFs_SUPPORTED)

+png_uint_32 PNGAPI

+png_get_oFFs(png_structp png_ptr, png_infop info_ptr,

+   png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)

+{

+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)

+      && offset_x != NULL && offset_y != NULL && unit_type != NULL)

+   {

+      png_debug1(1, "in %s retrieval function\n", "oFFs");

+      *offset_x = info_ptr->x_offset;

+      *offset_y = info_ptr->y_offset;

+      *unit_type = (int)info_ptr->offset_unit_type;

+      return (PNG_INFO_oFFs);

+   }

+   return (0);

+}

+#endif

+#if defined(PNG_pCAL_SUPPORTED)

+png_uint_32 PNGAPI

+png_get_pCAL(png_structp png_ptr, png_infop info_ptr,

+   png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,

+   png_charp *units, png_charpp *params)

+{

+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)

+      && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&

+      nparams != NULL && units != NULL && params != NULL)

+   {

+      png_debug1(1, "in %s retrieval function\n", "pCAL");

+      *purpose = info_ptr->pcal_purpose;

+      *X0 = info_ptr->pcal_X0;

+      *X1 = info_ptr->pcal_X1;

+      *type = (int)info_ptr->pcal_type;

+      *nparams = (int)info_ptr->pcal_nparams;

+      *units = info_ptr->pcal_units;

+      *params = info_ptr->pcal_params;

+      return (PNG_INFO_pCAL);

+   }

+   return (0);

+}

+#endif

+#if defined(PNG_sCAL_SUPPORTED)

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+png_uint_32 PNGAPI

+png_get_sCAL(png_structp png_ptr, png_infop info_ptr,

+             int *unit, double *width, double *height)

+{

+    if (png_ptr != NULL && info_ptr != NULL &&

+       (info_ptr->valid & PNG_INFO_sCAL))

+    {

+        *unit = info_ptr->scal_unit;

+        *width = info_ptr->scal_pixel_width;

+        *height = info_ptr->scal_pixel_height;

+        return (PNG_INFO_sCAL);

+    }

+    return(0);

+}

+#else

+#ifdef PNG_FIXED_POINT_SUPPORTED

+png_uint_32 PNGAPI

+png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr,

+             int *unit, png_charpp width, png_charpp height)

+{

+    if (png_ptr != NULL && info_ptr != NULL &&

+       (info_ptr->valid & PNG_INFO_sCAL))

+    {

+        *unit = info_ptr->scal_unit;

+        *width = info_ptr->scal_s_width;

+        *height = info_ptr->scal_s_height;

+        return (PNG_INFO_sCAL);

+    }

+    return(0);

+}

+#endif

+#endif

+#endif

+#if defined(PNG_pHYs_SUPPORTED)

+png_uint_32 PNGAPI

+png_get_pHYs(png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)

+{

+   png_uint_32 retval = 0;

+   if (png_ptr != NULL && info_ptr != NULL &&

+      (info_ptr->valid & PNG_INFO_pHYs))

+   {

+      png_debug1(1, "in %s retrieval function\n", "pHYs");

+      if (res_x != NULL)

+      {

+         *res_x = info_ptr->x_pixels_per_unit;

+         retval |= PNG_INFO_pHYs;

+      }

+      if (res_y != NULL)

+      {

+         *res_y = info_ptr->y_pixels_per_unit;

+         retval |= PNG_INFO_pHYs;

+      }

+      if (unit_type != NULL)

+      {

+         *unit_type = (int)info_ptr->phys_unit_type;

+         retval |= PNG_INFO_pHYs;

+      }

+   }

+   return (retval);

+}

+#endif

+png_uint_32 PNGAPI

+png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette,

+   int *num_palette)

+{

+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)

+       && palette != NULL)

+   {

+      png_debug1(1, "in %s retrieval function\n", "PLTE");

+      *palette = info_ptr->palette;

+      *num_palette = info_ptr->num_palette;

+      png_debug1(3, "num_palette = %d\n", *num_palette);

+      return (PNG_INFO_PLTE);

+   }

+   return (0);

+}

+#if defined(PNG_sBIT_SUPPORTED)

+png_uint_32 PNGAPI

+png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit)

+{

+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)

+      && sig_bit != NULL)

+   {

+      png_debug1(1, "in %s retrieval function\n", "sBIT");

+      *sig_bit = &(info_ptr->sig_bit);

+      return (PNG_INFO_sBIT);

+   }

+   return (0);

+}

+#endif

+#if defined(PNG_TEXT_SUPPORTED)

+png_uint_32 PNGAPI

+png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,

+   int *num_text)

+{

+   if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)

+   {

+      png_debug1(1, "in %s retrieval function\n",

+         (png_ptr->chunk_name[0] == '\0' ? "text"

+             : (png_const_charp)png_ptr->chunk_name));

+      if (text_ptr != NULL)

+         *text_ptr = info_ptr->text;

+      if (num_text != NULL)

+         *num_text = info_ptr->num_text;

+      return ((png_uint_32)info_ptr->num_text);

+   }

+   if (num_text != NULL)

+     *num_text = 0;

+   return(0);

+}

+#endif

+#if defined(PNG_tIME_SUPPORTED)

+png_uint_32 PNGAPI

+png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time)

+{

+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)

+       && mod_time != NULL)

+   {

+      png_debug1(1, "in %s retrieval function\n", "tIME");

+      *mod_time = &(info_ptr->mod_time);

+      return (PNG_INFO_tIME);

+   }

+   return (0);

+}

+#endif

+#if defined(PNG_tRNS_SUPPORTED)

+png_uint_32 PNGAPI

+png_get_tRNS(png_structp png_ptr, png_infop info_ptr,

+   png_bytep *trans, int *num_trans, png_color_16p *trans_values)

+{

+   png_uint_32 retval = 0;

+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))

+   {

+      png_debug1(1, "in %s retrieval function\n", "tRNS");

+      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+      {

+          if (trans != NULL)

+          {

+             *trans = info_ptr->trans;

+             retval |= PNG_INFO_tRNS;

+          }

+          if (trans_values != NULL)

+             *trans_values = &(info_ptr->trans_values);

+      }

+      else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */

+      {

+          if (trans_values != NULL)

+          {

+             *trans_values = &(info_ptr->trans_values);

+             retval |= PNG_INFO_tRNS;

+          }

+          if(trans != NULL)

+             *trans = NULL;

+      }

+      if(num_trans != NULL)

+      {

+         *num_trans = info_ptr->num_trans;

+         retval |= PNG_INFO_tRNS;

+      }

+   }

+   return (retval);

+}

+#endif

+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)

+png_uint_32 PNGAPI

+png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr,

+             png_unknown_chunkpp unknowns)

+{

+   if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)

+     *unknowns = info_ptr->unknown_chunks;

+   return ((png_uint_32)info_ptr->unknown_chunks_num);

+}

+#endif

+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)

+png_byte PNGAPI

+png_get_rgb_to_gray_status (png_structp png_ptr)

+{

+   return (png_byte)(png_ptr? png_ptr->rgb_to_gray_status : 0);

+}

+#endif

+#if defined(PNG_USER_CHUNKS_SUPPORTED)

+png_voidp PNGAPI

+png_get_user_chunk_ptr(png_structp png_ptr)

+{

+   return (png_ptr? png_ptr->user_chunk_ptr : NULL);

+}

+#endif

+#ifdef PNG_WRITE_SUPPORTED

+png_uint_32 PNGAPI

+png_get_compression_buffer_size(png_structp png_ptr)

+{

+   return (png_uint_32)(png_ptr? png_ptr->zbuf_size : 0L);

+}

+#endif

+#ifndef PNG_1_0_X

+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED

+/* this function was added to libpng 1.2.0 and should exist by default */

+png_uint_32 PNGAPI

+png_get_asm_flags (png_structp png_ptr)

+{

+    return (png_uint_32)(png_ptr? png_ptr->asm_flags : 0L);

+}

+/* this function was added to libpng 1.2.0 and should exist by default */

+png_uint_32 PNGAPI

+png_get_asm_flagmask (int flag_select)

+{

+    png_uint_32 settable_asm_flags = 0;

+    if (flag_select & PNG_SELECT_READ)

+        settable_asm_flags |=

+          PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  |

+          PNG_ASM_FLAG_MMX_READ_INTERLACE    |

+          PNG_ASM_FLAG_MMX_READ_FILTER_SUB   |

+          PNG_ASM_FLAG_MMX_READ_FILTER_UP    |

+          PNG_ASM_FLAG_MMX_READ_FILTER_AVG   |

+          PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;

+          /* no non-MMX flags yet */

+#if 0

+    /* GRR:  no write-flags yet, either, but someday... */

+    if (flag_select & PNG_SELECT_WRITE)

+        settable_asm_flags |=

+          PNG_ASM_FLAG_MMX_WRITE_ [whatever] ;

+#endif /* 0 */

+    return settable_asm_flags;  /* _theoretically_ settable capabilities only */

+}

+#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)

+    /* GRR:  could add this:   && defined(PNG_MMX_CODE_SUPPORTED) */

+/* this function was added to libpng 1.2.0 */

+png_uint_32 PNGAPI

+png_get_mmx_flagmask (int flag_select, int *compilerID)

+{

+    png_uint_32 settable_mmx_flags = 0;

+    if (flag_select & PNG_SELECT_READ)

+        settable_mmx_flags |=

+          PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  |

+          PNG_ASM_FLAG_MMX_READ_INTERLACE    |

+          PNG_ASM_FLAG_MMX_READ_FILTER_SUB   |

+          PNG_ASM_FLAG_MMX_READ_FILTER_UP    |

+          PNG_ASM_FLAG_MMX_READ_FILTER_AVG   |

+          PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;

+#if 0

+    /* GRR:  no MMX write support yet, but someday... */

+    if (flag_select & PNG_SELECT_WRITE)

+        settable_mmx_flags |=

+          PNG_ASM_FLAG_MMX_WRITE_ [whatever] ;

+#endif /* 0 */

+    if (compilerID != NULL) {

+#ifdef PNG_USE_PNGVCRD

+        *compilerID = 1;    /* MSVC */

+#else

+#ifdef PNG_USE_PNGGCCRD

+        *compilerID = 2;    /* gcc/gas */

+#else

+        *compilerID = -1;   /* unknown (i.e., no asm/MMX code compiled) */

+#endif

+#endif

+    }

+    return settable_mmx_flags;  /* _theoretically_ settable capabilities only */

+}

+/* this function was added to libpng 1.2.0 */

+png_byte PNGAPI

+png_get_mmx_bitdepth_threshold (png_structp png_ptr)

+{

+    return (png_byte)(png_ptr? png_ptr->mmx_bitdepth_threshold : 0);

+}

+/* this function was added to libpng 1.2.0 */

+png_uint_32 PNGAPI

+png_get_mmx_rowbytes_threshold (png_structp png_ptr)

+{

+    return (png_uint_32)(png_ptr? png_ptr->mmx_rowbytes_threshold : 0L);

+}

+#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */

+#ifdef PNG_SET_USER_LIMITS_SUPPORTED

+/* these functions were added to libpng 1.2.6 */

+png_uint_32 PNGAPI

+png_get_user_width_max (png_structp png_ptr)

+{

+    return (png_ptr? png_ptr->user_width_max : 0);

+}

+png_uint_32 PNGAPI

+png_get_user_height_max (png_structp png_ptr)

+{

+    return (png_ptr? png_ptr->user_height_max : 0);

+}

+#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */

+#endif /* ?PNG_1_0_X */

--- /dev/null

+++ b/src/gfx/libpng/pngmem.c

@@ -1,0 +1,595 @@

+/* pngmem.c - stub functions for memory allocation

+ *

+ * libpng version 1.2.8 - December 3, 2004

+ * For conditions of distribution and use, see copyright notice in png.h

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

+ *

+ * This file provides a location for all memory allocation.  Users who

+ * need special memory handling are expected to supply replacement

+ * functions for png_malloc() and png_free(), and to use

+ * png_create_read_struct_2() and png_create_write_struct_2() to

+ * identify the replacement functions.

+ */

+#define PNG_INTERNAL

+#include "png.h"

+/* Borland DOS special memory handler */

+#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)

+/* if you change this, be sure to change the one in png.h also */

+/* Allocate memory for a png_struct.  The malloc and memset can be replaced

+   by a single call to calloc() if this is thought to improve performance. */

+png_voidp /* PRIVATE */

+png_create_struct(int type)

+{

+#ifdef PNG_USER_MEM_SUPPORTED

+   return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));

+}

+/* Alternate version of png_create_struct, for use with user-defined malloc. */

+png_voidp /* PRIVATE */

+png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)

+{

+#endif /* PNG_USER_MEM_SUPPORTED */

+   png_size_t size;

+   png_voidp struct_ptr;

+   if (type == PNG_STRUCT_INFO)

+     size = png_sizeof(png_info);

+   else if (type == PNG_STRUCT_PNG)

+     size = png_sizeof(png_struct);

+   else

+     return (png_get_copyright(NULL));

+#ifdef PNG_USER_MEM_SUPPORTED

+   if(malloc_fn != NULL)

+   {

+      png_struct dummy_struct;

+      png_structp png_ptr = &dummy_struct;

+      png_ptr->mem_ptr=mem_ptr;

+      struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size);

+   }

+   else

+#endif /* PNG_USER_MEM_SUPPORTED */

+      struct_ptr = (png_voidp)farmalloc(size);

+   if (struct_ptr != NULL)

+      png_memset(struct_ptr, 0, size);

+   return (struct_ptr);

+}

+/* Free memory allocated by a png_create_struct() call */

+void /* PRIVATE */

+png_destroy_struct(png_voidp struct_ptr)

+{

+#ifdef PNG_USER_MEM_SUPPORTED

+   png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL);

+}

+/* Free memory allocated by a png_create_struct() call */

+void /* PRIVATE */

+png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,

+    png_voidp mem_ptr)

+{

+#endif

+   if (struct_ptr != NULL)

+   {

+#ifdef PNG_USER_MEM_SUPPORTED

+      if(free_fn != NULL)

+      {

+         png_struct dummy_struct;

+         png_structp png_ptr = &dummy_struct;

+         png_ptr->mem_ptr=mem_ptr;

+         (*(free_fn))(png_ptr, struct_ptr);

+         return;

+      }

+#endif /* PNG_USER_MEM_SUPPORTED */

+      farfree (struct_ptr);

+   }

+}

+/* Allocate memory.  For reasonable files, size should never exceed

+ * 64K.  However, zlib may allocate more then 64K if you don't tell

+ * it not to.  See zconf.h and png.h for more information. zlib does

+ * need to allocate exactly 64K, so whatever you call here must

+ * have the ability to do that.

+ *

+ * Borland seems to have a problem in DOS mode for exactly 64K.

+ * It gives you a segment with an offset of 8 (perhaps to store its

+ * memory stuff).  zlib doesn't like this at all, so we have to

+ * detect and deal with it.  This code should not be needed in

+ * Windows or OS/2 modes, and only in 16 bit mode.  This code has

+ * been updated by Alexander Lehmann for version 0.89 to waste less

+ * memory.

+ *

+ * Note that we can't use png_size_t for the "size" declaration,

+ * since on some systems a png_size_t is a 16-bit quantity, and as a

+ * result, we would be truncating potentially larger memory requests

+ * (which should cause a fatal error) and introducing major problems.

+ */

+png_voidp PNGAPI

+png_malloc(png_structp png_ptr, png_uint_32 size)

+{

+   png_voidp ret;

+   if (png_ptr == NULL || size == 0)

+      return (NULL);

+#ifdef PNG_USER_MEM_SUPPORTED

+   if(png_ptr->malloc_fn != NULL)

+       ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));

+   else

+       ret = (png_malloc_default(png_ptr, size));

+   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

+       png_error(png_ptr, "Out of memory!");

+   return (ret);

+}

+png_voidp PNGAPI

+png_malloc_default(png_structp png_ptr, png_uint_32 size)

+{

+   png_voidp ret;

+#endif /* PNG_USER_MEM_SUPPORTED */

+#ifdef PNG_MAX_MALLOC_64K

+   if (size > (png_uint_32)65536L)

+   {

+      png_warning(png_ptr, "Cannot Allocate > 64K");

+      ret = NULL;

+   }

+   else

+#endif

+   if (size != (size_t)size)

+     ret = NULL;

+   else if (size == (png_uint_32)65536L)

+   {

+      if (png_ptr->offset_table == NULL)

+      {

+         /* try to see if we need to do any of this fancy stuff */

+         ret = farmalloc(size);

+         if (ret == NULL || ((png_size_t)ret & 0xffff))

+         {

+            int num_blocks;

+            png_uint_32 total_size;

+            png_bytep table;

+            int i;

+            png_byte huge * hptr;

+            if (ret != NULL)

+            {

+               farfree(ret);

+               ret = NULL;

+            }

+            if(png_ptr->zlib_window_bits > 14)

+               num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));

+            else

+               num_blocks = 1;

+            if (png_ptr->zlib_mem_level >= 7)

+               num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));

+            else

+               num_blocks++;

+            total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;

+            table = farmalloc(total_size);

+            if (table == NULL)

+            {

+#ifndef PNG_USER_MEM_SUPPORTED

+               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

+                  png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */

+               else

+                  png_warning(png_ptr, "Out Of Memory.");

+#endif

+               return (NULL);

+            }

+            if ((png_size_t)table & 0xfff0)

+            {

+#ifndef PNG_USER_MEM_SUPPORTED

+               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

+                  png_error(png_ptr,

+                    "Farmalloc didn't return normalized pointer");

+               else

+                  png_warning(png_ptr,

+                    "Farmalloc didn't return normalized pointer");

+#endif

+               return (NULL);

+            }

+            png_ptr->offset_table = table;

+            png_ptr->offset_table_ptr = farmalloc(num_blocks *

+               png_sizeof (png_bytep));

+            if (png_ptr->offset_table_ptr == NULL)

+            {

+#ifndef PNG_USER_MEM_SUPPORTED

+               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

+                  png_error(png_ptr, "Out Of memory."); /* Note "O" and "M" */

+               else

+                  png_warning(png_ptr, "Out Of memory.");

+#endif

+               return (NULL);

+            }

+            hptr = (png_byte huge *)table;

+            if ((png_size_t)hptr & 0xf)

+            {

+               hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);

+               hptr = hptr + 16L;  /* "hptr += 16L" fails on Turbo C++ 3.0 */

+            }

+            for (i = 0; i < num_blocks; i++)

+            {

+               png_ptr->offset_table_ptr[i] = (png_bytep)hptr;

+               hptr = hptr + (png_uint_32)65536L;  /* "+=" fails on TC++3.0 */

+            }

+            png_ptr->offset_table_number = num_blocks;

+            png_ptr->offset_table_count = 0;

+            png_ptr->offset_table_count_free = 0;

+         }

+      }

+      if (png_ptr->offset_table_count >= png_ptr->offset_table_number)

+      {

+#ifndef PNG_USER_MEM_SUPPORTED

+         if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

+            png_error(png_ptr, "Out of Memory."); /* Note "o" and "M" */

+         else

+            png_warning(png_ptr, "Out of Memory.");

+#endif

+         return (NULL);

+      }

+      ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];

+   }

+   else

+      ret = farmalloc(size);

+#ifndef PNG_USER_MEM_SUPPORTED

+   if (ret == NULL)

+   {

+      if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

+         png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */

+      else

+         png_warning(png_ptr, "Out of memory."); /* Note "o" and "m" */

+   }

+#endif

+   return (ret);

+}

+/* free a pointer allocated by png_malloc().  In the default

+   configuration, png_ptr is not used, but is passed in case it

+   is needed.  If ptr is NULL, return without taking any action. */

+void PNGAPI

+png_free(png_structp png_ptr, png_voidp ptr)

+{

+   if (png_ptr == NULL || ptr == NULL)

+      return;

+#ifdef PNG_USER_MEM_SUPPORTED

+   if (png_ptr->free_fn != NULL)

+   {

+      (*(png_ptr->free_fn))(png_ptr, ptr);

+      return;

+   }

+   else png_free_default(png_ptr, ptr);

+}

+void PNGAPI

+png_free_default(png_structp png_ptr, png_voidp ptr)

+{

+#endif /* PNG_USER_MEM_SUPPORTED */

+   if (png_ptr->offset_table != NULL)

+   {

+      int i;

+      for (i = 0; i < png_ptr->offset_table_count; i++)

+      {

+         if (ptr == png_ptr->offset_table_ptr[i])

+         {

+            ptr = NULL;

+            png_ptr->offset_table_count_free++;

+            break;

+         }

+      }

+      if (png_ptr->offset_table_count_free == png_ptr->offset_table_count)

+      {

+         farfree(png_ptr->offset_table);

+         farfree(png_ptr->offset_table_ptr);

+         png_ptr->offset_table = NULL;

+         png_ptr->offset_table_ptr = NULL;

+      }

+   }

+   if (ptr != NULL)

+   {

+      farfree(ptr);

+   }

+}

+#else /* Not the Borland DOS special memory handler */

+/* Allocate memory for a png_struct or a png_info.  The malloc and

+   memset can be replaced by a single call to calloc() if this is thought

+   to improve performance noticably. */

+png_voidp /* PRIVATE */

+png_create_struct(int type)

+{

+#ifdef PNG_USER_MEM_SUPPORTED

+   return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));

+}

+/* Allocate memory for a png_struct or a png_info.  The malloc and

+   memset can be replaced by a single call to calloc() if this is thought

+   to improve performance noticably. */

+png_voidp /* PRIVATE */

+png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)

+{

+#endif /* PNG_USER_MEM_SUPPORTED */

+   png_size_t size;

+   png_voidp struct_ptr;

+   if (type == PNG_STRUCT_INFO)

+      size = png_sizeof(png_info);

+   else if (type == PNG_STRUCT_PNG)

+      size = png_sizeof(png_struct);

+   else

+      return (NULL);

+#ifdef PNG_USER_MEM_SUPPORTED

+   if(malloc_fn != NULL)

+   {

+      png_struct dummy_struct;

+      png_structp png_ptr = &dummy_struct;

+      png_ptr->mem_ptr=mem_ptr;

+      struct_ptr = (*(malloc_fn))(png_ptr, size);

+      if (struct_ptr != NULL)

+         png_memset(struct_ptr, 0, size);

+      return (struct_ptr);

+   }

+#endif /* PNG_USER_MEM_SUPPORTED */

+#if defined(__TURBOC__) && !defined(__FLAT__)

+   struct_ptr = (png_voidp)farmalloc(size);

+#else

+# if defined(_MSC_VER) && defined(MAXSEG_64K)

+   struct_ptr = (png_voidp)halloc(size,1);

+# else

+   struct_ptr = (png_voidp)malloc(size);

+# endif

+#endif

+   if (struct_ptr != NULL)

+      png_memset(struct_ptr, 0, size);

+   return (struct_ptr);

+}

+/* Free memory allocated by a png_create_struct() call */

+void /* PRIVATE */

+png_destroy_struct(png_voidp struct_ptr)

+{

+#ifdef PNG_USER_MEM_SUPPORTED

+   png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL);

+}

+/* Free memory allocated by a png_create_struct() call */

+void /* PRIVATE */

+png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,

+    png_voidp mem_ptr)

+{

+#endif /* PNG_USER_MEM_SUPPORTED */

+   if (struct_ptr != NULL)

+   {

+#ifdef PNG_USER_MEM_SUPPORTED

+      if(free_fn != NULL)

+      {

+         png_struct dummy_struct;

+         png_structp png_ptr = &dummy_struct;

+         png_ptr->mem_ptr=mem_ptr;

+         (*(free_fn))(png_ptr, struct_ptr);

+         return;

+      }

+#endif /* PNG_USER_MEM_SUPPORTED */

+#if defined(__TURBOC__) && !defined(__FLAT__)

+      farfree(struct_ptr);

+#else

+# if defined(_MSC_VER) && defined(MAXSEG_64K)

+      hfree(struct_ptr);

+# else

+      free(struct_ptr);

+# endif

+#endif

+   }

+}

+/* Allocate memory.  For reasonable files, size should never exceed

+   64K.  However, zlib may allocate more then 64K if you don't tell

+   it not to.  See zconf.h and png.h for more information.  zlib does

+   need to allocate exactly 64K, so whatever you call here must

+   have the ability to do that. */

+png_voidp PNGAPI

+png_malloc(png_structp png_ptr, png_uint_32 size)

+{

+   png_voidp ret;

+#ifdef PNG_USER_MEM_SUPPORTED

+   if (png_ptr == NULL || size == 0)

+      return (NULL);

+   if(png_ptr->malloc_fn != NULL)

+       ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));

+   else

+       ret = (png_malloc_default(png_ptr, size));

+   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

+       png_error(png_ptr, "Out of Memory!");

+   return (ret);

+}

+png_voidp PNGAPI

+png_malloc_default(png_structp png_ptr, png_uint_32 size)

+{

+   png_voidp ret;

+#endif /* PNG_USER_MEM_SUPPORTED */

+   if (png_ptr == NULL || size == 0)

+      return (NULL);

+#ifdef PNG_MAX_MALLOC_64K

+   if (size > (png_uint_32)65536L)

+   {

+#ifndef PNG_USER_MEM_SUPPORTED

+      if(png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

+         png_error(png_ptr, "Cannot Allocate > 64K");

+      else

+#endif

+         return NULL;

+   }

+#endif

+ /* Check for overflow */

+#if defined(__TURBOC__) && !defined(__FLAT__)

+ if (size != (unsigned long)size)

+   ret = NULL;

+ else

+   ret = farmalloc(size);

+#else

+# if defined(_MSC_VER) && defined(MAXSEG_64K)

+ if (size != (unsigned long)size)

+   ret = NULL;

+ else

+   ret = halloc(size, 1);

+# else

+ if (size != (size_t)size)

+   ret = NULL;

+ else

+   ret = malloc((size_t)size);

+# endif

+#endif

+#ifndef PNG_USER_MEM_SUPPORTED

+   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

+      png_error(png_ptr, "Out of Memory");

+#endif

+   return (ret);

+}

+/* Free a pointer allocated by png_malloc().  If ptr is NULL, return

+   without taking any action. */

+void PNGAPI

+png_free(png_structp png_ptr, png_voidp ptr)

+{

+   if (png_ptr == NULL || ptr == NULL)

+      return;

+#ifdef PNG_USER_MEM_SUPPORTED

+   if (png_ptr->free_fn != NULL)

+   {

+      (*(png_ptr->free_fn))(png_ptr, ptr);

+      return;

+   }

+   else png_free_default(png_ptr, ptr);

+}

+void PNGAPI

+png_free_default(png_structp png_ptr, png_voidp ptr)

+{

+   if (png_ptr == NULL || ptr == NULL)

+      return;

+#endif /* PNG_USER_MEM_SUPPORTED */

+#if defined(__TURBOC__) && !defined(__FLAT__)

+   farfree(ptr);

+#else

+# if defined(_MSC_VER) && defined(MAXSEG_64K)

+   hfree(ptr);

+# else

+   free(ptr);

+# endif

+#endif

+}

+#endif /* Not Borland DOS special memory handler */

+#if defined(PNG_1_0_X)

+#  define png_malloc_warn png_malloc

+#else

+/* This function was added at libpng version 1.2.3.  The png_malloc_warn()

+ * function will set up png_malloc() to issue a png_warning and return NULL

+ * instead of issuing a png_error, if it fails to allocate the requested

+ * memory.

+ */

+png_voidp PNGAPI

+png_malloc_warn(png_structp png_ptr, png_uint_32 size)

+{

+   png_voidp ptr;

+   png_uint_32 save_flags=png_ptr->flags;

+   png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;

+   ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);

+   png_ptr->flags=save_flags;

+   return(ptr);

+}

+#endif

+png_voidp PNGAPI

+png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2,

+   png_uint_32 length)

+{

+   png_size_t size;

+   size = (png_size_t)length;

+   if ((png_uint_32)size != length)

+      png_error(png_ptr,"Overflow in png_memcpy_check.");

+   return(png_memcpy (s1, s2, size));

+}

+png_voidp PNGAPI

+png_memset_check (png_structp png_ptr, png_voidp s1, int value,

+   png_uint_32 length)

+{

+   png_size_t size;

+   size = (png_size_t)length;

+   if ((png_uint_32)size != length)

+      png_error(png_ptr,"Overflow in png_memset_check.");

+   return (png_memset (s1, value, size));

+}

+#ifdef PNG_USER_MEM_SUPPORTED

+/* This function is called when the application wants to use another method

+ * of allocating and freeing memory.

+ */

+void PNGAPI

+png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr

+  malloc_fn, png_free_ptr free_fn)

+{

+   png_ptr->mem_ptr = mem_ptr;

+   png_ptr->malloc_fn = malloc_fn;

+   png_ptr->free_fn = free_fn;

+}

+/* This function returns a pointer to the mem_ptr associated with the user

+ * functions.  The application should free any memory associated with this

+ * pointer before png_write_destroy and png_read_destroy are called.

+ */

+png_voidp PNGAPI

+png_get_mem_ptr(png_structp png_ptr)

+{

+   return ((png_voidp)png_ptr->mem_ptr);

+}

+#endif /* PNG_USER_MEM_SUPPORTED */

binary files /dev/null b/src/gfx/libpng/pngnow.png differ

--- /dev/null

+++ b/src/gfx/libpng/pngpread.c

@@ -1,0 +1,1573 @@

+/* pngpread.c - read a png file in push mode

+ *

+ * libpng version 1.2.8 - December 3, 2004

+ * For conditions of distribution and use, see copyright notice in png.h

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

+ */

+#define PNG_INTERNAL

+#include "png.h"

+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

+/* push model modes */

+#define PNG_READ_SIG_MODE   0

+#define PNG_READ_CHUNK_MODE 1

+#define PNG_READ_IDAT_MODE  2

+#define PNG_SKIP_MODE       3

+#define PNG_READ_tEXt_MODE  4

+#define PNG_READ_zTXt_MODE  5

+#define PNG_READ_DONE_MODE  6

+#define PNG_READ_iTXt_MODE  7

+#define PNG_ERROR_MODE      8

+void PNGAPI

+png_process_data(png_structp png_ptr, png_infop info_ptr,

+   png_bytep buffer, png_size_t buffer_size)

+{

+   png_push_restore_buffer(png_ptr, buffer, buffer_size);

+   while (png_ptr->buffer_size)

+   {

+      png_process_some_data(png_ptr, info_ptr);

+   }

+}

+/* What we do with the incoming data depends on what we were previously

+ * doing before we ran out of data...

+ */

+void /* PRIVATE */

+png_process_some_data(png_structp png_ptr, png_infop info_ptr)

+{

+   switch (png_ptr->process_mode)

+   {

+      case PNG_READ_SIG_MODE:

+      {

+         png_push_read_sig(png_ptr, info_ptr);

+         break;

+      }

+      case PNG_READ_CHUNK_MODE:

+      {

+         png_push_read_chunk(png_ptr, info_ptr);

+         break;

+      }

+      case PNG_READ_IDAT_MODE:

+      {

+         png_push_read_IDAT(png_ptr);

+         break;

+      }

+#if defined(PNG_READ_tEXt_SUPPORTED)

+      case PNG_READ_tEXt_MODE:

+      {

+         png_push_read_tEXt(png_ptr, info_ptr);

+         break;

+      }

+#endif

+#if defined(PNG_READ_zTXt_SUPPORTED)

+      case PNG_READ_zTXt_MODE:

+      {

+         png_push_read_zTXt(png_ptr, info_ptr);

+         break;

+      }

+#endif

+#if defined(PNG_READ_iTXt_SUPPORTED)

+      case PNG_READ_iTXt_MODE:

+      {

+         png_push_read_iTXt(png_ptr, info_ptr);

+         break;

+      }

+#endif

+      case PNG_SKIP_MODE:

+      {

+         png_push_crc_finish(png_ptr);

+         break;

+      }

+      default:

+      {

+         png_ptr->buffer_size = 0;

+         break;

+      }

+   }

+}

+/* Read any remaining signature bytes from the stream and compare them with

+ * the correct PNG signature.  It is possible that this routine is called

+ * with bytes already read from the signature, either because they have been

+ * checked by the calling application, or because of multiple calls to this

+ * routine.

+ */

+void /* PRIVATE */

+png_push_read_sig(png_structp png_ptr, png_infop info_ptr)

+{

+   png_size_t num_checked = png_ptr->sig_bytes,

+             num_to_check = 8 - num_checked;

+   if (png_ptr->buffer_size < num_to_check)

+   {

+      num_to_check = png_ptr->buffer_size;

+   }

+   png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),

+      num_to_check);

+   png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes+num_to_check);

+   if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))

+   {

+      if (num_checked < 4 &&

+          png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))

+         png_error(png_ptr, "Not a PNG file");

+      else

+         png_error(png_ptr, "PNG file corrupted by ASCII conversion");

+   }

+   else

+   {

+      if (png_ptr->sig_bytes >= 8)

+      {

+         png_ptr->process_mode = PNG_READ_CHUNK_MODE;

+      }

+   }

+}

+void /* PRIVATE */

+png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+      PNG_IHDR;

+      PNG_IDAT;

+      PNG_IEND;

+      PNG_PLTE;

+#if defined(PNG_READ_bKGD_SUPPORTED)

+      PNG_bKGD;

+#endif

+#if defined(PNG_READ_cHRM_SUPPORTED)

+      PNG_cHRM;

+#endif

+#if defined(PNG_READ_gAMA_SUPPORTED)

+      PNG_gAMA;

+#endif

+#if defined(PNG_READ_hIST_SUPPORTED)

+      PNG_hIST;

+#endif

+#if defined(PNG_READ_iCCP_SUPPORTED)

+      PNG_iCCP;

+#endif

+#if defined(PNG_READ_iTXt_SUPPORTED)

+      PNG_iTXt;

+#endif

+#if defined(PNG_READ_oFFs_SUPPORTED)

+      PNG_oFFs;

+#endif

+#if defined(PNG_READ_pCAL_SUPPORTED)

+      PNG_pCAL;

+#endif

+#if defined(PNG_READ_pHYs_SUPPORTED)

+      PNG_pHYs;

+#endif

+#if defined(PNG_READ_sBIT_SUPPORTED)

+      PNG_sBIT;

+#endif

+#if defined(PNG_READ_sCAL_SUPPORTED)

+      PNG_sCAL;

+#endif

+#if defined(PNG_READ_sRGB_SUPPORTED)

+      PNG_sRGB;

+#endif

+#if defined(PNG_READ_sPLT_SUPPORTED)

+      PNG_sPLT;

+#endif

+#if defined(PNG_READ_tEXt_SUPPORTED)

+      PNG_tEXt;

+#endif

+#if defined(PNG_READ_tIME_SUPPORTED)

+      PNG_tIME;

+#endif

+#if defined(PNG_READ_tRNS_SUPPORTED)

+      PNG_tRNS;

+#endif

+#if defined(PNG_READ_zTXt_SUPPORTED)

+      PNG_zTXt;

+#endif

+#endif /* PNG_USE_LOCAL_ARRAYS */

+   /* First we make sure we have enough data for the 4 byte chunk name

+    * and the 4 byte chunk length before proceeding with decoding the

+    * chunk data.  To fully decode each of these chunks, we also make

+    * sure we have enough data in the buffer for the 4 byte CRC at the

+    * end of every chunk (except IDAT, which is handled separately).

+    */

+   if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))

+   {

+      png_byte chunk_length[4];

+      if (png_ptr->buffer_size < 8)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_push_fill_buffer(png_ptr, chunk_length, 4);

+      png_ptr->push_length = png_get_uint_31(png_ptr,chunk_length);

+      png_reset_crc(png_ptr);

+      png_crc_read(png_ptr, png_ptr->chunk_name, 4);

+      png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;

+   }

+   if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);

+   }

+   else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);

+      png_ptr->process_mode = PNG_READ_DONE_MODE;

+      png_push_have_end(png_ptr, info_ptr);

+   }

+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

+   else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

+         png_ptr->mode |= PNG_HAVE_IDAT;

+      png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);

+      if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))

+         png_ptr->mode |= PNG_HAVE_PLTE;

+      else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

+      {

+         if (!(png_ptr->mode & PNG_HAVE_IHDR))

+            png_error(png_ptr, "Missing IHDR before IDAT");

+         else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&

+                  !(png_ptr->mode & PNG_HAVE_PLTE))

+            png_error(png_ptr, "Missing PLTE before IDAT");

+      }

+   }

+#endif

+   else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);

+   }

+   else if (!png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4))

+   {

+      /* If we reach an IDAT chunk, this means we have read all of the

+       * header chunks, and we can start reading the image (or if this

+       * is called after the image has been read - we have an error).

+       */

+     if (!(png_ptr->mode & PNG_HAVE_IHDR))

+       png_error(png_ptr, "Missing IHDR before IDAT");

+     else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&

+         !(png_ptr->mode & PNG_HAVE_PLTE))

+       png_error(png_ptr, "Missing PLTE before IDAT");

+      if (png_ptr->mode & PNG_HAVE_IDAT)

+      {

+         if (png_ptr->push_length == 0)

+            return;

+         if (png_ptr->mode & PNG_AFTER_IDAT)

+            png_error(png_ptr, "Too many IDAT's found");

+      }

+      png_ptr->idat_size = png_ptr->push_length;

+      png_ptr->mode |= PNG_HAVE_IDAT;

+      png_ptr->process_mode = PNG_READ_IDAT_MODE;

+      png_push_have_info(png_ptr, info_ptr);

+      png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;

+      png_ptr->zstream.next_out = png_ptr->row_buf;

+      return;

+   }

+#if defined(PNG_READ_gAMA_SUPPORTED)

+   else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);

+   }

+#endif

+#if defined(PNG_READ_sBIT_SUPPORTED)

+   else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);

+   }

+#endif

+#if defined(PNG_READ_cHRM_SUPPORTED)

+   else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);

+   }

+#endif

+#if defined(PNG_READ_sRGB_SUPPORTED)

+   else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);

+   }

+#endif

+#if defined(PNG_READ_iCCP_SUPPORTED)

+   else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);

+   }

+#endif

+#if defined(PNG_READ_sPLT_SUPPORTED)

+   else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);

+   }

+#endif

+#if defined(PNG_READ_tRNS_SUPPORTED)

+   else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);

+   }

+#endif

+#if defined(PNG_READ_bKGD_SUPPORTED)

+   else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);

+   }

+#endif

+#if defined(PNG_READ_hIST_SUPPORTED)

+   else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);

+   }

+#endif

+#if defined(PNG_READ_pHYs_SUPPORTED)

+   else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);

+   }

+#endif

+#if defined(PNG_READ_oFFs_SUPPORTED)

+   else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);

+   }

+#endif

+#if defined(PNG_READ_pCAL_SUPPORTED)

+   else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);

+   }

+#endif

+#if defined(PNG_READ_sCAL_SUPPORTED)

+   else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);

+   }

+#endif

+#if defined(PNG_READ_tIME_SUPPORTED)

+   else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);

+   }

+#endif

+#if defined(PNG_READ_tEXt_SUPPORTED)

+   else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);

+   }

+#endif

+#if defined(PNG_READ_zTXt_SUPPORTED)

+   else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);

+   }

+#endif

+#if defined(PNG_READ_iTXt_SUPPORTED)

+   else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);

+   }

+#endif

+   else

+   {

+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_push_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);

+   }

+   png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;

+}

+void /* PRIVATE */

+png_push_crc_skip(png_structp png_ptr, png_uint_32 skip)

+{

+   png_ptr->process_mode = PNG_SKIP_MODE;

+   png_ptr->skip_length = skip;

+}

+void /* PRIVATE */

+png_push_crc_finish(png_structp png_ptr)

+{

+   if (png_ptr->skip_length && png_ptr->save_buffer_size)

+   {

+      png_size_t save_size;

+      if (png_ptr->skip_length < (png_uint_32)png_ptr->save_buffer_size)

+         save_size = (png_size_t)png_ptr->skip_length;

+      else

+         save_size = png_ptr->save_buffer_size;

+      png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);

+      png_ptr->skip_length -= save_size;

+      png_ptr->buffer_size -= save_size;

+      png_ptr->save_buffer_size -= save_size;

+      png_ptr->save_buffer_ptr += save_size;

+   }

+   if (png_ptr->skip_length && png_ptr->current_buffer_size)

+   {

+      png_size_t save_size;

+      if (png_ptr->skip_length < (png_uint_32)png_ptr->current_buffer_size)

+         save_size = (png_size_t)png_ptr->skip_length;

+      else

+         save_size = png_ptr->current_buffer_size;

+      png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);

+      png_ptr->skip_length -= save_size;

+      png_ptr->buffer_size -= save_size;

+      png_ptr->current_buffer_size -= save_size;

+      png_ptr->current_buffer_ptr += save_size;

+   }

+   if (!png_ptr->skip_length)

+   {

+      if (png_ptr->buffer_size < 4)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_crc_finish(png_ptr, 0);

+      png_ptr->process_mode = PNG_READ_CHUNK_MODE;

+   }

+}

+void PNGAPI

+png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)

+{

+   png_bytep ptr;

+   ptr = buffer;

+   if (png_ptr->save_buffer_size)

+   {

+      png_size_t save_size;

+      if (length < png_ptr->save_buffer_size)

+         save_size = length;

+      else

+         save_size = png_ptr->save_buffer_size;

+      png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size);

+      length -= save_size;

+      ptr += save_size;

+      png_ptr->buffer_size -= save_size;

+      png_ptr->save_buffer_size -= save_size;

+      png_ptr->save_buffer_ptr += save_size;

+   }

+   if (length && png_ptr->current_buffer_size)

+   {

+      png_size_t save_size;

+      if (length < png_ptr->current_buffer_size)

+         save_size = length;

+      else

+         save_size = png_ptr->current_buffer_size;

+      png_memcpy(ptr, png_ptr->current_buffer_ptr, save_size);

+      png_ptr->buffer_size -= save_size;

+      png_ptr->current_buffer_size -= save_size;

+      png_ptr->current_buffer_ptr += save_size;

+   }

+}

+void /* PRIVATE */

+png_push_save_buffer(png_structp png_ptr)

+{

+   if (png_ptr->save_buffer_size)

+   {

+      if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)

+      {

+         png_size_t i,istop;

+         png_bytep sp;

+         png_bytep dp;

+         istop = png_ptr->save_buffer_size;

+         for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer;

+            i < istop; i++, sp++, dp++)

+         {

+            *dp = *sp;

+         }

+      }

+   }

+   if (png_ptr->save_buffer_size + png_ptr->current_buffer_size >

+      png_ptr->save_buffer_max)

+   {

+      png_size_t new_max;

+      png_bytep old_buffer;

+      if (png_ptr->save_buffer_size > PNG_SIZE_MAX -

+         (png_ptr->current_buffer_size + 256))

+      {

+        png_error(png_ptr, "Potential overflow of save_buffer");

+      }

+      new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;

+      old_buffer = png_ptr->save_buffer;

+      png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr,

+         (png_uint_32)new_max);

+      png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);

+      png_free(png_ptr, old_buffer);

+      png_ptr->save_buffer_max = new_max;

+   }

+   if (png_ptr->current_buffer_size)

+   {

+      png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size,

+         png_ptr->current_buffer_ptr, png_ptr->current_buffer_size);

+      png_ptr->save_buffer_size += png_ptr->current_buffer_size;

+      png_ptr->current_buffer_size = 0;

+   }

+   png_ptr->save_buffer_ptr = png_ptr->save_buffer;

+   png_ptr->buffer_size = 0;

+}

+void /* PRIVATE */

+png_push_restore_buffer(png_structp png_ptr, png_bytep buffer,

+   png_size_t buffer_length)

+{

+   png_ptr->current_buffer = buffer;

+   png_ptr->current_buffer_size = buffer_length;

+   png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size;

+   png_ptr->current_buffer_ptr = png_ptr->current_buffer;

+}

+void /* PRIVATE */

+png_push_read_IDAT(png_structp png_ptr)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_IDAT;

+#endif

+   if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))

+   {

+      png_byte chunk_length[4];

+      if (png_ptr->buffer_size < 8)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_push_fill_buffer(png_ptr, chunk_length, 4);

+      png_ptr->push_length = png_get_uint_31(png_ptr,chunk_length);

+      png_reset_crc(png_ptr);

+      png_crc_read(png_ptr, png_ptr->chunk_name, 4);

+      png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;

+      if (png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4))

+      {

+         png_ptr->process_mode = PNG_READ_CHUNK_MODE;

+         if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))

+            png_error(png_ptr, "Not enough compressed data");

+         return;

+      }

+      png_ptr->idat_size = png_ptr->push_length;

+   }

+   if (png_ptr->idat_size && png_ptr->save_buffer_size)

+   {

+      png_size_t save_size;

+      if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size)

+      {

+         save_size = (png_size_t)png_ptr->idat_size;

+         /* check for overflow */

+         if((png_uint_32)save_size != png_ptr->idat_size)

+            png_error(png_ptr, "save_size overflowed in pngpread");

+      }

+      else

+         save_size = png_ptr->save_buffer_size;

+      png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);

+      if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))

+         png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size);

+      png_ptr->idat_size -= save_size;

+      png_ptr->buffer_size -= save_size;

+      png_ptr->save_buffer_size -= save_size;

+      png_ptr->save_buffer_ptr += save_size;

+   }

+   if (png_ptr->idat_size && png_ptr->current_buffer_size)

+   {

+      png_size_t save_size;

+      if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size)

+      {

+         save_size = (png_size_t)png_ptr->idat_size;

+         /* check for overflow */

+         if((png_uint_32)save_size != png_ptr->idat_size)

+            png_error(png_ptr, "save_size overflowed in pngpread");

+      }

+      else

+         save_size = png_ptr->current_buffer_size;

+      png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);

+      if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))

+        png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size);

+      png_ptr->idat_size -= save_size;

+      png_ptr->buffer_size -= save_size;

+      png_ptr->current_buffer_size -= save_size;

+      png_ptr->current_buffer_ptr += save_size;

+   }

+   if (!png_ptr->idat_size)

+   {

+      if (png_ptr->buffer_size < 4)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_crc_finish(png_ptr, 0);

+      png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;

+      png_ptr->mode |= PNG_AFTER_IDAT;

+   }

+}

+void /* PRIVATE */

+png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,

+   png_size_t buffer_length)

+{

+   int ret;

+   if ((png_ptr->flags & PNG_FLAG_ZLIB_FINISHED) && buffer_length)

+      png_error(png_ptr, "Extra compression data");

+   png_ptr->zstream.next_in = buffer;

+   png_ptr->zstream.avail_in = (uInt)buffer_length;

+   for(;;)

+   {

+      ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);

+      if (ret != Z_OK)

+      {

+         if (ret == Z_STREAM_END)

+         {

+            if (png_ptr->zstream.avail_in)

+               png_error(png_ptr, "Extra compressed data");

+            if (!(png_ptr->zstream.avail_out))

+            {

+               png_push_process_row(png_ptr);

+            }

+            png_ptr->mode |= PNG_AFTER_IDAT;

+            png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

+            break;

+         }

+         else if (ret == Z_BUF_ERROR)

+            break;

+         else

+            png_error(png_ptr, "Decompression Error");

+      }

+      if (!(png_ptr->zstream.avail_out))

+      {

+         if ((

+#if defined(PNG_READ_INTERLACING_SUPPORTED)

+             png_ptr->interlaced && png_ptr->pass > 6) ||

+             (!png_ptr->interlaced &&

+#endif

+             png_ptr->row_number == png_ptr->num_rows))

+         {

+           if (png_ptr->zstream.avail_in)

+             png_warning(png_ptr, "Too much data in IDAT chunks");

+           png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

+           break;

+         }

+         png_push_process_row(png_ptr);

+         png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;

+         png_ptr->zstream.next_out = png_ptr->row_buf;

+      }

+      else

+         break;

+   }

+}

+void /* PRIVATE */

+png_push_process_row(png_structp png_ptr)

+{

+   png_ptr->row_info.color_type = png_ptr->color_type;

+   png_ptr->row_info.width = png_ptr->iwidth;

+   png_ptr->row_info.channels = png_ptr->channels;

+   png_ptr->row_info.bit_depth = png_ptr->bit_depth;

+   png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;

+   png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,

+       png_ptr->row_info.width);

+   png_read_filter_row(png_ptr, &(png_ptr->row_info),

+      png_ptr->row_buf + 1, png_ptr->prev_row + 1,

+      (int)(png_ptr->row_buf[0]));

+   png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,

+      png_ptr->rowbytes + 1);

+   if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))

+      png_do_read_transformations(png_ptr);

+#if defined(PNG_READ_INTERLACING_SUPPORTED)

+   /* blow up interlaced rows to full size */

+   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))

+   {

+      if (png_ptr->pass < 6)

+/*       old interface (pre-1.0.9):

+         png_do_read_interlace(&(png_ptr->row_info),

+            png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);

+ */

+         png_do_read_interlace(png_ptr);

+    switch (png_ptr->pass)

+    {

+         case 0:

+         {

+            int i;

+            for (i = 0; i < 8 && png_ptr->pass == 0; i++)

+            {

+               png_push_have_row(png_ptr, png_ptr->row_buf + 1);

+               png_read_push_finish_row(png_ptr); /* updates png_ptr->pass */

+            }

+            if (png_ptr->pass == 2) /* pass 1 might be empty */

+            {

+               for (i = 0; i < 4 && png_ptr->pass == 2; i++)

+               {

+                  png_push_have_row(png_ptr, png_bytep_NULL);

+                  png_read_push_finish_row(png_ptr);

+               }

+            }

+            if (png_ptr->pass == 4 && png_ptr->height <= 4)

+            {

+               for (i = 0; i < 2 && png_ptr->pass == 4; i++)

+               {

+                  png_push_have_row(png_ptr, png_bytep_NULL);

+                  png_read_push_finish_row(png_ptr);

+               }

+            }

+            if (png_ptr->pass == 6 && png_ptr->height <= 4)

+            {

+                png_push_have_row(png_ptr, png_bytep_NULL);

+                png_read_push_finish_row(png_ptr);

+            }

+            break;

+         }

+         case 1:

+         {

+            int i;

+            for (i = 0; i < 8 && png_ptr->pass == 1; i++)

+            {

+               png_push_have_row(png_ptr, png_ptr->row_buf + 1);

+               png_read_push_finish_row(png_ptr);

+            }

+            if (png_ptr->pass == 2) /* skip top 4 generated rows */

+            {

+               for (i = 0; i < 4 && png_ptr->pass == 2; i++)

+               {

+                  png_push_have_row(png_ptr, png_bytep_NULL);

+                  png_read_push_finish_row(png_ptr);

+               }

+            }

+            break;

+         }

+         case 2:

+         {

+            int i;

+            for (i = 0; i < 4 && png_ptr->pass == 2; i++)

+            {

+               png_push_have_row(png_ptr, png_ptr->row_buf + 1);

+               png_read_push_finish_row(png_ptr);

+            }

+            for (i = 0; i < 4 && png_ptr->pass == 2; i++)

+            {

+               png_push_have_row(png_ptr, png_bytep_NULL);

+               png_read_push_finish_row(png_ptr);

+            }

+            if (png_ptr->pass == 4) /* pass 3 might be empty */

+            {

+               for (i = 0; i < 2 && png_ptr->pass == 4; i++)

+               {

+                  png_push_have_row(png_ptr, png_bytep_NULL);

+                  png_read_push_finish_row(png_ptr);

+               }

+            }

+            break;

+         }

+         case 3:

+         {

+            int i;

+            for (i = 0; i < 4 && png_ptr->pass == 3; i++)

+            {

+               png_push_have_row(png_ptr, png_ptr->row_buf + 1);

+               png_read_push_finish_row(png_ptr);

+            }

+            if (png_ptr->pass == 4) /* skip top two generated rows */

+            {

+               for (i = 0; i < 2 && png_ptr->pass == 4; i++)

+               {

+                  png_push_have_row(png_ptr, png_bytep_NULL);

+                  png_read_push_finish_row(png_ptr);

+               }

+            }

+            break;

+         }

+         case 4:

+         {

+            int i;

+            for (i = 0; i < 2 && png_ptr->pass == 4; i++)

+            {

+               png_push_have_row(png_ptr, png_ptr->row_buf + 1);

+               png_read_push_finish_row(png_ptr);

+            }

+            for (i = 0; i < 2 && png_ptr->pass == 4; i++)

+            {

+               png_push_have_row(png_ptr, png_bytep_NULL);

+               png_read_push_finish_row(png_ptr);

+            }

+            if (png_ptr->pass == 6) /* pass 5 might be empty */

+            {

+               png_push_have_row(png_ptr, png_bytep_NULL);

+               png_read_push_finish_row(png_ptr);

+            }

+            break;

+         }

+         case 5:

+         {

+            int i;

+            for (i = 0; i < 2 && png_ptr->pass == 5; i++)

+            {

+               png_push_have_row(png_ptr, png_ptr->row_buf + 1);

+               png_read_push_finish_row(png_ptr);

+            }

+            if (png_ptr->pass == 6) /* skip top generated row */

+            {

+               png_push_have_row(png_ptr, png_bytep_NULL);

+               png_read_push_finish_row(png_ptr);

+            }

+            break;

+         }

+         case 6:

+         {

+            png_push_have_row(png_ptr, png_ptr->row_buf + 1);

+            png_read_push_finish_row(png_ptr);

+            if (png_ptr->pass != 6)

+               break;

+            png_push_have_row(png_ptr, png_bytep_NULL);

+            png_read_push_finish_row(png_ptr);

+         }

+      }

+   }

+   else

+#endif

+   {

+      png_push_have_row(png_ptr, png_ptr->row_buf + 1);

+      png_read_push_finish_row(png_ptr);

+   }

+}

+void /* PRIVATE */

+png_read_push_finish_row(png_structp png_ptr)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */

+   /* start of interlace block */

+   const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};

+   /* offset to next interlace block */

+   const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};

+   /* start of interlace block in the y direction */

+   const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};

+   /* offset to next interlace block in the y direction */

+   const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};

+   /* Width of interlace block.  This is not currently used - if you need

+    * it, uncomment it here and in png.h

+   const int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1};

+   */

+   /* Height of interlace block.  This is not currently used - if you need

+    * it, uncomment it here and in png.h

+   const int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};

+   */

+#endif

+   png_ptr->row_number++;

+   if (png_ptr->row_number < png_ptr->num_rows)

+      return;

+   if (png_ptr->interlaced)

+   {

+      png_ptr->row_number = 0;

+      png_memset_check(png_ptr, png_ptr->prev_row, 0,

+         png_ptr->rowbytes + 1);

+      do

+      {

+         png_ptr->pass++;

+         if ((png_ptr->pass == 1 && png_ptr->width < 5) ||

+             (png_ptr->pass == 3 && png_ptr->width < 3) ||

+             (png_ptr->pass == 5 && png_ptr->width < 2))

+           png_ptr->pass++;

+         if (png_ptr->pass > 7)

+            png_ptr->pass--;

+         if (png_ptr->pass >= 7)

+            break;

+         png_ptr->iwidth = (png_ptr->width +

+            png_pass_inc[png_ptr->pass] - 1 -

+            png_pass_start[png_ptr->pass]) /

+            png_pass_inc[png_ptr->pass];

+         png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,

+            png_ptr->iwidth) + 1;

+         if (png_ptr->transformations & PNG_INTERLACE)

+            break;

+         png_ptr->num_rows = (png_ptr->height +

+            png_pass_yinc[png_ptr->pass] - 1 -

+            png_pass_ystart[png_ptr->pass]) /

+            png_pass_yinc[png_ptr->pass];

+      } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);

+   }

+}

+#if defined(PNG_READ_tEXt_SUPPORTED)

+void /* PRIVATE */

+png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32

+   length)

+{

+   if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))

+      {

+         png_error(png_ptr, "Out of place tEXt");

+         /* to quiet some compiler warnings */

+         if(info_ptr == NULL) return;

+      }

+#ifdef PNG_MAX_MALLOC_64K

+   png_ptr->skip_length = 0;  /* This may not be necessary */

+   if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */

+   {

+      png_warning(png_ptr, "tEXt chunk too large to fit in memory");

+      png_ptr->skip_length = length - (png_uint_32)65535L;

+      length = (png_uint_32)65535L;

+   }

+#endif

+   png_ptr->current_text = (png_charp)png_malloc(png_ptr,

+         (png_uint_32)(length+1));

+   png_ptr->current_text[length] = '\0';

+   png_ptr->current_text_ptr = png_ptr->current_text;

+   png_ptr->current_text_size = (png_size_t)length;

+   png_ptr->current_text_left = (png_size_t)length;

+   png_ptr->process_mode = PNG_READ_tEXt_MODE;

+}

+void /* PRIVATE */

+png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr->buffer_size && png_ptr->current_text_left)

+   {

+      png_size_t text_size;

+      if (png_ptr->buffer_size < png_ptr->current_text_left)

+         text_size = png_ptr->buffer_size;

+      else

+         text_size = png_ptr->current_text_left;

+      png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);

+      png_ptr->current_text_left -= text_size;

+      png_ptr->current_text_ptr += text_size;

+   }

+   if (!(png_ptr->current_text_left))

+   {

+      png_textp text_ptr;

+      png_charp text;

+      png_charp key;

+      int ret;

+      if (png_ptr->buffer_size < 4)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_push_crc_finish(png_ptr);

+#if defined(PNG_MAX_MALLOC_64K)

+      if (png_ptr->skip_length)

+         return;

+#endif

+      key = png_ptr->current_text;

+      for (text = key; *text; text++)

+         /* empty loop */ ;

+      if (text != key + png_ptr->current_text_size)

+         text++;

+      text_ptr = (png_textp)png_malloc(png_ptr,

+         (png_uint_32)png_sizeof(png_text));

+      text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;

+      text_ptr->key = key;

+#ifdef PNG_iTXt_SUPPORTED

+      text_ptr->lang = NULL;

+      text_ptr->lang_key = NULL;

+#endif

+      text_ptr->text = text;

+      ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);

+      png_free(png_ptr, key);

+      png_free(png_ptr, text_ptr);

+      png_ptr->current_text = NULL;

+      if (ret)

+        png_warning(png_ptr, "Insufficient memory to store text chunk.");

+   }

+}

+#endif

+#if defined(PNG_READ_zTXt_SUPPORTED)

+void /* PRIVATE */

+png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32

+   length)

+{

+   if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))

+      {

+         png_error(png_ptr, "Out of place zTXt");

+         /* to quiet some compiler warnings */

+         if(info_ptr == NULL) return;

+      }

+#ifdef PNG_MAX_MALLOC_64K

+   /* We can't handle zTXt chunks > 64K, since we don't have enough space

+    * to be able to store the uncompressed data.  Actually, the threshold

+    * is probably around 32K, but it isn't as definite as 64K is.

+    */

+   if (length > (png_uint_32)65535L)

+   {

+      png_warning(png_ptr, "zTXt chunk too large to fit in memory");

+      png_push_crc_skip(png_ptr, length);

+      return;

+   }

+#endif

+   png_ptr->current_text = (png_charp)png_malloc(png_ptr,

+       (png_uint_32)(length+1));

+   png_ptr->current_text[length] = '\0';

+   png_ptr->current_text_ptr = png_ptr->current_text;

+   png_ptr->current_text_size = (png_size_t)length;

+   png_ptr->current_text_left = (png_size_t)length;

+   png_ptr->process_mode = PNG_READ_zTXt_MODE;

+}

+void /* PRIVATE */

+png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr->buffer_size && png_ptr->current_text_left)

+   {

+      png_size_t text_size;

+      if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left)

+         text_size = png_ptr->buffer_size;

+      else

+         text_size = png_ptr->current_text_left;

+      png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);

+      png_ptr->current_text_left -= text_size;

+      png_ptr->current_text_ptr += text_size;

+   }

+   if (!(png_ptr->current_text_left))

+   {

+      png_textp text_ptr;

+      png_charp text;

+      png_charp key;

+      int ret;

+      png_size_t text_size, key_size;

+      if (png_ptr->buffer_size < 4)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_push_crc_finish(png_ptr);

+      key = png_ptr->current_text;

+      for (text = key; *text; text++)

+         /* empty loop */ ;

+      /* zTXt can't have zero text */

+      if (text == key + png_ptr->current_text_size)

+      {

+         png_ptr->current_text = NULL;

+         png_free(png_ptr, key);

+         return;

+      }

+      text++;

+      if (*text != PNG_TEXT_COMPRESSION_zTXt) /* check compression byte */

+      {

+         png_ptr->current_text = NULL;

+         png_free(png_ptr, key);

+         return;

+      }

+      text++;

+      png_ptr->zstream.next_in = (png_bytep )text;

+      png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size -

+         (text - key));

+      png_ptr->zstream.next_out = png_ptr->zbuf;

+      png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+      key_size = text - key;

+      text_size = 0;

+      text = NULL;

+      ret = Z_STREAM_END;

+      while (png_ptr->zstream.avail_in)

+      {

+         ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);

+         if (ret != Z_OK && ret != Z_STREAM_END)

+         {

+            inflateReset(&png_ptr->zstream);

+            png_ptr->zstream.avail_in = 0;

+            png_ptr->current_text = NULL;

+            png_free(png_ptr, key);

+            png_free(png_ptr, text);

+            return;

+         }

+         if (!(png_ptr->zstream.avail_out) || ret == Z_STREAM_END)

+         {

+            if (text == NULL)

+            {

+               text = (png_charp)png_malloc(png_ptr,

+                  (png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out

+                     + key_size + 1));

+               png_memcpy(text + key_size, png_ptr->zbuf,

+                  png_ptr->zbuf_size - png_ptr->zstream.avail_out);

+               png_memcpy(text, key, key_size);

+               text_size = key_size + png_ptr->zbuf_size -

+                  png_ptr->zstream.avail_out;

+               *(text + text_size) = '\0';

+            }

+            else

+            {

+               png_charp tmp;

+               tmp = text;

+               text = (png_charp)png_malloc(png_ptr, text_size +

+                  (png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out

+                   + 1));

+               png_memcpy(text, tmp, text_size);

+               png_free(png_ptr, tmp);

+               png_memcpy(text + text_size, png_ptr->zbuf,

+                  png_ptr->zbuf_size - png_ptr->zstream.avail_out);

+               text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;

+               *(text + text_size) = '\0';

+            }

+            if (ret != Z_STREAM_END)

+            {

+               png_ptr->zstream.next_out = png_ptr->zbuf;

+               png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+            }

+         }

+         else

+         {

+            break;

+         }

+         if (ret == Z_STREAM_END)

+            break;

+      }

+      inflateReset(&png_ptr->zstream);

+      png_ptr->zstream.avail_in = 0;

+      if (ret != Z_STREAM_END)

+      {

+         png_ptr->current_text = NULL;

+         png_free(png_ptr, key);

+         png_free(png_ptr, text);

+         return;

+      }

+      png_ptr->current_text = NULL;

+      png_free(png_ptr, key);

+      key = text;

+      text += key_size;

+      text_ptr = (png_textp)png_malloc(png_ptr,

+          (png_uint_32)png_sizeof(png_text));

+      text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt;

+      text_ptr->key = key;

+#ifdef PNG_iTXt_SUPPORTED

+      text_ptr->lang = NULL;

+      text_ptr->lang_key = NULL;

+#endif

+      text_ptr->text = text;

+      ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);

+      png_free(png_ptr, key);

+      png_free(png_ptr, text_ptr);

+      if (ret)

+        png_warning(png_ptr, "Insufficient memory to store text chunk.");

+   }

+}

+#endif

+#if defined(PNG_READ_iTXt_SUPPORTED)

+void /* PRIVATE */

+png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32

+   length)

+{

+   if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))

+      {

+         png_error(png_ptr, "Out of place iTXt");

+         /* to quiet some compiler warnings */

+         if(info_ptr == NULL) return;

+      }

+#ifdef PNG_MAX_MALLOC_64K

+   png_ptr->skip_length = 0;  /* This may not be necessary */

+   if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */

+   {

+      png_warning(png_ptr, "iTXt chunk too large to fit in memory");

+      png_ptr->skip_length = length - (png_uint_32)65535L;

+      length = (png_uint_32)65535L;

+   }

+#endif

+   png_ptr->current_text = (png_charp)png_malloc(png_ptr,

+         (png_uint_32)(length+1));

+   png_ptr->current_text[length] = '\0';

+   png_ptr->current_text_ptr = png_ptr->current_text;

+   png_ptr->current_text_size = (png_size_t)length;

+   png_ptr->current_text_left = (png_size_t)length;

+   png_ptr->process_mode = PNG_READ_iTXt_MODE;

+}

+void /* PRIVATE */

+png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr->buffer_size && png_ptr->current_text_left)

+   {

+      png_size_t text_size;

+      if (png_ptr->buffer_size < png_ptr->current_text_left)

+         text_size = png_ptr->buffer_size;

+      else

+         text_size = png_ptr->current_text_left;

+      png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);

+      png_ptr->current_text_left -= text_size;

+      png_ptr->current_text_ptr += text_size;

+   }

+   if (!(png_ptr->current_text_left))

+   {

+      png_textp text_ptr;

+      png_charp key;

+      int comp_flag;

+      png_charp lang;

+      png_charp lang_key;

+      png_charp text;

+      int ret;

+      if (png_ptr->buffer_size < 4)

+      {

+         png_push_save_buffer(png_ptr);

+         return;

+      }

+      png_push_crc_finish(png_ptr);

+#if defined(PNG_MAX_MALLOC_64K)

+      if (png_ptr->skip_length)

+         return;

+#endif

+      key = png_ptr->current_text;

+      for (lang = key; *lang; lang++)

+         /* empty loop */ ;

+      if (lang != key + png_ptr->current_text_size)

+         lang++;

+      comp_flag = *lang++;

+      lang++;     /* skip comp_type, always zero */

+      for (lang_key = lang; *lang_key; lang_key++)

+         /* empty loop */ ;

+      lang_key++;        /* skip NUL separator */

+      for (text = lang_key; *text; text++)

+         /* empty loop */ ;

+      if (text != key + png_ptr->current_text_size)

+         text++;

+      text_ptr = (png_textp)png_malloc(png_ptr,

+         (png_uint_32)png_sizeof(png_text));

+      text_ptr->compression = comp_flag + 2;

+      text_ptr->key = key;

+      text_ptr->lang = lang;

+      text_ptr->lang_key = lang_key;

+      text_ptr->text = text;

+      text_ptr->text_length = 0;

+      text_ptr->itxt_length = png_strlen(text);

+      ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);

+      png_ptr->current_text = NULL;

+      png_free(png_ptr, text_ptr);

+      if (ret)

+        png_warning(png_ptr, "Insufficient memory to store iTXt chunk.");

+   }

+}

+#endif

+/* This function is called when we haven't found a handler for this

+ * chunk.  If there isn't a problem with the chunk itself (ie a bad chunk

+ * name or a critical chunk), the chunk is (currently) silently ignored.

+ */

+void /* PRIVATE */

+png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32

+   length)

+{

+   png_uint_32 skip=0;

+   png_check_chunk_name(png_ptr, png_ptr->chunk_name);

+   if (!(png_ptr->chunk_name[0] & 0x20))

+   {

+#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)

+      if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=

+           PNG_HANDLE_CHUNK_ALWAYS

+#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)

+           && png_ptr->read_user_chunk_fn == NULL

+#endif

+         )

+#endif

+         png_chunk_error(png_ptr, "unknown critical chunk");

+      /* to quiet compiler warnings about unused info_ptr */

+      if (info_ptr == NULL)

+         return;

+   }

+#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)

+   if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)

+   {

+       png_unknown_chunk chunk;

+#ifdef PNG_MAX_MALLOC_64K

+       if (length > (png_uint_32)65535L)

+       {

+           png_warning(png_ptr, "unknown chunk too large to fit in memory");

+           skip = length - (png_uint_32)65535L;

+           length = (png_uint_32)65535L;

+       }

+#endif

+       png_strcpy((png_charp)chunk.name, (png_charp)png_ptr->chunk_name);

+       chunk.data = (png_bytep)png_malloc(png_ptr, length);

+       png_crc_read(png_ptr, chunk.data, length);

+       chunk.size = length;

+#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)

+       if(png_ptr->read_user_chunk_fn != NULL)

+       {

+          /* callback to user unknown chunk handler */

+          if ((*(png_ptr->read_user_chunk_fn)) (png_ptr, &chunk) <= 0)

+          {

+             if (!(png_ptr->chunk_name[0] & 0x20))

+                if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=

+                     PNG_HANDLE_CHUNK_ALWAYS)

+                   png_chunk_error(png_ptr, "unknown critical chunk");

+          }

+             png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1);

+       }

+       else

+#endif

+          png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1);

+       png_free(png_ptr, chunk.data);

+   }

+   else

+#endif

+      skip=length;

+   png_push_crc_skip(png_ptr, skip);

+}

+void /* PRIVATE */

+png_push_have_info(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr->info_fn != NULL)

+      (*(png_ptr->info_fn))(png_ptr, info_ptr);

+}

+void /* PRIVATE */

+png_push_have_end(png_structp png_ptr, png_infop info_ptr)

+{

+   if (png_ptr->end_fn != NULL)

+      (*(png_ptr->end_fn))(png_ptr, info_ptr);

+}

+void /* PRIVATE */

+png_push_have_row(png_structp png_ptr, png_bytep row)

+{

+   if (png_ptr->row_fn != NULL)

+      (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,

+         (int)png_ptr->pass);

+}

+void PNGAPI

+png_progressive_combine_row (png_structp png_ptr,

+   png_bytep old_row, png_bytep new_row)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   const int FARDATA png_pass_dsp_mask[7] =

+      {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};

+#endif

+   if (new_row != NULL)    /* new_row must == png_ptr->row_buf here. */

+      png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]);

+}

+void PNGAPI

+png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr,

+   png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,

+   png_progressive_end_ptr end_fn)

+{

+   png_ptr->info_fn = info_fn;

+   png_ptr->row_fn = row_fn;

+   png_ptr->end_fn = end_fn;

+   png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer);

+}

+png_voidp PNGAPI

+png_get_progressive_ptr(png_structp png_ptr)

+{

+   return png_ptr->io_ptr;

+}

+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

--- /dev/null

+++ b/src/gfx/libpng/pngread.c

@@ -1,0 +1,1456 @@

+/* pngread.c - read a PNG file

+ *

+ * libpng 1.2.8 - December 3, 2004

+ * For conditions of distribution and use, see copyright notice in png.h

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

+ *

+ * This file contains routines that an application calls directly to

+ * read a PNG file or stream.

+ */

+#define PNG_INTERNAL

+#include "png.h"

+/* Create a PNG structure for reading, and allocate any memory needed. */

+png_structp PNGAPI

+png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr,

+   png_error_ptr error_fn, png_error_ptr warn_fn)

+{

+#ifdef PNG_USER_MEM_SUPPORTED

+   return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn,

+      warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL));

+}

+/* Alternate create PNG structure for reading, and allocate any memory needed. */

+png_structp PNGAPI

+png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,

+   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

+   png_malloc_ptr malloc_fn, png_free_ptr free_fn)

+{

+#endif /* PNG_USER_MEM_SUPPORTED */

+   png_structp png_ptr;

+#ifdef PNG_SETJMP_SUPPORTED

+#ifdef USE_FAR_KEYWORD

+   jmp_buf jmpbuf;

+#endif

+#endif

+   int i;

+   png_debug(1, "in png_create_read_struct\n");

+#ifdef PNG_USER_MEM_SUPPORTED

+   png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,

+      (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);

+#else

+   png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);

+#endif

+   if (png_ptr == NULL)

+      return (NULL);

+#if !defined(PNG_1_0_X)

+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED

+   png_init_mmx_flags(png_ptr);   /* 1.2.0 addition */

+#endif

+#endif /* PNG_1_0_X */

+   /* added at libpng-1.2.6 */

+#ifdef PNG_SET_USER_LIMITS_SUPPORTED

+   png_ptr->user_width_max=PNG_USER_WIDTH_MAX;

+   png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;

+#endif

+#ifdef PNG_SETJMP_SUPPORTED

+#ifdef USE_FAR_KEYWORD

+   if (setjmp(jmpbuf))

+#else

+   if (setjmp(png_ptr->jmpbuf))

+#endif

+   {

+      png_free(png_ptr, png_ptr->zbuf);

+      png_ptr->zbuf=NULL;

+#ifdef PNG_USER_MEM_SUPPORTED

+      png_destroy_struct_2((png_voidp)png_ptr,

+         (png_free_ptr)free_fn, (png_voidp)mem_ptr);

+#else

+      png_destroy_struct((png_voidp)png_ptr);

+#endif

+      return (NULL);

+   }

+#ifdef USE_FAR_KEYWORD

+   png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf));

+#endif

+#endif

+#ifdef PNG_USER_MEM_SUPPORTED

+   png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);

+#endif

+   png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);

+   i=0;

+   do

+   {

+     if(user_png_ver[i] != png_libpng_ver[i])

+        png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;

+   } while (png_libpng_ver[i++]);

+   if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)

+   {

+     /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so

+      * we must recompile any applications that use any older library version.

+      * For versions after libpng 1.0, we will be compatible, so we need

+      * only check the first digit.

+      */

+     if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||

+         (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||

+         (user_png_ver[0] == '0' && user_png_ver[2] < '9'))

+     {

+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)

+        char msg[80];

+        if (user_png_ver)

+        {

+          sprintf(msg, "Application was compiled with png.h from libpng-%.20s",

+             user_png_ver);

+          png_warning(png_ptr, msg);

+        }

+        sprintf(msg, "Application  is  running with png.c from libpng-%.20s",

+           png_libpng_ver);

+        png_warning(png_ptr, msg);

+#endif

+#ifdef PNG_ERROR_NUMBERS_SUPPORTED

+        png_ptr->flags=0;

+#endif

+        png_error(png_ptr,

+           "Incompatible libpng version in application and library");

+     }

+   }

+   /* initialize zbuf - compression buffer */

+   png_ptr->zbuf_size = PNG_ZBUF_SIZE;

+   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,

+     (png_uint_32)png_ptr->zbuf_size);

+   png_ptr->zstream.zalloc = png_zalloc;

+   png_ptr->zstream.zfree = png_zfree;

+   png_ptr->zstream.opaque = (voidpf)png_ptr;

+   switch (inflateInit(&png_ptr->zstream))

+   {

+     case Z_OK: /* Do nothing */ break;

+     case Z_MEM_ERROR:

+     case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); break;

+     case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error"); break;

+     default: png_error(png_ptr, "Unknown zlib error");

+   }

+   png_ptr->zstream.next_out = png_ptr->zbuf;

+   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+   png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL);

+#ifdef PNG_SETJMP_SUPPORTED

+/* Applications that neglect to set up their own setjmp() and then encounter

+   a png_error() will longjmp here.  Since the jmpbuf is then meaningless we

+   abort instead of returning. */

+#ifdef USE_FAR_KEYWORD

+   if (setjmp(jmpbuf))

+      PNG_ABORT();

+   png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf));

+#else

+   if (setjmp(png_ptr->jmpbuf))

+      PNG_ABORT();

+#endif

+#endif

+   return (png_ptr);

+}

+/* Initialize PNG structure for reading, and allocate any memory needed.

+   This interface is deprecated in favour of the png_create_read_struct(),

+   and it will eventually disappear. */

+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)

+#undef png_read_init

+void PNGAPI

+png_read_init(png_structp png_ptr)

+{

+   /* We only come here via pre-1.0.7-compiled applications */

+   png_read_init_2(png_ptr, "1.0.6 or earlier", 0, 0);

+}

+#endif

+void PNGAPI

+png_read_init_2(png_structp png_ptr, png_const_charp user_png_ver,

+   png_size_t png_struct_size, png_size_t png_info_size)

+{

+   /* We only come here via pre-1.0.12-compiled applications */

+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)

+   if(png_sizeof(png_struct) > png_struct_size ||

+      png_sizeof(png_info) > png_info_size)

+   {

+      char msg[80];

+      png_ptr->warning_fn=NULL;

+      if (user_png_ver)

+      {

+        sprintf(msg, "Application was compiled with png.h from libpng-%.20s",

+           user_png_ver);

+        png_warning(png_ptr, msg);

+      }

+      sprintf(msg, "Application  is  running with png.c from libpng-%.20s",

+         png_libpng_ver);

+      png_warning(png_ptr, msg);

+   }

+#endif

+   if(png_sizeof(png_struct) > png_struct_size)

+     {

+       png_ptr->error_fn=NULL;

+#ifdef PNG_ERROR_NUMBERS_SUPPORTED

+       png_ptr->flags=0;

+#endif

+       png_error(png_ptr,

+       "The png struct allocated by the application for reading is too small.");

+     }

+   if(png_sizeof(png_info) > png_info_size)

+     {

+       png_ptr->error_fn=NULL;

+#ifdef PNG_ERROR_NUMBERS_SUPPORTED

+       png_ptr->flags=0;

+#endif

+       png_error(png_ptr,

+         "The info struct allocated by application for reading is too small.");

+     }

+   png_read_init_3(&png_ptr, user_png_ver, png_struct_size);

+}

+void PNGAPI

+png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,

+   png_size_t png_struct_size)

+{

+#ifdef PNG_SETJMP_SUPPORTED

+   jmp_buf tmp_jmp;  /* to save current jump buffer */

+#endif

+   int i=0;

+   png_structp png_ptr=*ptr_ptr;

+   do

+   {

+     if(user_png_ver[i] != png_libpng_ver[i])

+     {

+#ifdef PNG_LEGACY_SUPPORTED

+       png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;

+#else

+       png_ptr->warning_fn=NULL;

+       png_warning(png_ptr,

+        "Application uses deprecated png_read_init() and should be recompiled.");

+       break;

+#endif

+     }

+   } while (png_libpng_ver[i++]);

+   png_debug(1, "in png_read_init_3\n");

+#ifdef PNG_SETJMP_SUPPORTED

+   /* save jump buffer and error functions */

+   png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof (jmp_buf));

+#endif

+   if(png_sizeof(png_struct) > png_struct_size)

+     {

+       png_destroy_struct(png_ptr);

+       *ptr_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);

+       png_ptr = *ptr_ptr;

+     }

+   /* reset all variables to 0 */

+   png_memset(png_ptr, 0, png_sizeof (png_struct));

+#ifdef PNG_SETJMP_SUPPORTED

+   /* restore jump buffer */

+   png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof (jmp_buf));

+#endif

+   /* added at libpng-1.2.6 */

+#ifdef PNG_SET_USER_LIMITS_SUPPORTED

+   png_ptr->user_width_max=PNG_USER_WIDTH_MAX;

+   png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;

+#endif

+   /* initialize zbuf - compression buffer */

+   png_ptr->zbuf_size = PNG_ZBUF_SIZE;

+   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,

+     (png_uint_32)png_ptr->zbuf_size);

+   png_ptr->zstream.zalloc = png_zalloc;

+   png_ptr->zstream.zfree = png_zfree;

+   png_ptr->zstream.opaque = (voidpf)png_ptr;

+   switch (inflateInit(&png_ptr->zstream))

+   {

+     case Z_OK: /* Do nothing */ break;

+     case Z_MEM_ERROR:

+     case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory"); break;

+     case Z_VERSION_ERROR: png_error(png_ptr, "zlib version"); break;

+     default: png_error(png_ptr, "Unknown zlib error");

+   }

+   png_ptr->zstream.next_out = png_ptr->zbuf;

+   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+   png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL);

+}

+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

+/* Read the information before the actual image data.  This has been

+ * changed in v0.90 to allow reading a file that already has the magic

+ * bytes read from the stream.  You can tell libpng how many bytes have

+ * been read from the beginning of the stream (up to the maximum of 8)

+ * via png_set_sig_bytes(), and we will only check the remaining bytes

+ * here.  The application can then have access to the signature bytes we

+ * read if it is determined that this isn't a valid PNG file.

+ */

+void PNGAPI

+png_read_info(png_structp png_ptr, png_infop info_ptr)

+{

+   png_debug(1, "in png_read_info\n");

+   /* If we haven't checked all of the PNG signature bytes, do so now. */

+   if (png_ptr->sig_bytes < 8)

+   {

+      png_size_t num_checked = png_ptr->sig_bytes,

+                 num_to_check = 8 - num_checked;

+      png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check);

+      png_ptr->sig_bytes = 8;

+      if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))

+      {

+         if (num_checked < 4 &&

+             png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))

+            png_error(png_ptr, "Not a PNG file");

+         else

+            png_error(png_ptr, "PNG file corrupted by ASCII conversion");

+      }

+      if (num_checked < 3)

+         png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;

+   }

+   for(;;)

+   {

+#ifdef PNG_USE_LOCAL_ARRAYS

+      PNG_IHDR;

+      PNG_IDAT;

+      PNG_IEND;

+      PNG_PLTE;

+#if defined(PNG_READ_bKGD_SUPPORTED)

+      PNG_bKGD;

+#endif

+#if defined(PNG_READ_cHRM_SUPPORTED)

+      PNG_cHRM;

+#endif

+#if defined(PNG_READ_gAMA_SUPPORTED)

+      PNG_gAMA;

+#endif

+#if defined(PNG_READ_hIST_SUPPORTED)

+      PNG_hIST;

+#endif

+#if defined(PNG_READ_iCCP_SUPPORTED)

+      PNG_iCCP;

+#endif

+#if defined(PNG_READ_iTXt_SUPPORTED)

+      PNG_iTXt;

+#endif

+#if defined(PNG_READ_oFFs_SUPPORTED)

+      PNG_oFFs;

+#endif

+#if defined(PNG_READ_pCAL_SUPPORTED)

+      PNG_pCAL;

+#endif

+#if defined(PNG_READ_pHYs_SUPPORTED)

+      PNG_pHYs;

+#endif

+#if defined(PNG_READ_sBIT_SUPPORTED)

+      PNG_sBIT;

+#endif

+#if defined(PNG_READ_sCAL_SUPPORTED)

+      PNG_sCAL;

+#endif

+#if defined(PNG_READ_sPLT_SUPPORTED)

+      PNG_sPLT;

+#endif

+#if defined(PNG_READ_sRGB_SUPPORTED)

+      PNG_sRGB;

+#endif

+#if defined(PNG_READ_tEXt_SUPPORTED)

+      PNG_tEXt;

+#endif

+#if defined(PNG_READ_tIME_SUPPORTED)

+      PNG_tIME;

+#endif

+#if defined(PNG_READ_tRNS_SUPPORTED)

+      PNG_tRNS;

+#endif

+#if defined(PNG_READ_zTXt_SUPPORTED)

+      PNG_zTXt;

+#endif

+#endif /* PNG_USE_LOCAL_ARRAYS */

+      png_byte chunk_length[4];

+      png_uint_32 length;

+      png_read_data(png_ptr, chunk_length, 4);

+      length = png_get_uint_31(png_ptr,chunk_length);

+      png_reset_crc(png_ptr);

+      png_crc_read(png_ptr, png_ptr->chunk_name, 4);

+      png_debug2(0, "Reading %s chunk, length=%lu.\n", png_ptr->chunk_name,

+         length);

+      /* This should be a binary subdivision search or a hash for

+       * matching the chunk name rather than a linear search.

+       */

+      if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))

+         png_handle_IHDR(png_ptr, info_ptr, length);

+      else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))

+         png_handle_IEND(png_ptr, info_ptr, length);

+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

+      else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))

+      {

+         if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

+            png_ptr->mode |= PNG_HAVE_IDAT;

+         png_handle_unknown(png_ptr, info_ptr, length);

+         if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))

+            png_ptr->mode |= PNG_HAVE_PLTE;

+         else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

+         {

+            if (!(png_ptr->mode & PNG_HAVE_IHDR))

+               png_error(png_ptr, "Missing IHDR before IDAT");

+            else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&

+                     !(png_ptr->mode & PNG_HAVE_PLTE))

+               png_error(png_ptr, "Missing PLTE before IDAT");

+            break;

+         }

+      }

+#endif

+      else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))

+         png_handle_PLTE(png_ptr, info_ptr, length);

+      else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

+      {

+         if (!(png_ptr->mode & PNG_HAVE_IHDR))

+            png_error(png_ptr, "Missing IHDR before IDAT");

+         else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&

+                  !(png_ptr->mode & PNG_HAVE_PLTE))

+            png_error(png_ptr, "Missing PLTE before IDAT");

+         png_ptr->idat_size = length;

+         png_ptr->mode |= PNG_HAVE_IDAT;

+         break;

+      }

+#if defined(PNG_READ_bKGD_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))

+         png_handle_bKGD(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_cHRM_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))

+         png_handle_cHRM(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_gAMA_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))

+         png_handle_gAMA(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_hIST_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))

+         png_handle_hIST(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_oFFs_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))

+         png_handle_oFFs(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_pCAL_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))

+         png_handle_pCAL(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_sCAL_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))

+         png_handle_sCAL(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_pHYs_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))

+         png_handle_pHYs(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_sBIT_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))

+         png_handle_sBIT(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_sRGB_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))

+         png_handle_sRGB(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_iCCP_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))

+         png_handle_iCCP(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_sPLT_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))

+         png_handle_sPLT(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_tEXt_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))

+         png_handle_tEXt(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_tIME_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))

+         png_handle_tIME(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_tRNS_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))

+         png_handle_tRNS(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_zTXt_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))

+         png_handle_zTXt(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_iTXt_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))

+         png_handle_iTXt(png_ptr, info_ptr, length);

+#endif

+      else

+         png_handle_unknown(png_ptr, info_ptr, length);

+   }

+}

+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */

+/* optional call to update the users info_ptr structure */

+void PNGAPI

+png_read_update_info(png_structp png_ptr, png_infop info_ptr)

+{

+   png_debug(1, "in png_read_update_info\n");

+   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))

+      png_read_start_row(png_ptr);

+   else

+      png_warning(png_ptr,

+      "Ignoring extra png_read_update_info() call; row buffer not reallocated");

+   png_read_transform_info(png_ptr, info_ptr);

+}

+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

+/* Initialize palette, background, etc, after transformations

+ * are set, but before any reading takes place.  This allows

+ * the user to obtain a gamma-corrected palette, for example.

+ * If the user doesn't call this, we will do it ourselves.

+ */

+void PNGAPI

+png_start_read_image(png_structp png_ptr)

+{

+   png_debug(1, "in png_start_read_image\n");

+   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))

+      png_read_start_row(png_ptr);

+}

+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */

+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

+void PNGAPI

+png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_IDAT;

+   const int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};

+   const int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};

+#endif

+   int ret;

+   png_debug2(1, "in png_read_row (row %lu, pass %d)\n",

+      png_ptr->row_number, png_ptr->pass);

+   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))

+      png_read_start_row(png_ptr);

+   if (png_ptr->row_number == 0 && png_ptr->pass == 0)

+   {

+   /* check for transforms that have been set but were defined out */

+#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)

+   if (png_ptr->transformations & PNG_INVERT_MONO)

+      png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined.");

+#endif

+#if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED)

+   if (png_ptr->transformations & PNG_FILLER)

+      png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined.");

+#endif

+#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && !defined(PNG_READ_PACKSWAP_SUPPORTED)

+   if (png_ptr->transformations & PNG_PACKSWAP)

+      png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined.");

+#endif

+#if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED)

+   if (png_ptr->transformations & PNG_PACK)

+      png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined.");

+#endif

+#if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED)

+   if (png_ptr->transformations & PNG_SHIFT)

+      png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined.");

+#endif

+#if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED)

+   if (png_ptr->transformations & PNG_BGR)

+      png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined.");

+#endif

+#if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED)

+   if (png_ptr->transformations & PNG_SWAP_BYTES)

+      png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined.");

+#endif

+   }

+#if defined(PNG_READ_INTERLACING_SUPPORTED)

+   /* if interlaced and we do not need a new row, combine row and return */

+   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))

+   {

+      switch (png_ptr->pass)

+      {

+         case 0:

+            if (png_ptr->row_number & 0x07)

+            {

+               if (dsp_row != NULL)

+                  png_combine_row(png_ptr, dsp_row,

+                     png_pass_dsp_mask[png_ptr->pass]);

+               png_read_finish_row(png_ptr);

+               return;

+            }

+            break;

+         case 1:

+            if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)

+            {

+               if (dsp_row != NULL)

+                  png_combine_row(png_ptr, dsp_row,

+                     png_pass_dsp_mask[png_ptr->pass]);

+               png_read_finish_row(png_ptr);

+               return;

+            }

+            break;

+         case 2:

+            if ((png_ptr->row_number & 0x07) != 4)

+            {

+               if (dsp_row != NULL && (png_ptr->row_number & 4))

+                  png_combine_row(png_ptr, dsp_row,

+                     png_pass_dsp_mask[png_ptr->pass]);

+               png_read_finish_row(png_ptr);

+               return;

+            }

+            break;

+         case 3:

+            if ((png_ptr->row_number & 3) || png_ptr->width < 3)

+            {

+               if (dsp_row != NULL)

+                  png_combine_row(png_ptr, dsp_row,

+                     png_pass_dsp_mask[png_ptr->pass]);

+               png_read_finish_row(png_ptr);

+               return;

+            }

+            break;

+         case 4:

+            if ((png_ptr->row_number & 3) != 2)

+            {

+               if (dsp_row != NULL && (png_ptr->row_number & 2))

+                  png_combine_row(png_ptr, dsp_row,

+                     png_pass_dsp_mask[png_ptr->pass]);

+               png_read_finish_row(png_ptr);

+               return;

+            }

+            break;

+         case 5:

+            if ((png_ptr->row_number & 1) || png_ptr->width < 2)

+            {

+               if (dsp_row != NULL)

+                  png_combine_row(png_ptr, dsp_row,

+                     png_pass_dsp_mask[png_ptr->pass]);

+               png_read_finish_row(png_ptr);

+               return;

+            }

+            break;

+         case 6:

+            if (!(png_ptr->row_number & 1))

+            {

+               png_read_finish_row(png_ptr);

+               return;

+            }

+            break;

+      }

+   }

+#endif

+   if (!(png_ptr->mode & PNG_HAVE_IDAT))

+      png_error(png_ptr, "Invalid attempt to read row data");

+   png_ptr->zstream.next_out = png_ptr->row_buf;

+   png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;

+   do

+   {

+      if (!(png_ptr->zstream.avail_in))

+      {

+         while (!png_ptr->idat_size)

+         {

+            png_byte chunk_length[4];

+            png_crc_finish(png_ptr, 0);

+            png_read_data(png_ptr, chunk_length, 4);

+            png_ptr->idat_size = png_get_uint_31(png_ptr,chunk_length);

+            png_reset_crc(png_ptr);

+            png_crc_read(png_ptr, png_ptr->chunk_name, 4);

+            if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

+               png_error(png_ptr, "Not enough image data");

+         }

+         png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;

+         png_ptr->zstream.next_in = png_ptr->zbuf;

+         if (png_ptr->zbuf_size > png_ptr->idat_size)

+            png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;

+         png_crc_read(png_ptr, png_ptr->zbuf,

+            (png_size_t)png_ptr->zstream.avail_in);

+         png_ptr->idat_size -= png_ptr->zstream.avail_in;

+      }

+      ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);

+      if (ret == Z_STREAM_END)

+      {

+         if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in ||

+            png_ptr->idat_size)

+            png_error(png_ptr, "Extra compressed data");

+         png_ptr->mode |= PNG_AFTER_IDAT;

+         png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

+         break;

+      }

+      if (ret != Z_OK)

+         png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :

+                   "Decompression error");

+   } while (png_ptr->zstream.avail_out);

+   png_ptr->row_info.color_type = png_ptr->color_type;

+   png_ptr->row_info.width = png_ptr->iwidth;

+   png_ptr->row_info.channels = png_ptr->channels;

+   png_ptr->row_info.bit_depth = png_ptr->bit_depth;

+   png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;

+   png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,

+       png_ptr->row_info.width);

+   if(png_ptr->row_buf[0])

+   png_read_filter_row(png_ptr, &(png_ptr->row_info),

+      png_ptr->row_buf + 1, png_ptr->prev_row + 1,

+      (int)(png_ptr->row_buf[0]));

+   png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,

+      png_ptr->rowbytes + 1);

+#if defined(PNG_MNG_FEATURES_SUPPORTED)

+   if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&

+      (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))

+   {

+      /* Intrapixel differencing */

+      png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);

+   }

+#endif

+   if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))

+      png_do_read_transformations(png_ptr);

+#if defined(PNG_READ_INTERLACING_SUPPORTED)

+   /* blow up interlaced rows to full size */

+   if (png_ptr->interlaced &&

+      (png_ptr->transformations & PNG_INTERLACE))

+   {

+      if (png_ptr->pass < 6)

+/*       old interface (pre-1.0.9):

+         png_do_read_interlace(&(png_ptr->row_info),

+            png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);

+ */

+         png_do_read_interlace(png_ptr);

+      if (dsp_row != NULL)

+         png_combine_row(png_ptr, dsp_row,

+            png_pass_dsp_mask[png_ptr->pass]);

+      if (row != NULL)

+         png_combine_row(png_ptr, row,

+            png_pass_mask[png_ptr->pass]);

+   }

+   else

+#endif

+   {

+      if (row != NULL)

+         png_combine_row(png_ptr, row, 0xff);

+      if (dsp_row != NULL)

+         png_combine_row(png_ptr, dsp_row, 0xff);

+   }

+   png_read_finish_row(png_ptr);

+   if (png_ptr->read_row_fn != NULL)

+      (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);

+}

+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */

+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

+/* Read one or more rows of image data.  If the image is interlaced,

+ * and png_set_interlace_handling() has been called, the rows need to

+ * contain the contents of the rows from the previous pass.  If the

+ * image has alpha or transparency, and png_handle_alpha()[*] has been

+ * called, the rows contents must be initialized to the contents of the

+ * screen.

+ *

+ * "row" holds the actual image, and pixels are placed in it

+ * as they arrive.  If the image is displayed after each pass, it will

+ * appear to "sparkle" in.  "display_row" can be used to display a

+ * "chunky" progressive image, with finer detail added as it becomes

+ * available.  If you do not want this "chunky" display, you may pass

+ * NULL for display_row.  If you do not want the sparkle display, and

+ * you have not called png_handle_alpha(), you may pass NULL for rows.

+ * If you have called png_handle_alpha(), and the image has either an

+ * alpha channel or a transparency chunk, you must provide a buffer for

+ * rows.  In this case, you do not have to provide a display_row buffer

+ * also, but you may.  If the image is not interlaced, or if you have

+ * not called png_set_interlace_handling(), the display_row buffer will

+ * be ignored, so pass NULL to it.

+ *

+ * [*] png_handle_alpha() does not exist yet, as of libpng version 1.2.8

+ */

+void PNGAPI

+png_read_rows(png_structp png_ptr, png_bytepp row,

+   png_bytepp display_row, png_uint_32 num_rows)

+{

+   png_uint_32 i;

+   png_bytepp rp;

+   png_bytepp dp;

+   png_debug(1, "in png_read_rows\n");

+   rp = row;

+   dp = display_row;

+   if (rp != NULL && dp != NULL)

+      for (i = 0; i < num_rows; i++)

+      {

+         png_bytep rptr = *rp++;

+         png_bytep dptr = *dp++;

+         png_read_row(png_ptr, rptr, dptr);

+      }

+   else if(rp != NULL)

+      for (i = 0; i < num_rows; i++)

+      {

+         png_bytep rptr = *rp;

+         png_read_row(png_ptr, rptr, png_bytep_NULL);

+         rp++;

+      }

+   else if(dp != NULL)

+      for (i = 0; i < num_rows; i++)

+      {

+         png_bytep dptr = *dp;

+         png_read_row(png_ptr, png_bytep_NULL, dptr);

+         dp++;

+      }

+}

+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */

+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

+/* Read the entire image.  If the image has an alpha channel or a tRNS

+ * chunk, and you have called png_handle_alpha()[*], you will need to

+ * initialize the image to the current image that PNG will be overlaying.

+ * We set the num_rows again here, in case it was incorrectly set in

+ * png_read_start_row() by a call to png_read_update_info() or

+ * png_start_read_image() if png_set_interlace_handling() wasn't called

+ * prior to either of these functions like it should have been.  You can

+ * only call this function once.  If you desire to have an image for

+ * each pass of a interlaced image, use png_read_rows() instead.

+ *

+ * [*] png_handle_alpha() does not exist yet, as of libpng version 1.2.8

+ */

+void PNGAPI

+png_read_image(png_structp png_ptr, png_bytepp image)

+{

+   png_uint_32 i,image_height;

+   int pass, j;

+   png_bytepp rp;

+   png_debug(1, "in png_read_image\n");

+#ifdef PNG_READ_INTERLACING_SUPPORTED

+   pass = png_set_interlace_handling(png_ptr);

+#else

+   if (png_ptr->interlaced)

+      png_error(png_ptr,

+        "Cannot read interlaced image -- interlace handler disabled.");

+   pass = 1;

+#endif

+   image_height=png_ptr->height;

+   png_ptr->num_rows = image_height; /* Make sure this is set correctly */

+   for (j = 0; j < pass; j++)

+   {

+      rp = image;

+      for (i = 0; i < image_height; i++)

+      {

+         png_read_row(png_ptr, *rp, png_bytep_NULL);

+         rp++;

+      }

+   }

+}

+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */

+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

+/* Read the end of the PNG file.  Will not read past the end of the

+ * file, will verify the end is accurate, and will read any comments

+ * or time information at the end of the file, if info is not NULL.

+ */

+void PNGAPI

+png_read_end(png_structp png_ptr, png_infop info_ptr)

+{

+   png_byte chunk_length[4];

+   png_uint_32 length;

+   png_debug(1, "in png_read_end\n");

+   png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */

+   do

+   {

+#ifdef PNG_USE_LOCAL_ARRAYS

+      PNG_IHDR;

+      PNG_IDAT;

+      PNG_IEND;

+      PNG_PLTE;

+#if defined(PNG_READ_bKGD_SUPPORTED)

+      PNG_bKGD;

+#endif

+#if defined(PNG_READ_cHRM_SUPPORTED)

+      PNG_cHRM;

+#endif

+#if defined(PNG_READ_gAMA_SUPPORTED)

+      PNG_gAMA;

+#endif

+#if defined(PNG_READ_hIST_SUPPORTED)

+      PNG_hIST;

+#endif

+#if defined(PNG_READ_iCCP_SUPPORTED)

+      PNG_iCCP;

+#endif

+#if defined(PNG_READ_iTXt_SUPPORTED)

+      PNG_iTXt;

+#endif

+#if defined(PNG_READ_oFFs_SUPPORTED)

+      PNG_oFFs;

+#endif

+#if defined(PNG_READ_pCAL_SUPPORTED)

+      PNG_pCAL;

+#endif

+#if defined(PNG_READ_pHYs_SUPPORTED)

+      PNG_pHYs;

+#endif

+#if defined(PNG_READ_sBIT_SUPPORTED)

+      PNG_sBIT;

+#endif

+#if defined(PNG_READ_sCAL_SUPPORTED)

+      PNG_sCAL;

+#endif

+#if defined(PNG_READ_sPLT_SUPPORTED)

+      PNG_sPLT;

+#endif

+#if defined(PNG_READ_sRGB_SUPPORTED)

+      PNG_sRGB;

+#endif

+#if defined(PNG_READ_tEXt_SUPPORTED)

+      PNG_tEXt;

+#endif

+#if defined(PNG_READ_tIME_SUPPORTED)

+      PNG_tIME;

+#endif

+#if defined(PNG_READ_tRNS_SUPPORTED)

+      PNG_tRNS;

+#endif

+#if defined(PNG_READ_zTXt_SUPPORTED)

+      PNG_zTXt;

+#endif

+#endif /* PNG_USE_LOCAL_ARRAYS */

+      png_read_data(png_ptr, chunk_length, 4);

+      length = png_get_uint_31(png_ptr,chunk_length);

+      png_reset_crc(png_ptr);

+      png_crc_read(png_ptr, png_ptr->chunk_name, 4);

+      png_debug1(0, "Reading %s chunk.\n", png_ptr->chunk_name);

+      if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))

+         png_handle_IHDR(png_ptr, info_ptr, length);

+      else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))

+         png_handle_IEND(png_ptr, info_ptr, length);

+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

+      else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))

+      {

+         if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

+         {

+            if (length > 0 || png_ptr->mode & PNG_AFTER_IDAT)

+               png_error(png_ptr, "Too many IDAT's found");

+         }

+         else

+            png_ptr->mode |= PNG_AFTER_IDAT;

+         png_handle_unknown(png_ptr, info_ptr, length);

+         if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))

+            png_ptr->mode |= PNG_HAVE_PLTE;

+      }

+#endif

+      else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))

+      {

+         /* Zero length IDATs are legal after the last IDAT has been

+          * read, but not after other chunks have been read.

+          */

+         if (length > 0 || png_ptr->mode & PNG_AFTER_IDAT)

+            png_error(png_ptr, "Too many IDAT's found");

+         png_crc_finish(png_ptr, length);

+      }

+      else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))

+         png_handle_PLTE(png_ptr, info_ptr, length);

+#if defined(PNG_READ_bKGD_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))

+         png_handle_bKGD(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_cHRM_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))

+         png_handle_cHRM(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_gAMA_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))

+         png_handle_gAMA(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_hIST_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))

+         png_handle_hIST(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_oFFs_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))

+         png_handle_oFFs(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_pCAL_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))

+         png_handle_pCAL(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_sCAL_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))

+         png_handle_sCAL(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_pHYs_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))

+         png_handle_pHYs(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_sBIT_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))

+         png_handle_sBIT(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_sRGB_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))

+         png_handle_sRGB(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_iCCP_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))

+         png_handle_iCCP(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_sPLT_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))

+         png_handle_sPLT(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_tEXt_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))

+         png_handle_tEXt(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_tIME_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))

+         png_handle_tIME(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_tRNS_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))

+         png_handle_tRNS(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_zTXt_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))

+         png_handle_zTXt(png_ptr, info_ptr, length);

+#endif

+#if defined(PNG_READ_iTXt_SUPPORTED)

+      else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))

+         png_handle_iTXt(png_ptr, info_ptr, length);

+#endif

+      else

+         png_handle_unknown(png_ptr, info_ptr, length);

+   } while (!(png_ptr->mode & PNG_HAVE_IEND));

+}

+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */

+/* free all memory used by the read */

+void PNGAPI

+png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,

+   png_infopp end_info_ptr_ptr)

+{

+   png_structp png_ptr = NULL;

+   png_infop info_ptr = NULL, end_info_ptr = NULL;

+#ifdef PNG_USER_MEM_SUPPORTED

+   png_free_ptr free_fn;

+   png_voidp mem_ptr;

+#endif

+   png_debug(1, "in png_destroy_read_struct\n");

+   if (png_ptr_ptr != NULL)

+      png_ptr = *png_ptr_ptr;

+   if (info_ptr_ptr != NULL)

+      info_ptr = *info_ptr_ptr;

+   if (end_info_ptr_ptr != NULL)

+      end_info_ptr = *end_info_ptr_ptr;

+#ifdef PNG_USER_MEM_SUPPORTED

+   free_fn = png_ptr->free_fn;

+   mem_ptr = png_ptr->mem_ptr;

+#endif

+   png_read_destroy(png_ptr, info_ptr, end_info_ptr);

+   if (info_ptr != NULL)

+   {

+#if defined(PNG_TEXT_SUPPORTED)

+      png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1);

+#endif

+#ifdef PNG_USER_MEM_SUPPORTED

+      png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,

+          (png_voidp)mem_ptr);

+#else

+      png_destroy_struct((png_voidp)info_ptr);

+#endif

+      *info_ptr_ptr = NULL;

+   }

+   if (end_info_ptr != NULL)

+   {

+#if defined(PNG_READ_TEXT_SUPPORTED)

+      png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1);

+#endif

+#ifdef PNG_USER_MEM_SUPPORTED

+      png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn,

+         (png_voidp)mem_ptr);

+#else

+      png_destroy_struct((png_voidp)end_info_ptr);

+#endif

+      *end_info_ptr_ptr = NULL;

+   }

+   if (png_ptr != NULL)

+   {

+#ifdef PNG_USER_MEM_SUPPORTED

+      png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,

+          (png_voidp)mem_ptr);

+#else

+      png_destroy_struct((png_voidp)png_ptr);

+#endif

+      *png_ptr_ptr = NULL;

+   }

+}

+/* free all memory used by the read (old method) */

+void /* PRIVATE */

+png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr)

+{

+#ifdef PNG_SETJMP_SUPPORTED

+   jmp_buf tmp_jmp;

+#endif

+   png_error_ptr error_fn;

+   png_error_ptr warning_fn;

+   png_voidp error_ptr;

+#ifdef PNG_USER_MEM_SUPPORTED

+   png_free_ptr free_fn;

+#endif

+   png_debug(1, "in png_read_destroy\n");

+   if (info_ptr != NULL)

+      png_info_destroy(png_ptr, info_ptr);

+   if (end_info_ptr != NULL)

+      png_info_destroy(png_ptr, end_info_ptr);

+   png_free(png_ptr, png_ptr->zbuf);

+   png_free(png_ptr, png_ptr->big_row_buf);

+   png_free(png_ptr, png_ptr->prev_row);

+#if defined(PNG_READ_DITHER_SUPPORTED)

+   png_free(png_ptr, png_ptr->palette_lookup);

+   png_free(png_ptr, png_ptr->dither_index);

+#endif

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+   png_free(png_ptr, png_ptr->gamma_table);

+#endif

+#if defined(PNG_READ_BACKGROUND_SUPPORTED)

+   png_free(png_ptr, png_ptr->gamma_from_1);

+   png_free(png_ptr, png_ptr->gamma_to_1);

+#endif

+#ifdef PNG_FREE_ME_SUPPORTED

+   if (png_ptr->free_me & PNG_FREE_PLTE)

+      png_zfree((void*)png_ptr, (void*)png_ptr->palette);

+   png_ptr->free_me &= ~PNG_FREE_PLTE;

+#else

+   if (png_ptr->flags & PNG_FLAG_FREE_PLTE)

+      png_zfree(png_ptr, png_ptr->palette);

+   png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;

+#endif

+#if defined(PNG_tRNS_SUPPORTED) || \

+    defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

+#ifdef PNG_FREE_ME_SUPPORTED

+   if (png_ptr->free_me & PNG_FREE_TRNS)

+      png_free(png_ptr, png_ptr->trans);

+   png_ptr->free_me &= ~PNG_FREE_TRNS;

+#else

+   if (png_ptr->flags & PNG_FLAG_FREE_TRNS)

+      png_free(png_ptr, png_ptr->trans);

+   png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;

+#endif

+#endif

+#if defined(PNG_READ_hIST_SUPPORTED)

+#ifdef PNG_FREE_ME_SUPPORTED

+   if (png_ptr->free_me & PNG_FREE_HIST)

+      png_free(png_ptr, png_ptr->hist);

+   png_ptr->free_me &= ~PNG_FREE_HIST;

+#else

+   if (png_ptr->flags & PNG_FLAG_FREE_HIST)

+      png_free(png_ptr, png_ptr->hist);

+   png_ptr->flags &= ~PNG_FLAG_FREE_HIST;

+#endif

+#endif

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+   if (png_ptr->gamma_16_table != NULL)

+   {

+      int i;

+      int istop = (1 << (8 - png_ptr->gamma_shift));

+      for (i = 0; i < istop; i++)

+      {

+         png_free(png_ptr, png_ptr->gamma_16_table[i]);

+      }

+   png_free(png_ptr, png_ptr->gamma_16_table);

+   }

+#if defined(PNG_READ_BACKGROUND_SUPPORTED)

+   if (png_ptr->gamma_16_from_1 != NULL)

+   {

+      int i;

+      int istop = (1 << (8 - png_ptr->gamma_shift));

+      for (i = 0; i < istop; i++)

+      {

+         png_free(png_ptr, png_ptr->gamma_16_from_1[i]);

+      }

+   png_free(png_ptr, png_ptr->gamma_16_from_1);

+   }

+   if (png_ptr->gamma_16_to_1 != NULL)

+   {

+      int i;

+      int istop = (1 << (8 - png_ptr->gamma_shift));

+      for (i = 0; i < istop; i++)

+      {

+         png_free(png_ptr, png_ptr->gamma_16_to_1[i]);

+      }

+   png_free(png_ptr, png_ptr->gamma_16_to_1);

+   }

+#endif

+#endif

+#if defined(PNG_TIME_RFC1123_SUPPORTED)

+   png_free(png_ptr, png_ptr->time_buffer);

+#endif

+   inflateEnd(&png_ptr->zstream);

+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

+   png_free(png_ptr, png_ptr->save_buffer);

+#endif

+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

+#ifdef PNG_TEXT_SUPPORTED

+   png_free(png_ptr, png_ptr->current_text);

+#endif /* PNG_TEXT_SUPPORTED */

+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

+   /* Save the important info out of the png_struct, in case it is

+    * being used again.

+    */

+#ifdef PNG_SETJMP_SUPPORTED

+   png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof (jmp_buf));

+#endif

+   error_fn = png_ptr->error_fn;

+   warning_fn = png_ptr->warning_fn;

+   error_ptr = png_ptr->error_ptr;

+#ifdef PNG_USER_MEM_SUPPORTED

+   free_fn = png_ptr->free_fn;

+#endif

+   png_memset(png_ptr, 0, png_sizeof (png_struct));

+   png_ptr->error_fn = error_fn;

+   png_ptr->warning_fn = warning_fn;

+   png_ptr->error_ptr = error_ptr;

+#ifdef PNG_USER_MEM_SUPPORTED

+   png_ptr->free_fn = free_fn;

+#endif

+#ifdef PNG_SETJMP_SUPPORTED

+   png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof (jmp_buf));

+#endif

+}

+void PNGAPI

+png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)

+{

+   png_ptr->read_row_fn = read_row_fn;

+}

+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED

+#if defined(PNG_INFO_IMAGE_SUPPORTED)

+void PNGAPI

+png_read_png(png_structp png_ptr, png_infop info_ptr,

+                           int transforms,

+                           png_voidp params)

+{

+   int row;

+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)

+   /* invert the alpha channel from opacity to transparency

+    */

+   if (transforms & PNG_TRANSFORM_INVERT_ALPHA)

+       png_set_invert_alpha(png_ptr);

+#endif

+   /* png_read_info() gives us all of the information from the

+    * PNG file before the first IDAT (image data chunk).

+    */

+   png_read_info(png_ptr, info_ptr);

+   if (info_ptr->height > PNG_UINT_32_MAX/png_sizeof(png_bytep))

+      png_error(png_ptr,"Image is too high to process with png_read_png()");

+   /* -------------- image transformations start here ------------------- */

+#if defined(PNG_READ_16_TO_8_SUPPORTED)

+   /* tell libpng to strip 16 bit/color files down to 8 bits per color

+    */

+   if (transforms & PNG_TRANSFORM_STRIP_16)

+       png_set_strip_16(png_ptr);

+#endif

+#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)

+   /* Strip alpha bytes from the input data without combining with

+    * the background (not recommended).

+    */

+   if (transforms & PNG_TRANSFORM_STRIP_ALPHA)

+       png_set_strip_alpha(png_ptr);

+#endif

+#if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED)

+   /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single

+    * byte into separate bytes (useful for paletted and grayscale images).

+    */

+   if (transforms & PNG_TRANSFORM_PACKING)

+       png_set_packing(png_ptr);

+#endif

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+   /* Change the order of packed pixels to least significant bit first

+    * (not useful if you are using png_set_packing).

+    */

+   if (transforms & PNG_TRANSFORM_PACKSWAP)

+       png_set_packswap(png_ptr);

+#endif

+#if defined(PNG_READ_EXPAND_SUPPORTED)

+   /* Expand paletted colors into true RGB triplets

+    * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel

+    * Expand paletted or RGB images with transparency to full alpha

+    * channels so the data will be available as RGBA quartets.

+    */

+   if (transforms & PNG_TRANSFORM_EXPAND)

+       if ((png_ptr->bit_depth < 8) ||

+           (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ||

+           (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)))

+         png_set_expand(png_ptr);

+#endif

+   /* We don't handle background color or gamma transformation or dithering.

+    */

+#if defined(PNG_READ_INVERT_SUPPORTED)

+   /* invert monochrome files to have 0 as white and 1 as black

+    */

+   if (transforms & PNG_TRANSFORM_INVERT_MONO)

+       png_set_invert_mono(png_ptr);

+#endif

+#if defined(PNG_READ_SHIFT_SUPPORTED)

+   /* If you want to shift the pixel values from the range [0,255] or

+    * [0,65535] to the original [0,7] or [0,31], or whatever range the

+    * colors were originally in:

+    */

+   if ((transforms & PNG_TRANSFORM_SHIFT)

+       && png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))

+   {

+      png_color_8p sig_bit;

+      png_get_sBIT(png_ptr, info_ptr, &sig_bit);

+      png_set_shift(png_ptr, sig_bit);

+   }

+#endif

+#if defined(PNG_READ_BGR_SUPPORTED)

+   /* flip the RGB pixels to BGR (or RGBA to BGRA)

+    */

+   if (transforms & PNG_TRANSFORM_BGR)

+       png_set_bgr(png_ptr);

+#endif

+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)

+   /* swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR)

+    */

+   if (transforms & PNG_TRANSFORM_SWAP_ALPHA)

+       png_set_swap_alpha(png_ptr);

+#endif

+#if defined(PNG_READ_SWAP_SUPPORTED)

+   /* swap bytes of 16 bit files to least significant byte first

+    */

+   if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)

+       png_set_swap(png_ptr);

+#endif

+   /* We don't handle adding filler bytes */

+   /* Optional call to gamma correct and add the background to the palette

+    * and update info structure.  REQUIRED if you are expecting libpng to

+    * update the palette for you (i.e., you selected such a transform above).

+    */

+   png_read_update_info(png_ptr, info_ptr);

+   /* -------------- image transformations end here ------------------- */

+#ifdef PNG_FREE_ME_SUPPORTED

+   png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);

+#endif

+   if(info_ptr->row_pointers == NULL)

+   {

+      info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,

+         info_ptr->height * png_sizeof(png_bytep));

+#ifdef PNG_FREE_ME_SUPPORTED

+      info_ptr->free_me |= PNG_FREE_ROWS;

+#endif

+      for (row = 0; row < (int)info_ptr->height; row++)

+      {

+         info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,

+            png_get_rowbytes(png_ptr, info_ptr));

+      }

+   }

+   png_read_image(png_ptr, info_ptr->row_pointers);

+   info_ptr->valid |= PNG_INFO_IDAT;

+   /* read rest of file, and get additional chunks in info_ptr - REQUIRED */

+   png_read_end(png_ptr, info_ptr);

+   if(transforms == 0 || params == NULL)

+      /* quiet compiler warnings */ return;

+}

+#endif

+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */

--- /dev/null

+++ b/src/gfx/libpng/pngrio.c

@@ -1,0 +1,161 @@

+/* pngrio.c - functions for data input

+ *

+ * libpng 1.2.8 - December 3, 2004

+ * For conditions of distribution and use, see copyright notice in png.h

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

+ *

+ * This file provides a location for all input.  Users who need

+ * special handling are expected to write a function that has the same

+ * arguments as this and performs a similar function, but that possibly

+ * has a different input method.  Note that you shouldn't change this

+ * function, but rather write a replacement function and then make

+ * libpng use it at run time with png_set_read_fn(...).

+ */

+#define PNG_INTERNAL

+#include "png.h"

+/* Read the data from whatever input you are using.  The default routine

+   reads from a file pointer.  Note that this routine sometimes gets called

+   with very small lengths, so you should implement some kind of simple

+   buffering if you are using unbuffered reads.  This should never be asked

+   to read more then 64K on a 16 bit machine. */

+void /* PRIVATE */

+png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)

+{

+   png_debug1(4,"reading %d bytes\n", (int)length);

+   if (png_ptr->read_data_fn != NULL)

+      (*(png_ptr->read_data_fn))(png_ptr, data, length);

+   else

+      png_error(png_ptr, "Call to NULL read function");

+}

+#if !defined(PNG_NO_STDIO)

+/* This is the function that does the actual reading of data.  If you are

+   not reading from a standard C stream, you should create a replacement

+   read_data function and use it at run time with png_set_read_fn(), rather

+   than changing the library. */

+#ifndef USE_FAR_KEYWORD

+void PNGAPI

+png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)

+{

+   png_size_t check;

+   /* fread() returns 0 on error, so it is OK to store this in a png_size_t

+    * instead of an int, which is what fread() actually returns.

+    */

+#if defined(_WIN32_WCE)

+   if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )

+      check = 0;

+#else

+   check = (png_size_t)fread(data, (png_size_t)1, length,

+      (png_FILE_p)png_ptr->io_ptr);

+#endif

+   if (check != length)

+      png_error(png_ptr, "Read Error");

+}

+#else

+/* this is the model-independent version. Since the standard I/O library

+   can't handle far buffers in the medium and small models, we have to copy

+   the data.

+*/

+#define NEAR_BUF_SIZE 1024

+#define MIN(a,b) (a <= b ? a : b)

+static void /* PRIVATE */

+png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)

+{

+   int check;

+   png_byte *n_data;

+   png_FILE_p io_ptr;

+   /* Check if data really is near. If so, use usual code. */

+   n_data = (png_byte *)CVT_PTR_NOCHECK(data);

+   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);

+   if ((png_bytep)n_data == data)

+   {

+#if defined(_WIN32_WCE)

+      if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )

+         check = 0;

+#else

+      check = fread(n_data, 1, length, io_ptr);

+#endif

+   }

+   else

+   {

+      png_byte buf[NEAR_BUF_SIZE];

+      png_size_t read, remaining, err;

+      check = 0;

+      remaining = length;

+      do

+      {

+         read = MIN(NEAR_BUF_SIZE, remaining);

+#if defined(_WIN32_WCE)

+         if ( !ReadFile((HANDLE)(io_ptr), buf, read, &err, NULL) )

+            err = 0;

+#else

+         err = fread(buf, (png_size_t)1, read, io_ptr);

+#endif

+         png_memcpy(data, buf, read); /* copy far buffer to near buffer */

+         if(err != read)

+            break;

+         else

+            check += err;

+         data += read;

+         remaining -= read;

+      }

+      while (remaining != 0);

+   }

+   if ((png_uint_32)check != (png_uint_32)length)

+      png_error(png_ptr, "read Error");

+}

+#endif

+#endif

+/* This function allows the application to supply a new input function

+   for libpng if standard C streams aren't being used.

+   This function takes as its arguments:

+   png_ptr      - pointer to a png input data structure

+   io_ptr       - pointer to user supplied structure containing info about

+                  the input functions.  May be NULL.

+   read_data_fn - pointer to a new input function that takes as its

+                  arguments a pointer to a png_struct, a pointer to

+                  a location where input data can be stored, and a 32-bit

+                  unsigned int that is the number of bytes to be read.

+                  To exit and output any fatal error messages the new write

+                  function should call png_error(png_ptr, "Error msg"). */

+void PNGAPI

+png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,

+   png_rw_ptr read_data_fn)

+{

+   png_ptr->io_ptr = io_ptr;

+#if !defined(PNG_NO_STDIO)

+   if (read_data_fn != NULL)

+      png_ptr->read_data_fn = read_data_fn;

+   else

+      png_ptr->read_data_fn = png_default_read_data;

+#else

+   png_ptr->read_data_fn = read_data_fn;

+#endif

+   /* It is an error to write to a read device */

+   if (png_ptr->write_data_fn != NULL)

+   {

+      png_ptr->write_data_fn = NULL;

+      png_warning(png_ptr,

+         "It's an error to set both read_data_fn and write_data_fn in the ");

+      png_warning(png_ptr,

+         "same structure.  Resetting write_data_fn to NULL.");

+   }

+#if defined(PNG_WRITE_FLUSH_SUPPORTED)

+   png_ptr->output_flush_fn = NULL;

+#endif

+}

--- /dev/null

+++ b/src/gfx/libpng/pngrtran.c

@@ -1,0 +1,4177 @@

+/* pngrtran.c - transforms the data in a row for PNG readers

+ *

+ * libpng version  1.2.8 - December 3, 2004

+ * For conditions of distribution and use, see copyright notice in png.h

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

+ *

+ * This file contains functions optionally called by an application

+ * in order to tell libpng how to handle data when reading a PNG.

+ * Transformations that are used in both reading and writing are

+ * in pngtrans.c.

+ */

+#define PNG_INTERNAL

+#include "png.h"

+/* Set the action on getting a CRC error for an ancillary or critical chunk. */

+void PNGAPI

+png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)

+{

+   png_debug(1, "in png_set_crc_action\n");

+   /* Tell libpng how we react to CRC errors in critical chunks */

+   switch (crit_action)

+   {

+      case PNG_CRC_NO_CHANGE:                        /* leave setting as is */

+         break;

+      case PNG_CRC_WARN_USE:                               /* warn/use data */

+         png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;

+         png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE;

+         break;

+      case PNG_CRC_QUIET_USE:                             /* quiet/use data */

+         png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;

+         png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE |

+                           PNG_FLAG_CRC_CRITICAL_IGNORE;

+         break;

+      case PNG_CRC_WARN_DISCARD:    /* not a valid action for critical data */

+         png_warning(png_ptr, "Can't discard critical data on CRC error.");

+      case PNG_CRC_ERROR_QUIT:                                /* error/quit */

+      case PNG_CRC_DEFAULT:

+      default:

+         png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;

+         break;

+   }

+   switch (ancil_action)

+   {

+      case PNG_CRC_NO_CHANGE:                       /* leave setting as is */

+         break;

+      case PNG_CRC_WARN_USE:                              /* warn/use data */

+         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;

+         png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE;

+         break;

+      case PNG_CRC_QUIET_USE:                            /* quiet/use data */

+         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;

+         png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE |

+                           PNG_FLAG_CRC_ANCILLARY_NOWARN;

+         break;

+      case PNG_CRC_ERROR_QUIT:                               /* error/quit */

+         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;

+         png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN;

+         break;

+      case PNG_CRC_WARN_DISCARD:                      /* warn/discard data */

+      case PNG_CRC_DEFAULT:

+      default:

+         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;

+         break;

+   }

+}

+#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \

+    defined(PNG_FLOATING_POINT_SUPPORTED)

+/* handle alpha and tRNS via a background color */

+void PNGAPI

+png_set_background(png_structp png_ptr,

+   png_color_16p background_color, int background_gamma_code,

+   int need_expand, double background_gamma)

+{

+   png_debug(1, "in png_set_background\n");

+   if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN)

+   {

+      png_warning(png_ptr, "Application must supply a known background gamma");

+      return;

+   }

+   png_ptr->transformations |= PNG_BACKGROUND;

+   png_memcpy(&(png_ptr->background), background_color,

+      png_sizeof(png_color_16));

+   png_ptr->background_gamma = (float)background_gamma;

+   png_ptr->background_gamma_type = (png_byte)(background_gamma_code);

+   png_ptr->transformations |= (need_expand ? PNG_BACKGROUND_EXPAND : 0);

+   /* Note:  if need_expand is set and color_type is either RGB or RGB_ALPHA

+    * (in which case need_expand is superfluous anyway), the background color

+    * might actually be gray yet not be flagged as such. This is not a problem

+    * for the current code, which uses PNG_BACKGROUND_IS_GRAY only to

+    * decide when to do the png_do_gray_to_rgb() transformation.

+    */

+   if ((need_expand && !(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) ||

+       (!need_expand && background_color->red == background_color->green &&

+        background_color->red == background_color->blue))

+      png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;

+}

+#endif

+#if defined(PNG_READ_16_TO_8_SUPPORTED)

+/* strip 16 bit depth files to 8 bit depth */

+void PNGAPI

+png_set_strip_16(png_structp png_ptr)

+{

+   png_debug(1, "in png_set_strip_16\n");

+   png_ptr->transformations |= PNG_16_TO_8;

+}

+#endif

+#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)

+void PNGAPI

+png_set_strip_alpha(png_structp png_ptr)

+{

+   png_debug(1, "in png_set_strip_alpha\n");

+   png_ptr->flags |= PNG_FLAG_STRIP_ALPHA;

+}

+#endif

+#if defined(PNG_READ_DITHER_SUPPORTED)

+/* Dither file to 8 bit.  Supply a palette, the current number

+ * of elements in the palette, the maximum number of elements

+ * allowed, and a histogram if possible.  If the current number

+ * of colors is greater then the maximum number, the palette will be

+ * modified to fit in the maximum number.  "full_dither" indicates

+ * whether we need a dithering cube set up for RGB images, or if we

+ * simply are reducing the number of colors in a paletted image.

+ */

+typedef struct png_dsort_struct

+{

+   struct png_dsort_struct FAR * next;

+   png_byte left;

+   png_byte right;

+} png_dsort;

+typedef png_dsort FAR *       png_dsortp;

+typedef png_dsort FAR * FAR * png_dsortpp;

+void PNGAPI

+png_set_dither(png_structp png_ptr, png_colorp palette,

+   int num_palette, int maximum_colors, png_uint_16p histogram,

+   int full_dither)

+{

+   png_debug(1, "in png_set_dither\n");

+   png_ptr->transformations |= PNG_DITHER;

+   if (!full_dither)

+   {

+      int i;

+      png_ptr->dither_index = (png_bytep)png_malloc(png_ptr,

+         (png_uint_32)(num_palette * png_sizeof (png_byte)));

+      for (i = 0; i < num_palette; i++)

+         png_ptr->dither_index[i] = (png_byte)i;

+   }

+   if (num_palette > maximum_colors)

+   {

+      if (histogram != NULL)

+      {

+         /* This is easy enough, just throw out the least used colors.

+            Perhaps not the best solution, but good enough. */

+         int i;

+         /* initialize an array to sort colors */

+         png_ptr->dither_sort = (png_bytep)png_malloc(png_ptr,

+            (png_uint_32)(num_palette * png_sizeof (png_byte)));

+         /* initialize the dither_sort array */

+         for (i = 0; i < num_palette; i++)

+            png_ptr->dither_sort[i] = (png_byte)i;

+         /* Find the least used palette entries by starting a

+            bubble sort, and running it until we have sorted

+            out enough colors.  Note that we don't care about

+            sorting all the colors, just finding which are

+            least used. */

+         for (i = num_palette - 1; i >= maximum_colors; i--)

+         {

+            int done; /* to stop early if the list is pre-sorted */

+            int j;

+            done = 1;

+            for (j = 0; j < i; j++)

+            {

+               if (histogram[png_ptr->dither_sort[j]]

+                   < histogram[png_ptr->dither_sort[j + 1]])

+               {

+                  png_byte t;

+                  t = png_ptr->dither_sort[j];

+                  png_ptr->dither_sort[j] = png_ptr->dither_sort[j + 1];

+                  png_ptr->dither_sort[j + 1] = t;

+                  done = 0;

+               }

+            }

+            if (done)

+               break;

+         }

+         /* swap the palette around, and set up a table, if necessary */

+         if (full_dither)

+         {

+            int j = num_palette;

+            /* put all the useful colors within the max, but don't

+               move the others */

+            for (i = 0; i < maximum_colors; i++)

+            {

+               if ((int)png_ptr->dither_sort[i] >= maximum_colors)

+               {

+                  do

+                     j--;

+                  while ((int)png_ptr->dither_sort[j] >= maximum_colors);

+                  palette[i] = palette[j];

+               }

+            }

+         }

+         else

+         {

+            int j = num_palette;

+            /* move all the used colors inside the max limit, and

+               develop a translation table */

+            for (i = 0; i < maximum_colors; i++)

+            {

+               /* only move the colors we need to */

+               if ((int)png_ptr->dither_sort[i] >= maximum_colors)

+               {

+                  png_color tmp_color;

+                  do

+                     j--;

+                  while ((int)png_ptr->dither_sort[j] >= maximum_colors);

+                  tmp_color = palette[j];

+                  palette[j] = palette[i];

+                  palette[i] = tmp_color;

+                  /* indicate where the color went */

+                  png_ptr->dither_index[j] = (png_byte)i;

+                  png_ptr->dither_index[i] = (png_byte)j;

+               }

+            }

+            /* find closest color for those colors we are not using */

+            for (i = 0; i < num_palette; i++)

+            {

+               if ((int)png_ptr->dither_index[i] >= maximum_colors)

+               {

+                  int min_d, k, min_k, d_index;

+                  /* find the closest color to one we threw out */

+                  d_index = png_ptr->dither_index[i];

+                  min_d = PNG_COLOR_DIST(palette[d_index], palette[0]);

+                  for (k = 1, min_k = 0; k < maximum_colors; k++)

+                  {

+                     int d;

+                     d = PNG_COLOR_DIST(palette[d_index], palette[k]);

+                     if (d < min_d)

+                     {

+                        min_d = d;

+                        min_k = k;

+                     }

+                  }

+                  /* point to closest color */

+                  png_ptr->dither_index[i] = (png_byte)min_k;

+               }

+            }

+         }

+         png_free(png_ptr, png_ptr->dither_sort);

+         png_ptr->dither_sort=NULL;

+      }

+      else

+      {

+         /* This is much harder to do simply (and quickly).  Perhaps

+            we need to go through a median cut routine, but those

+            don't always behave themselves with only a few colors

+            as input.  So we will just find the closest two colors,

+            and throw out one of them (chosen somewhat randomly).

+            [We don't understand this at all, so if someone wants to

+             work on improving it, be our guest - AED, GRP]

+            */

+         int i;

+         int max_d;

+         int num_new_palette;

+         png_dsortp t;

+         png_dsortpp hash;

+         t=NULL;

+         /* initialize palette index arrays */

+         png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr,

+            (png_uint_32)(num_palette * png_sizeof (png_byte)));

+         png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr,

+            (png_uint_32)(num_palette * png_sizeof (png_byte)));

+         /* initialize the sort array */

+         for (i = 0; i < num_palette; i++)

+         {

+            png_ptr->index_to_palette[i] = (png_byte)i;

+            png_ptr->palette_to_index[i] = (png_byte)i;

+         }

+         hash = (png_dsortpp)png_malloc(png_ptr, (png_uint_32)(769 *

+            png_sizeof (png_dsortp)));

+         for (i = 0; i < 769; i++)

+            hash[i] = NULL;

+/*         png_memset(hash, 0, 769 * png_sizeof (png_dsortp)); */

+         num_new_palette = num_palette;

+         /* initial wild guess at how far apart the farthest pixel

+            pair we will be eliminating will be.  Larger

+            numbers mean more areas will be allocated, Smaller

+            numbers run the risk of not saving enough data, and

+            having to do this all over again.

+            I have not done extensive checking on this number.

+            */

+         max_d = 96;

+         while (num_new_palette > maximum_colors)

+         {

+            for (i = 0; i < num_new_palette - 1; i++)

+            {

+               int j;

+               for (j = i + 1; j < num_new_palette; j++)

+               {

+                  int d;

+                  d = PNG_COLOR_DIST(palette[i], palette[j]);

+                  if (d <= max_d)

+                  {

+                     t = (png_dsortp)png_malloc_warn(png_ptr,

+                         (png_uint_32)(png_sizeof(png_dsort)));

+                     if (t == NULL)

+                         break;

+                     t->next = hash[d];

+                     t->left = (png_byte)i;

+                     t->right = (png_byte)j;

+                     hash[d] = t;

+                  }

+               }

+               if (t == NULL)

+                  break;

+            }

+            if (t != NULL)

+            for (i = 0; i <= max_d; i++)

+            {

+               if (hash[i] != NULL)

+               {

+                  png_dsortp p;

+                  for (p = hash[i]; p; p = p->next)

+                  {

+                     if ((int)png_ptr->index_to_palette[p->left]

+                        < num_new_palette &&

+                        (int)png_ptr->index_to_palette[p->right]

+                        < num_new_palette)

+                     {

+                        int j, next_j;

+                        if (num_new_palette & 0x01)

+                        {

+                           j = p->left;

+                           next_j = p->right;

+                        }

+                        else

+                        {

+                           j = p->right;

+                           next_j = p->left;

+                        }

+                        num_new_palette--;

+                        palette[png_ptr->index_to_palette[j]]

+                          = palette[num_new_palette];

+                        if (!full_dither)

+                        {

+                           int k;

+                           for (k = 0; k < num_palette; k++)

+                           {

+                              if (png_ptr->dither_index[k] ==

+                                 png_ptr->index_to_palette[j])

+                                 png_ptr->dither_index[k] =

+                                    png_ptr->index_to_palette[next_j];

+                              if ((int)png_ptr->dither_index[k] ==

+                                 num_new_palette)

+                                 png_ptr->dither_index[k] =

+                                    png_ptr->index_to_palette[j];

+                           }

+                        }

+                        png_ptr->index_to_palette[png_ptr->palette_to_index

+                           [num_new_palette]] = png_ptr->index_to_palette[j];

+                        png_ptr->palette_to_index[png_ptr->index_to_palette[j]]

+                           = png_ptr->palette_to_index[num_new_palette];

+                        png_ptr->index_to_palette[j] = (png_byte)num_new_palette;

+                        png_ptr->palette_to_index[num_new_palette] = (png_byte)j;

+                     }

+                     if (num_new_palette <= maximum_colors)

+                        break;

+                  }

+                  if (num_new_palette <= maximum_colors)

+                     break;

+               }

+            }

+            for (i = 0; i < 769; i++)

+            {

+               if (hash[i] != NULL)

+               {

+                  png_dsortp p = hash[i];

+                  while (p)

+                  {

+                     t = p->next;

+                     png_free(png_ptr, p);

+                     p = t;

+                  }

+               }

+               hash[i] = 0;

+            }

+            max_d += 96;

+         }

+         png_free(png_ptr, hash);

+         png_free(png_ptr, png_ptr->palette_to_index);

+         png_free(png_ptr, png_ptr->index_to_palette);

+         png_ptr->palette_to_index=NULL;

+         png_ptr->index_to_palette=NULL;

+      }

+      num_palette = maximum_colors;

+   }

+   if (png_ptr->palette == NULL)

+   {

+      png_ptr->palette = palette;

+   }

+   png_ptr->num_palette = (png_uint_16)num_palette;

+   if (full_dither)

+   {

+      int i;

+      png_bytep distance;

+      int total_bits = PNG_DITHER_RED_BITS + PNG_DITHER_GREEN_BITS +

+         PNG_DITHER_BLUE_BITS;

+      int num_red = (1 << PNG_DITHER_RED_BITS);

+      int num_green = (1 << PNG_DITHER_GREEN_BITS);

+      int num_blue = (1 << PNG_DITHER_BLUE_BITS);

+      png_size_t num_entries = ((png_size_t)1 << total_bits);

+      png_ptr->palette_lookup = (png_bytep )png_malloc(png_ptr,

+         (png_uint_32)(num_entries * png_sizeof (png_byte)));

+      png_memset(png_ptr->palette_lookup, 0, num_entries *

+         png_sizeof (png_byte));

+      distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries *

+         png_sizeof(png_byte)));

+      png_memset(distance, 0xff, num_entries * png_sizeof(png_byte));

+      for (i = 0; i < num_palette; i++)

+      {

+         int ir, ig, ib;

+         int r = (palette[i].red >> (8 - PNG_DITHER_RED_BITS));

+         int g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS));

+         int b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS));

+         for (ir = 0; ir < num_red; ir++)

+         {

+            /* int dr = abs(ir - r); */

+            int dr = ((ir > r) ? ir - r : r - ir);

+            int index_r = (ir << (PNG_DITHER_BLUE_BITS + PNG_DITHER_GREEN_BITS));

+            for (ig = 0; ig < num_green; ig++)

+            {

+               /* int dg = abs(ig - g); */

+               int dg = ((ig > g) ? ig - g : g - ig);

+               int dt = dr + dg;

+               int dm = ((dr > dg) ? dr : dg);

+               int index_g = index_r | (ig << PNG_DITHER_BLUE_BITS);

+               for (ib = 0; ib < num_blue; ib++)

+               {

+                  int d_index = index_g | ib;

+                  /* int db = abs(ib - b); */

+                  int db = ((ib > b) ? ib - b : b - ib);

+                  int dmax = ((dm > db) ? dm : db);

+                  int d = dmax + dt + db;

+                  if (d < (int)distance[d_index])

+                  {

+                     distance[d_index] = (png_byte)d;

+                     png_ptr->palette_lookup[d_index] = (png_byte)i;

+                  }

+               }

+            }

+         }

+      }

+      png_free(png_ptr, distance);

+   }

+}

+#endif

+#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)

+/* Transform the image from the file_gamma to the screen_gamma.  We

+ * only do transformations on images where the file_gamma and screen_gamma

+ * are not close reciprocals, otherwise it slows things down slightly, and

+ * also needlessly introduces small errors.

+ *

+ * We will turn off gamma transformation later if no semitransparent entries

+ * are present in the tRNS array for palette images.  We can't do it here

+ * because we don't necessarily have the tRNS chunk yet.

+ */

+void PNGAPI

+png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)

+{

+   png_debug(1, "in png_set_gamma\n");

+   if ((fabs(scrn_gamma * file_gamma - 1.0) > PNG_GAMMA_THRESHOLD) ||

+       (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) ||

+       (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))

+     png_ptr->transformations |= PNG_GAMMA;

+   png_ptr->gamma = (float)file_gamma;

+   png_ptr->screen_gamma = (float)scrn_gamma;

+}

+#endif

+#if defined(PNG_READ_EXPAND_SUPPORTED)

+/* Expand paletted images to RGB, expand grayscale images of

+ * less than 8-bit depth to 8-bit depth, and expand tRNS chunks

+ * to alpha channels.

+ */

+void PNGAPI

+png_set_expand(png_structp png_ptr)

+{

+   png_debug(1, "in png_set_expand\n");

+   png_ptr->transformations |= PNG_EXPAND;

+}

+/* GRR 19990627:  the following three functions currently are identical

+ *  to png_set_expand().  However, it is entirely reasonable that someone

+ *  might wish to expand an indexed image to RGB but *not* expand a single,

+ *  fully transparent palette entry to a full alpha channel--perhaps instead

+ *  convert tRNS to the grayscale/RGB format (16-bit RGB value), or replace

+ *  the transparent color with a particular RGB value, or drop tRNS entirely.

+ *  IOW, a future version of the library may make the transformations flag

+ *  a bit more fine-grained, with separate bits for each of these three

+ *  functions.

+ *

+ *  More to the point, these functions make it obvious what libpng will be

+ *  doing, whereas "expand" can (and does) mean any number of things.

+ */

+/* Expand paletted images to RGB. */

+void PNGAPI

+png_set_palette_to_rgb(png_structp png_ptr)

+{

+   png_debug(1, "in png_set_expand\n");

+   png_ptr->transformations |= PNG_EXPAND;

+}

+/* Expand grayscale images of less than 8-bit depth to 8 bits. */

+void PNGAPI

+png_set_gray_1_2_4_to_8(png_structp png_ptr)

+{

+   png_debug(1, "in png_set_expand\n");

+   png_ptr->transformations |= PNG_EXPAND;

+}

+/* Expand tRNS chunks to alpha channels. */

+void PNGAPI

+png_set_tRNS_to_alpha(png_structp png_ptr)

+{

+   png_debug(1, "in png_set_expand\n");

+   png_ptr->transformations |= PNG_EXPAND;

+}

+#endif /* defined(PNG_READ_EXPAND_SUPPORTED) */

+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)

+void PNGAPI

+png_set_gray_to_rgb(png_structp png_ptr)

+{

+   png_debug(1, "in png_set_gray_to_rgb\n");

+   png_ptr->transformations |= PNG_GRAY_TO_RGB;

+}

+#endif

+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)

+#if defined(PNG_FLOATING_POINT_SUPPORTED)

+/* Convert a RGB image to a grayscale of the same width.  This allows us,

+ * for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image.

+ */

+void PNGAPI

+png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red,

+   double green)

+{

+      int red_fixed = (int)((float)red*100000.0 + 0.5);

+      int green_fixed = (int)((float)green*100000.0 + 0.5);

+      png_set_rgb_to_gray_fixed(png_ptr, error_action, red_fixed, green_fixed);

+}

+#endif

+void PNGAPI

+png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action,

+   png_fixed_point red, png_fixed_point green)

+{

+   png_debug(1, "in png_set_rgb_to_gray\n");

+   switch(error_action)

+   {

+      case 1: png_ptr->transformations |= PNG_RGB_TO_GRAY;

+              break;

+      case 2: png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN;

+              break;

+      case 3: png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR;

+   }

+   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+#if defined(PNG_READ_EXPAND_SUPPORTED)

+      png_ptr->transformations |= PNG_EXPAND;

+#else

+   {

+      png_warning(png_ptr, "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED.");

+      png_ptr->transformations &= ~PNG_RGB_TO_GRAY;

+   }

+#endif

+   {

+      png_uint_16 red_int, green_int;

+      if(red < 0 || green < 0)

+      {

+         red_int   =  6968; /* .212671 * 32768 + .5 */

+         green_int = 23434; /* .715160 * 32768 + .5 */

+      }

+      else if(red + green < 100000L)

+      {

+        red_int = (png_uint_16)(((png_uint_32)red*32768L)/100000L);

+        green_int = (png_uint_16)(((png_uint_32)green*32768L)/100000L);

+      }

+      else

+      {

+         png_warning(png_ptr, "ignoring out of range rgb_to_gray coefficients");

+         red_int   =  6968;

+         green_int = 23434;

+      }

+      png_ptr->rgb_to_gray_red_coeff   = red_int;

+      png_ptr->rgb_to_gray_green_coeff = green_int;

+      png_ptr->rgb_to_gray_blue_coeff  = (png_uint_16)(32768-red_int-green_int);

+   }

+}

+#endif

+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \

+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \

+    defined(PNG_LEGACY_SUPPORTED)

+void PNGAPI

+png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr

+   read_user_transform_fn)

+{

+   png_debug(1, "in png_set_read_user_transform_fn\n");

+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)

+   png_ptr->transformations |= PNG_USER_TRANSFORM;

+   png_ptr->read_user_transform_fn = read_user_transform_fn;

+#endif

+#ifdef PNG_LEGACY_SUPPORTED

+   if(read_user_transform_fn)

+      png_warning(png_ptr,

+        "This version of libpng does not support user transforms");

+#endif

+}

+#endif

+/* Initialize everything needed for the read.  This includes modifying

+ * the palette.

+ */

+void /* PRIVATE */

+png_init_read_transformations(png_structp png_ptr)

+{

+   png_debug(1, "in png_init_read_transformations\n");

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+   if(png_ptr != NULL)

+#endif

+  {

+#if defined(PNG_READ_BACKGROUND_SUPPORTED) || defined(PNG_READ_SHIFT_SUPPORTED) \

+ || defined(PNG_READ_GAMMA_SUPPORTED)

+   int color_type = png_ptr->color_type;

+#endif

+#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED)

+   if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&

+       (png_ptr->transformations & PNG_EXPAND))

+   {

+      if (!(color_type & PNG_COLOR_MASK_COLOR))  /* i.e., GRAY or GRAY_ALPHA */

+      {

+         /* expand background chunk. */

+         switch (png_ptr->bit_depth)

+         {

+            case 1:

+               png_ptr->background.gray *= (png_uint_16)0xff;

+               png_ptr->background.red = png_ptr->background.green

+                 =  png_ptr->background.blue = png_ptr->background.gray;

+               break;

+            case 2:

+               png_ptr->background.gray *= (png_uint_16)0x55;

+               png_ptr->background.red = png_ptr->background.green

+                 = png_ptr->background.blue = png_ptr->background.gray;

+               break;

+            case 4:

+               png_ptr->background.gray *= (png_uint_16)0x11;

+               png_ptr->background.red = png_ptr->background.green

+                 = png_ptr->background.blue = png_ptr->background.gray;

+               break;

+            case 8:

+            case 16:

+               png_ptr->background.red = png_ptr->background.green

+                 = png_ptr->background.blue = png_ptr->background.gray;

+               break;

+         }

+      }

+      else if (color_type == PNG_COLOR_TYPE_PALETTE)

+      {

+         png_ptr->background.red   =

+            png_ptr->palette[png_ptr->background.index].red;

+         png_ptr->background.green =

+            png_ptr->palette[png_ptr->background.index].green;

+         png_ptr->background.blue  =

+            png_ptr->palette[png_ptr->background.index].blue;

+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)

+        if (png_ptr->transformations & PNG_INVERT_ALPHA)

+        {

+#if defined(PNG_READ_EXPAND_SUPPORTED)

+           if (!(png_ptr->transformations & PNG_EXPAND))

+#endif

+           {

+           /* invert the alpha channel (in tRNS) unless the pixels are

+              going to be expanded, in which case leave it for later */

+              int i,istop;

+              istop=(int)png_ptr->num_trans;

+              for (i=0; i<istop; i++)

+                 png_ptr->trans[i] = (png_byte)(255 - png_ptr->trans[i]);

+           }

+        }

+#endif

+      }

+   }

+#endif

+#if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED)

+   png_ptr->background_1 = png_ptr->background;

+#endif

+#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)

+   if ((color_type == PNG_COLOR_TYPE_PALETTE && png_ptr->num_trans != 0)

+       && (fabs(png_ptr->screen_gamma * png_ptr->gamma - 1.0)

+         < PNG_GAMMA_THRESHOLD))

+   {

+    int i,k;

+    k=0;

+    for (i=0; i<png_ptr->num_trans; i++)

+    {

+      if (png_ptr->trans[i] != 0 && png_ptr->trans[i] != 0xff)

+        k=1; /* partial transparency is present */

+    }

+    if (k == 0)

+      png_ptr->transformations &= (~PNG_GAMMA);

+   }

+   if (png_ptr->transformations & (PNG_GAMMA | PNG_RGB_TO_GRAY))

+   {

+      png_build_gamma_table(png_ptr);

+#if defined(PNG_READ_BACKGROUND_SUPPORTED)

+      if (png_ptr->transformations & PNG_BACKGROUND)

+      {

+         if (color_type == PNG_COLOR_TYPE_PALETTE)

+         {

+           /* could skip if no transparency and

+           */

+            png_color back, back_1;

+            png_colorp palette = png_ptr->palette;

+            int num_palette = png_ptr->num_palette;

+            int i;

+            if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)

+            {

+               back.red = png_ptr->gamma_table[png_ptr->background.red];

+               back.green = png_ptr->gamma_table[png_ptr->background.green];

+               back.blue = png_ptr->gamma_table[png_ptr->background.blue];

+               back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];

+               back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];

+               back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];

+            }

+            else

+            {

+               double g, gs;

+               switch (png_ptr->background_gamma_type)

+               {

+                  case PNG_BACKGROUND_GAMMA_SCREEN:

+                     g = (png_ptr->screen_gamma);

+                     gs = 1.0;

+                     break;

+                  case PNG_BACKGROUND_GAMMA_FILE:

+                     g = 1.0 / (png_ptr->gamma);

+                     gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);

+                     break;

+                  case PNG_BACKGROUND_GAMMA_UNIQUE:

+                     g = 1.0 / (png_ptr->background_gamma);

+                     gs = 1.0 / (png_ptr->background_gamma *

+                                 png_ptr->screen_gamma);

+                     break;

+                  default:

+                     g = 1.0;    /* back_1 */

+                     gs = 1.0;   /* back */

+               }

+               if ( fabs(gs - 1.0) < PNG_GAMMA_THRESHOLD)

+               {

+                  back.red   = (png_byte)png_ptr->background.red;

+                  back.green = (png_byte)png_ptr->background.green;

+                  back.blue  = (png_byte)png_ptr->background.blue;

+               }

+               else

+               {

+                  back.red = (png_byte)(pow(

+                     (double)png_ptr->background.red/255, gs) * 255.0 + .5);

+                  back.green = (png_byte)(pow(

+                     (double)png_ptr->background.green/255, gs) * 255.0 + .5);

+                  back.blue = (png_byte)(pow(

+                     (double)png_ptr->background.blue/255, gs) * 255.0 + .5);

+               }

+               back_1.red = (png_byte)(pow(

+                  (double)png_ptr->background.red/255, g) * 255.0 + .5);

+               back_1.green = (png_byte)(pow(

+                  (double)png_ptr->background.green/255, g) * 255.0 + .5);

+               back_1.blue = (png_byte)(pow(

+                  (double)png_ptr->background.blue/255, g) * 255.0 + .5);

+            }

+            for (i = 0; i < num_palette; i++)

+            {

+               if (i < (int)png_ptr->num_trans && png_ptr->trans[i] != 0xff)

+               {

+                  if (png_ptr->trans[i] == 0)

+                  {

+                     palette[i] = back;

+                  }

+                  else /* if (png_ptr->trans[i] != 0xff) */

+                  {

+                     png_byte v, w;

+                     v = png_ptr->gamma_to_1[palette[i].red];

+                     png_composite(w, v, png_ptr->trans[i], back_1.red);

+                     palette[i].red = png_ptr->gamma_from_1[w];

+                     v = png_ptr->gamma_to_1[palette[i].green];

+                     png_composite(w, v, png_ptr->trans[i], back_1.green);

+                     palette[i].green = png_ptr->gamma_from_1[w];

+                     v = png_ptr->gamma_to_1[palette[i].blue];

+                     png_composite(w, v, png_ptr->trans[i], back_1.blue);

+                     palette[i].blue = png_ptr->gamma_from_1[w];

+                  }

+               }

+               else

+               {

+                  palette[i].red = png_ptr->gamma_table[palette[i].red];

+                  palette[i].green = png_ptr->gamma_table[palette[i].green];

+                  palette[i].blue = png_ptr->gamma_table[palette[i].blue];

+               }

+            }

+         }

+         /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */

+         else

+         /* color_type != PNG_COLOR_TYPE_PALETTE */

+         {

+            double m = (double)(((png_uint_32)1 << png_ptr->bit_depth) - 1);

+            double g = 1.0;

+            double gs = 1.0;

+            switch (png_ptr->background_gamma_type)

+            {

+               case PNG_BACKGROUND_GAMMA_SCREEN:

+                  g = (png_ptr->screen_gamma);

+                  gs = 1.0;

+                  break;

+               case PNG_BACKGROUND_GAMMA_FILE:

+                  g = 1.0 / (png_ptr->gamma);

+                  gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);

+                  break;

+               case PNG_BACKGROUND_GAMMA_UNIQUE:

+                  g = 1.0 / (png_ptr->background_gamma);

+                  gs = 1.0 / (png_ptr->background_gamma *

+                     png_ptr->screen_gamma);

+                  break;

+            }

+            png_ptr->background_1.gray = (png_uint_16)(pow(

+               (double)png_ptr->background.gray / m, g) * m + .5);

+            png_ptr->background.gray = (png_uint_16)(pow(

+               (double)png_ptr->background.gray / m, gs) * m + .5);

+            if ((png_ptr->background.red != png_ptr->background.green) ||

+                (png_ptr->background.red != png_ptr->background.blue) ||

+                (png_ptr->background.red != png_ptr->background.gray))

+            {

+               /* RGB or RGBA with color background */

+               png_ptr->background_1.red = (png_uint_16)(pow(

+                  (double)png_ptr->background.red / m, g) * m + .5);

+               png_ptr->background_1.green = (png_uint_16)(pow(

+                  (double)png_ptr->background.green / m, g) * m + .5);

+               png_ptr->background_1.blue = (png_uint_16)(pow(

+                  (double)png_ptr->background.blue / m, g) * m + .5);

+               png_ptr->background.red = (png_uint_16)(pow(

+                  (double)png_ptr->background.red / m, gs) * m + .5);

+               png_ptr->background.green = (png_uint_16)(pow(

+                  (double)png_ptr->background.green / m, gs) * m + .5);

+               png_ptr->background.blue = (png_uint_16)(pow(

+                  (double)png_ptr->background.blue / m, gs) * m + .5);

+            }

+            else

+            {

+               /* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */

+               png_ptr->background_1.red = png_ptr->background_1.green

+                 = png_ptr->background_1.blue = png_ptr->background_1.gray;

+               png_ptr->background.red = png_ptr->background.green

+                 = png_ptr->background.blue = png_ptr->background.gray;

+            }

+         }

+      }

+      else

+      /* transformation does not include PNG_BACKGROUND */

+#endif /* PNG_READ_BACKGROUND_SUPPORTED */

+      if (color_type == PNG_COLOR_TYPE_PALETTE)

+      {

+         png_colorp palette = png_ptr->palette;

+         int num_palette = png_ptr->num_palette;

+         int i;

+         for (i = 0; i < num_palette; i++)

+         {

+            palette[i].red = png_ptr->gamma_table[palette[i].red];

+            palette[i].green = png_ptr->gamma_table[palette[i].green];

+            palette[i].blue = png_ptr->gamma_table[palette[i].blue];

+         }

+      }

+   }

+#if defined(PNG_READ_BACKGROUND_SUPPORTED)

+   else

+#endif

+#endif /* PNG_READ_GAMMA_SUPPORTED && PNG_FLOATING_POINT_SUPPORTED */

+#if defined(PNG_READ_BACKGROUND_SUPPORTED)

+   /* No GAMMA transformation */

+   if ((png_ptr->transformations & PNG_BACKGROUND) &&

+       (color_type == PNG_COLOR_TYPE_PALETTE))

+   {

+      int i;

+      int istop = (int)png_ptr->num_trans;

+      png_color back;

+      png_colorp palette = png_ptr->palette;

+      back.red   = (png_byte)png_ptr->background.red;

+      back.green = (png_byte)png_ptr->background.green;

+      back.blue  = (png_byte)png_ptr->background.blue;

+      for (i = 0; i < istop; i++)

+      {

+         if (png_ptr->trans[i] == 0)

+         {

+            palette[i] = back;

+         }

+         else if (png_ptr->trans[i] != 0xff)

+         {

+            /* The png_composite() macro is defined in png.h */

+            png_composite(palette[i].red, palette[i].red,

+               png_ptr->trans[i], back.red);

+            png_composite(palette[i].green, palette[i].green,

+               png_ptr->trans[i], back.green);

+            png_composite(palette[i].blue, palette[i].blue,

+               png_ptr->trans[i], back.blue);

+         }

+      }

+   }

+#endif /* PNG_READ_BACKGROUND_SUPPORTED */

+#if defined(PNG_READ_SHIFT_SUPPORTED)

+   if ((png_ptr->transformations & PNG_SHIFT) &&

+      (color_type == PNG_COLOR_TYPE_PALETTE))

+   {

+      png_uint_16 i;

+      png_uint_16 istop = png_ptr->num_palette;

+      int sr = 8 - png_ptr->sig_bit.red;

+      int sg = 8 - png_ptr->sig_bit.green;

+      int sb = 8 - png_ptr->sig_bit.blue;

+      if (sr < 0 || sr > 8)

+         sr = 0;

+      if (sg < 0 || sg > 8)

+         sg = 0;

+      if (sb < 0 || sb > 8)

+         sb = 0;

+      for (i = 0; i < istop; i++)

+      {

+         png_ptr->palette[i].red >>= sr;

+         png_ptr->palette[i].green >>= sg;

+         png_ptr->palette[i].blue >>= sb;

+      }

+   }

+#endif  /* PNG_READ_SHIFT_SUPPORTED */

+ }

+#if !defined(PNG_READ_GAMMA_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) \

+ && !defined(PNG_READ_BACKGROUND_SUPPORTED)

+   if(png_ptr)

+      return;

+#endif

+}

+/* Modify the info structure to reflect the transformations.  The

+ * info should be updated so a PNG file could be written with it,

+ * assuming the transformations result in valid PNG data.

+ */

+void /* PRIVATE */

+png_read_transform_info(png_structp png_ptr, png_infop info_ptr)

+{

+   png_debug(1, "in png_read_transform_info\n");

+#if defined(PNG_READ_EXPAND_SUPPORTED)

+   if (png_ptr->transformations & PNG_EXPAND)

+   {

+      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+      {

+         if (png_ptr->num_trans)

+            info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA;

+         else

+            info_ptr->color_type = PNG_COLOR_TYPE_RGB;

+         info_ptr->bit_depth = 8;

+         info_ptr->num_trans = 0;

+      }

+      else

+      {

+         if (png_ptr->num_trans)

+            info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;

+         if (info_ptr->bit_depth < 8)

+            info_ptr->bit_depth = 8;

+         info_ptr->num_trans = 0;

+      }

+   }

+#endif

+#if defined(PNG_READ_BACKGROUND_SUPPORTED)

+   if (png_ptr->transformations & PNG_BACKGROUND)

+   {

+      info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;

+      info_ptr->num_trans = 0;

+      info_ptr->background = png_ptr->background;

+   }

+#endif

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+   if (png_ptr->transformations & PNG_GAMMA)

+   {

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+      info_ptr->gamma = png_ptr->gamma;

+#endif

+#ifdef PNG_FIXED_POINT_SUPPORTED

+      info_ptr->int_gamma = png_ptr->int_gamma;

+#endif

+   }

+#endif

+#if defined(PNG_READ_16_TO_8_SUPPORTED)

+   if ((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16))

+      info_ptr->bit_depth = 8;

+#endif

+#if defined(PNG_READ_DITHER_SUPPORTED)

+   if (png_ptr->transformations & PNG_DITHER)

+   {

+      if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||

+         (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&

+         png_ptr->palette_lookup && info_ptr->bit_depth == 8)

+      {

+         info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;

+      }

+   }

+#endif

+#if defined(PNG_READ_PACK_SUPPORTED)

+   if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8))

+      info_ptr->bit_depth = 8;

+#endif

+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)

+   if (png_ptr->transformations & PNG_GRAY_TO_RGB)

+      info_ptr->color_type |= PNG_COLOR_MASK_COLOR;

+#endif

+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)

+   if (png_ptr->transformations & PNG_RGB_TO_GRAY)

+      info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR;

+#endif

+   if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+      info_ptr->channels = 1;

+   else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)

+      info_ptr->channels = 3;

+   else

+      info_ptr->channels = 1;

+#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)

+   if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)

+      info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;

+#endif

+   if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)

+      info_ptr->channels++;

+#if defined(PNG_READ_FILLER_SUPPORTED)

+   /* STRIP_ALPHA and FILLER allowed:  MASK_ALPHA bit stripped above */

+   if ((png_ptr->transformations & PNG_FILLER) &&

+       ((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||

+       (info_ptr->color_type == PNG_COLOR_TYPE_GRAY)))

+   {

+      info_ptr->channels++;

+      /* if adding a true alpha channel not just filler */

+#if !defined(PNG_1_0_X)

+      if (png_ptr->transformations & PNG_ADD_ALPHA)

+        info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;

+#endif

+   }

+#endif

+#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \

+defined(PNG_READ_USER_TRANSFORM_SUPPORTED)

+   if(png_ptr->transformations & PNG_USER_TRANSFORM)

+     {

+       if(info_ptr->bit_depth < png_ptr->user_transform_depth)

+         info_ptr->bit_depth = png_ptr->user_transform_depth;

+       if(info_ptr->channels < png_ptr->user_transform_channels)

+         info_ptr->channels = png_ptr->user_transform_channels;

+     }

+#endif

+   info_ptr->pixel_depth = (png_byte)(info_ptr->channels *

+      info_ptr->bit_depth);

+   info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth,info_ptr->width);

+#if !defined(PNG_READ_EXPAND_SUPPORTED)

+   if(png_ptr)

+      return;

+#endif

+}

+/* Transform the row.  The order of transformations is significant,

+ * and is very touchy.  If you add a transformation, take care to

+ * decide how it fits in with the other transformations here.

+ */

+void /* PRIVATE */

+png_do_read_transformations(png_structp png_ptr)

+{

+   png_debug(1, "in png_do_read_transformations\n");

+#if !defined(PNG_USELESS_TESTS_SUPPORTED)

+   if (png_ptr->row_buf == NULL)

+   {

+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)

+      char msg[50];

+      sprintf(msg, "NULL row buffer for row %ld, pass %d", png_ptr->row_number,

+         png_ptr->pass);

+      png_error(png_ptr, msg);

+#else

+      png_error(png_ptr, "NULL row buffer");

+#endif

+   }

+#endif

+#if defined(PNG_READ_EXPAND_SUPPORTED)

+   if (png_ptr->transformations & PNG_EXPAND)

+   {

+      if (png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE)

+      {

+         png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1,

+            png_ptr->palette, png_ptr->trans, png_ptr->num_trans);

+      }

+      else

+      {

+         if (png_ptr->num_trans)

+            png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,

+               &(png_ptr->trans_values));

+         else

+            png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,

+               NULL);

+      }

+   }

+#endif

+#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)

+   if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)

+      png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,

+         PNG_FLAG_FILLER_AFTER | (png_ptr->flags & PNG_FLAG_STRIP_ALPHA));

+#endif

+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)

+   if (png_ptr->transformations & PNG_RGB_TO_GRAY)

+   {

+      int rgb_error =

+         png_do_rgb_to_gray(png_ptr, &(png_ptr->row_info), png_ptr->row_buf + 1);

+      if(rgb_error)

+      {

+         png_ptr->rgb_to_gray_status=1;

+         if(png_ptr->transformations == PNG_RGB_TO_GRAY_WARN)

+            png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel");

+         if(png_ptr->transformations == PNG_RGB_TO_GRAY_ERR)

+            png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel");

+      }

+   }

+#endif

+/*

+From Andreas Dilger e-mail to png-implement, 26 March 1998:

+  In most cases, the "simple transparency" should be done prior to doing

+  gray-to-RGB, or you will have to test 3x as many bytes to check if a

+  pixel is transparent.  You would also need to make sure that the

+  transparency information is upgraded to RGB.

+  To summarize, the current flow is:

+  - Gray + simple transparency -> compare 1 or 2 gray bytes and composite

+                                  with background "in place" if transparent,

+                                  convert to RGB if necessary

+  - Gray + alpha -> composite with gray background and remove alpha bytes,

+                                  convert to RGB if necessary

+  To support RGB backgrounds for gray images we need:

+  - Gray + simple transparency -> convert to RGB + simple transparency, compare

+                                  3 or 6 bytes and composite with background

+                                  "in place" if transparent (3x compare/pixel

+                                  compared to doing composite with gray bkgrnd)

+  - Gray + alpha -> convert to RGB + alpha, composite with background and

+                                  remove alpha bytes (3x float operations/pixel

+                                  compared with composite on gray background)

+  Greg's change will do this.  The reason it wasn't done before is for

+  performance, as this increases the per-pixel operations.  If we would check

+  in advance if the background was gray or RGB, and position the gray-to-RGB

+  transform appropriately, then it would save a lot of work/time.

+ */

+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)

+   /* if gray -> RGB, do so now only if background is non-gray; else do later

+    * for performance reasons */

+   if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&

+       !(png_ptr->mode & PNG_BACKGROUND_IS_GRAY))

+      png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);

+#endif

+#if defined(PNG_READ_BACKGROUND_SUPPORTED)

+   if ((png_ptr->transformations & PNG_BACKGROUND) &&

+      ((png_ptr->num_trans != 0 ) ||

+      (png_ptr->color_type & PNG_COLOR_MASK_ALPHA)))

+      png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1,

+         &(png_ptr->trans_values), &(png_ptr->background)

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+         , &(png_ptr->background_1),

+         png_ptr->gamma_table, png_ptr->gamma_from_1,

+         png_ptr->gamma_to_1, png_ptr->gamma_16_table,

+         png_ptr->gamma_16_from_1, png_ptr->gamma_16_to_1,

+         png_ptr->gamma_shift

+#endif

+);

+#endif

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+   if ((png_ptr->transformations & PNG_GAMMA) &&

+#if defined(PNG_READ_BACKGROUND_SUPPORTED)

+      !((png_ptr->transformations & PNG_BACKGROUND) &&

+      ((png_ptr->num_trans != 0) ||

+      (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) &&

+#endif

+      (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE))

+      png_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1,

+         png_ptr->gamma_table, png_ptr->gamma_16_table,

+         png_ptr->gamma_shift);

+#endif

+#if defined(PNG_READ_16_TO_8_SUPPORTED)

+   if (png_ptr->transformations & PNG_16_TO_8)

+      png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1);

+#endif

+#if defined(PNG_READ_DITHER_SUPPORTED)

+   if (png_ptr->transformations & PNG_DITHER)

+   {

+      png_do_dither((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1,

+         png_ptr->palette_lookup, png_ptr->dither_index);

+      if(png_ptr->row_info.rowbytes == (png_uint_32)0)

+         png_error(png_ptr, "png_do_dither returned rowbytes=0");

+   }

+#endif

+#if defined(PNG_READ_INVERT_SUPPORTED)

+   if (png_ptr->transformations & PNG_INVERT_MONO)

+      png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);

+#endif

+#if defined(PNG_READ_SHIFT_SUPPORTED)

+   if (png_ptr->transformations & PNG_SHIFT)

+      png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1,

+         &(png_ptr->shift));

+#endif

+#if defined(PNG_READ_PACK_SUPPORTED)

+   if (png_ptr->transformations & PNG_PACK)

+      png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1);

+#endif

+#if defined(PNG_READ_BGR_SUPPORTED)

+   if (png_ptr->transformations & PNG_BGR)

+      png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);

+#endif

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+   if (png_ptr->transformations & PNG_PACKSWAP)

+      png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);

+#endif

+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)

+   /* if gray -> RGB, do so now only if we did not do so above */

+   if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&

+       (png_ptr->mode & PNG_BACKGROUND_IS_GRAY))

+      png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);

+#endif

+#if defined(PNG_READ_FILLER_SUPPORTED)

+   if (png_ptr->transformations & PNG_FILLER)

+      png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,

+         (png_uint_32)png_ptr->filler, png_ptr->flags);

+#endif

+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)

+   if (png_ptr->transformations & PNG_INVERT_ALPHA)

+      png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);

+#endif

+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)

+   if (png_ptr->transformations & PNG_SWAP_ALPHA)

+      png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);

+#endif

+#if defined(PNG_READ_SWAP_SUPPORTED)

+   if (png_ptr->transformations & PNG_SWAP_BYTES)

+      png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);

+#endif

+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)

+   if (png_ptr->transformations & PNG_USER_TRANSFORM)

+    {

+      if(png_ptr->read_user_transform_fn != NULL)

+        (*(png_ptr->read_user_transform_fn)) /* user read transform function */

+          (png_ptr,                    /* png_ptr */

+           &(png_ptr->row_info),       /* row_info:     */

+             /*  png_uint_32 width;          width of row */

+             /*  png_uint_32 rowbytes;       number of bytes in row */

+             /*  png_byte color_type;        color type of pixels */

+             /*  png_byte bit_depth;         bit depth of samples */

+             /*  png_byte channels;          number of channels (1-4) */

+             /*  png_byte pixel_depth;       bits per pixel (depth*channels) */

+           png_ptr->row_buf + 1);      /* start of pixel data for row */

+#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)

+      if(png_ptr->user_transform_depth)

+         png_ptr->row_info.bit_depth = png_ptr->user_transform_depth;

+      if(png_ptr->user_transform_channels)

+         png_ptr->row_info.channels = png_ptr->user_transform_channels;

+#endif

+      png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *

+         png_ptr->row_info.channels);

+      png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,

+         png_ptr->row_info.width);

+   }

+#endif

+}

+#if defined(PNG_READ_PACK_SUPPORTED)

+/* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel,

+ * without changing the actual values.  Thus, if you had a row with

+ * a bit depth of 1, you would end up with bytes that only contained

+ * the numbers 0 or 1.  If you would rather they contain 0 and 255, use

+ * png_do_shift() after this.

+ */

+void /* PRIVATE */

+png_do_unpack(png_row_infop row_info, png_bytep row)

+{

+   png_debug(1, "in png_do_unpack\n");

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+   if (row != NULL && row_info != NULL && row_info->bit_depth < 8)

+#else

+   if (row_info->bit_depth < 8)

+#endif

+   {

+      png_uint_32 i;

+      png_uint_32 row_width=row_info->width;

+      switch (row_info->bit_depth)

+      {

+         case 1:

+         {

+            png_bytep sp = row + (png_size_t)((row_width - 1) >> 3);

+            png_bytep dp = row + (png_size_t)row_width - 1;

+            png_uint_32 shift = 7 - (int)((row_width + 7) & 0x07);

+            for (i = 0; i < row_width; i++)

+            {

+               *dp = (png_byte)((*sp >> shift) & 0x01);

+               if (shift == 7)

+               {

+                  shift = 0;

+                  sp--;

+               }

+               else

+                  shift++;

+               dp--;

+            }

+            break;

+         }

+         case 2:

+         {

+            png_bytep sp = row + (png_size_t)((row_width - 1) >> 2);

+            png_bytep dp = row + (png_size_t)row_width - 1;

+            png_uint_32 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);

+            for (i = 0; i < row_width; i++)

+            {

+               *dp = (png_byte)((*sp >> shift) & 0x03);

+               if (shift == 6)

+               {

+                  shift = 0;

+                  sp--;

+               }

+               else

+                  shift += 2;

+               dp--;

+            }

+            break;

+         }

+         case 4:

+         {

+            png_bytep sp = row + (png_size_t)((row_width - 1) >> 1);

+            png_bytep dp = row + (png_size_t)row_width - 1;

+            png_uint_32 shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);

+            for (i = 0; i < row_width; i++)

+            {

+               *dp = (png_byte)((*sp >> shift) & 0x0f);

+               if (shift == 4)

+               {

+                  shift = 0;

+                  sp--;

+               }

+               else

+                  shift = 4;

+               dp--;

+            }

+            break;

+         }

+      }

+      row_info->bit_depth = 8;

+      row_info->pixel_depth = (png_byte)(8 * row_info->channels);

+      row_info->rowbytes = row_width * row_info->channels;

+   }

+}

+#endif

+#if defined(PNG_READ_SHIFT_SUPPORTED)

+/* Reverse the effects of png_do_shift.  This routine merely shifts the

+ * pixels back to their significant bits values.  Thus, if you have

+ * a row of bit depth 8, but only 5 are significant, this will shift

+ * the values back to 0 through 31.

+ */

+void /* PRIVATE */

+png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)

+{

+   png_debug(1, "in png_do_unshift\n");

+   if (

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+       row != NULL && row_info != NULL && sig_bits != NULL &&

+#endif

+       row_info->color_type != PNG_COLOR_TYPE_PALETTE)

+   {

+      int shift[4];

+      int channels = 0;

+      int c;

+      png_uint_16 value = 0;

+      png_uint_32 row_width = row_info->width;

+      if (row_info->color_type & PNG_COLOR_MASK_COLOR)

+      {

+         shift[channels++] = row_info->bit_depth - sig_bits->red;

+         shift[channels++] = row_info->bit_depth - sig_bits->green;

+         shift[channels++] = row_info->bit_depth - sig_bits->blue;

+      }

+      else

+      {

+         shift[channels++] = row_info->bit_depth - sig_bits->gray;

+      }

+      if (row_info->color_type & PNG_COLOR_MASK_ALPHA)

+      {

+         shift[channels++] = row_info->bit_depth - sig_bits->alpha;

+      }

+      for (c = 0; c < channels; c++)

+      {

+         if (shift[c] <= 0)

+            shift[c] = 0;

+         else

+            value = 1;

+      }

+      if (!value)

+         return;

+      switch (row_info->bit_depth)

+      {

+         case 2:

+         {

+            png_bytep bp;

+            png_uint_32 i;

+            png_uint_32 istop = row_info->rowbytes;

+            for (bp = row, i = 0; i < istop; i++)

+            {

+               *bp >>= 1;

+               *bp++ &= 0x55;

+            }

+            break;

+         }

+         case 4:

+         {

+            png_bytep bp = row;

+            png_uint_32 i;

+            png_uint_32 istop = row_info->rowbytes;

+            png_byte mask = (png_byte)((((int)0xf0 >> shift[0]) & (int)0xf0) |

+               (png_byte)((int)0xf >> shift[0]));

+            for (i = 0; i < istop; i++)

+            {

+               *bp >>= shift[0];

+               *bp++ &= mask;

+            }

+            break;

+         }

+         case 8:

+         {

+            png_bytep bp = row;

+            png_uint_32 i;

+            png_uint_32 istop = row_width * channels;

+            for (i = 0; i < istop; i++)

+            {

+               *bp++ >>= shift[i%channels];

+            }

+            break;

+         }

+         case 16:

+         {

+            png_bytep bp = row;

+            png_uint_32 i;

+            png_uint_32 istop = channels * row_width;

+            for (i = 0; i < istop; i++)

+            {

+               value = (png_uint_16)((*bp << 8) + *(bp + 1));

+               value >>= shift[i%channels];

+               *bp++ = (png_byte)(value >> 8);

+               *bp++ = (png_byte)(value & 0xff);

+            }

+            break;

+         }

+      }

+   }

+}

+#endif

+#if defined(PNG_READ_16_TO_8_SUPPORTED)

+/* chop rows of bit depth 16 down to 8 */

+void /* PRIVATE */

+png_do_chop(png_row_infop row_info, png_bytep row)

+{

+   png_debug(1, "in png_do_chop\n");

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+   if (row != NULL && row_info != NULL && row_info->bit_depth == 16)

+#else

+   if (row_info->bit_depth == 16)

+#endif

+   {

+      png_bytep sp = row;

+      png_bytep dp = row;

+      png_uint_32 i;

+      png_uint_32 istop = row_info->width * row_info->channels;

+      for (i = 0; i<istop; i++, sp += 2, dp++)

+      {

+#if defined(PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED)

+      /* This does a more accurate scaling of the 16-bit color

+       * value, rather than a simple low-byte truncation.

+       *

+       * What the ideal calculation should be:

+       *   *dp = (((((png_uint_32)(*sp) << 8) |

+       *          (png_uint_32)(*(sp + 1))) * 255 + 127) / (png_uint_32)65535L;

+       *

+       * GRR: no, I think this is what it really should be:

+       *   *dp = (((((png_uint_32)(*sp) << 8) |

+       *           (png_uint_32)(*(sp + 1))) + 128L) / (png_uint_32)257L;

+       *

+       * GRR: here's the exact calculation with shifts:

+       *   temp = (((png_uint_32)(*sp) << 8) | (png_uint_32)(*(sp + 1))) + 128L;

+       *   *dp = (temp - (temp >> 8)) >> 8;

+       *

+       * Approximate calculation with shift/add instead of multiply/divide:

+       *   *dp = ((((png_uint_32)(*sp) << 8) |

+       *          (png_uint_32)((int)(*(sp + 1)) - *sp)) + 128) >> 8;

+       *

+       * What we actually do to avoid extra shifting and conversion:

+       */

+         *dp = *sp + ((((int)(*(sp + 1)) - *sp) > 128) ? 1 : 0);

+#else

+       /* Simply discard the low order byte */

+         *dp = *sp;

+#endif

+      }

+      row_info->bit_depth = 8;

+      row_info->pixel_depth = (png_byte)(8 * row_info->channels);

+      row_info->rowbytes = row_info->width * row_info->channels;

+   }

+}

+#endif

+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)

+void /* PRIVATE */

+png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)

+{

+   png_debug(1, "in png_do_read_swap_alpha\n");

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+   if (row != NULL && row_info != NULL)

+#endif

+   {

+      png_uint_32 row_width = row_info->width;

+      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+      {

+         /* This converts from RGBA to ARGB */

+         if (row_info->bit_depth == 8)

+         {

+            png_bytep sp = row + row_info->rowbytes;

+            png_bytep dp = sp;

+            png_byte save;

+            png_uint_32 i;

+            for (i = 0; i < row_width; i++)

+            {

+               save = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = save;

+            }

+         }

+         /* This converts from RRGGBBAA to AARRGGBB */

+         else

+         {

+            png_bytep sp = row + row_info->rowbytes;

+            png_bytep dp = sp;

+            png_byte save[2];

+            png_uint_32 i;

+            for (i = 0; i < row_width; i++)

+            {

+               save[0] = *(--sp);

+               save[1] = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = save[0];

+               *(--dp) = save[1];

+            }

+         }

+      }

+      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

+      {

+         /* This converts from GA to AG */

+         if (row_info->bit_depth == 8)

+         {

+            png_bytep sp = row + row_info->rowbytes;

+            png_bytep dp = sp;

+            png_byte save;

+            png_uint_32 i;

+            for (i = 0; i < row_width; i++)

+            {

+               save = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = save;

+            }

+         }

+         /* This converts from GGAA to AAGG */

+         else

+         {

+            png_bytep sp = row + row_info->rowbytes;

+            png_bytep dp = sp;

+            png_byte save[2];

+            png_uint_32 i;

+            for (i = 0; i < row_width; i++)

+            {

+               save[0] = *(--sp);

+               save[1] = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = save[0];

+               *(--dp) = save[1];

+            }

+         }

+      }

+   }

+}

+#endif

+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)

+void /* PRIVATE */

+png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)

+{

+   png_debug(1, "in png_do_read_invert_alpha\n");

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+   if (row != NULL && row_info != NULL)

+#endif

+   {

+      png_uint_32 row_width = row_info->width;

+      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+      {

+         /* This inverts the alpha channel in RGBA */

+         if (row_info->bit_depth == 8)

+         {

+            png_bytep sp = row + row_info->rowbytes;

+            png_bytep dp = sp;

+            png_uint_32 i;

+            for (i = 0; i < row_width; i++)

+            {

+               *(--dp) = (png_byte)(255 - *(--sp));

+/*             This does nothing:

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               We can replace it with:

+*/

+               sp-=3;

+               dp=sp;

+            }

+         }

+         /* This inverts the alpha channel in RRGGBBAA */

+         else

+         {

+            png_bytep sp = row + row_info->rowbytes;

+            png_bytep dp = sp;

+            png_uint_32 i;

+            for (i = 0; i < row_width; i++)

+            {

+               *(--dp) = (png_byte)(255 - *(--sp));

+               *(--dp) = (png_byte)(255 - *(--sp));

+/*             This does nothing:

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               We can replace it with:

+*/

+               sp-=6;

+               dp=sp;

+            }

+         }

+      }

+      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

+      {

+         /* This inverts the alpha channel in GA */

+         if (row_info->bit_depth == 8)

+         {

+            png_bytep sp = row + row_info->rowbytes;

+            png_bytep dp = sp;

+            png_uint_32 i;

+            for (i = 0; i < row_width; i++)

+            {

+               *(--dp) = (png_byte)(255 - *(--sp));

+               *(--dp) = *(--sp);

+            }

+         }

+         /* This inverts the alpha channel in GGAA */

+         else

+         {

+            png_bytep sp  = row + row_info->rowbytes;

+            png_bytep dp = sp;

+            png_uint_32 i;

+            for (i = 0; i < row_width; i++)

+            {

+               *(--dp) = (png_byte)(255 - *(--sp));

+               *(--dp) = (png_byte)(255 - *(--sp));

+/*

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+*/

+               sp-=2;

+               dp=sp;

+            }

+         }

+      }

+   }

+}

+#endif

+#if defined(PNG_READ_FILLER_SUPPORTED)

+/* Add filler channel if we have RGB color */

+void /* PRIVATE */

+png_do_read_filler(png_row_infop row_info, png_bytep row,

+   png_uint_32 filler, png_uint_32 flags)

+{

+   png_uint_32 i;

+   png_uint_32 row_width = row_info->width;

+   png_byte hi_filler = (png_byte)((filler>>8) & 0xff);

+   png_byte lo_filler = (png_byte)(filler & 0xff);

+   png_debug(1, "in png_do_read_filler\n");

+   if (

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+       row != NULL  && row_info != NULL &&

+#endif

+       row_info->color_type == PNG_COLOR_TYPE_GRAY)

+   {

+      if(row_info->bit_depth == 8)

+      {

+         /* This changes the data from G to GX */

+         if (flags & PNG_FLAG_FILLER_AFTER)

+         {

+            png_bytep sp = row + (png_size_t)row_width;

+            png_bytep dp =  sp + (png_size_t)row_width;

+            for (i = 1; i < row_width; i++)

+            {

+               *(--dp) = lo_filler;

+               *(--dp) = *(--sp);

+            }

+            *(--dp) = lo_filler;

+            row_info->channels = 2;

+            row_info->pixel_depth = 16;

+            row_info->rowbytes = row_width * 2;

+         }

+      /* This changes the data from G to XG */

+         else

+         {

+            png_bytep sp = row + (png_size_t)row_width;

+            png_bytep dp = sp  + (png_size_t)row_width;

+            for (i = 0; i < row_width; i++)

+            {

+               *(--dp) = *(--sp);

+               *(--dp) = lo_filler;

+            }

+            row_info->channels = 2;

+            row_info->pixel_depth = 16;

+            row_info->rowbytes = row_width * 2;

+         }

+      }

+      else if(row_info->bit_depth == 16)

+      {

+         /* This changes the data from GG to GGXX */

+         if (flags & PNG_FLAG_FILLER_AFTER)

+         {

+            png_bytep sp = row + (png_size_t)row_width * 2;

+            png_bytep dp = sp  + (png_size_t)row_width * 2;

+            for (i = 1; i < row_width; i++)

+            {

+               *(--dp) = hi_filler;

+               *(--dp) = lo_filler;

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+            }

+            *(--dp) = hi_filler;

+            *(--dp) = lo_filler;

+            row_info->channels = 2;

+            row_info->pixel_depth = 32;

+            row_info->rowbytes = row_width * 4;

+         }

+         /* This changes the data from GG to XXGG */

+         else

+         {

+            png_bytep sp = row + (png_size_t)row_width * 2;

+            png_bytep dp = sp  + (png_size_t)row_width * 2;

+            for (i = 0; i < row_width; i++)

+            {

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = hi_filler;

+               *(--dp) = lo_filler;

+            }

+            row_info->channels = 2;

+            row_info->pixel_depth = 32;

+            row_info->rowbytes = row_width * 4;

+         }

+      }

+   } /* COLOR_TYPE == GRAY */

+   else if (row_info->color_type == PNG_COLOR_TYPE_RGB)

+   {

+      if(row_info->bit_depth == 8)

+      {

+         /* This changes the data from RGB to RGBX */

+         if (flags & PNG_FLAG_FILLER_AFTER)

+         {

+            png_bytep sp = row + (png_size_t)row_width * 3;

+            png_bytep dp = sp  + (png_size_t)row_width;

+            for (i = 1; i < row_width; i++)

+            {

+               *(--dp) = lo_filler;

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+            }

+            *(--dp) = lo_filler;

+            row_info->channels = 4;

+            row_info->pixel_depth = 32;

+            row_info->rowbytes = row_width * 4;

+         }

+      /* This changes the data from RGB to XRGB */

+         else

+         {

+            png_bytep sp = row + (png_size_t)row_width * 3;

+            png_bytep dp = sp + (png_size_t)row_width;

+            for (i = 0; i < row_width; i++)

+            {

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = lo_filler;

+            }

+            row_info->channels = 4;

+            row_info->pixel_depth = 32;

+            row_info->rowbytes = row_width * 4;

+         }

+      }

+      else if(row_info->bit_depth == 16)

+      {

+         /* This changes the data from RRGGBB to RRGGBBXX */

+         if (flags & PNG_FLAG_FILLER_AFTER)

+         {

+            png_bytep sp = row + (png_size_t)row_width * 6;

+            png_bytep dp = sp  + (png_size_t)row_width * 2;

+            for (i = 1; i < row_width; i++)

+            {

+               *(--dp) = hi_filler;

+               *(--dp) = lo_filler;

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+            }

+            *(--dp) = hi_filler;

+            *(--dp) = lo_filler;

+            row_info->channels = 4;

+            row_info->pixel_depth = 64;

+            row_info->rowbytes = row_width * 8;

+         }

+         /* This changes the data from RRGGBB to XXRRGGBB */

+         else

+         {

+            png_bytep sp = row + (png_size_t)row_width * 6;

+            png_bytep dp = sp  + (png_size_t)row_width * 2;

+            for (i = 0; i < row_width; i++)

+            {

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = *(--sp);

+               *(--dp) = hi_filler;

+               *(--dp) = lo_filler;

+            }

+            row_info->channels = 4;

+            row_info->pixel_depth = 64;

+            row_info->rowbytes = row_width * 8;

+         }

+      }

+   } /* COLOR_TYPE == RGB */

+}

+#endif

+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)

+/* expand grayscale files to RGB, with or without alpha */

+void /* PRIVATE */

+png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)

+{

+   png_uint_32 i;

+   png_uint_32 row_width = row_info->width;

+   png_debug(1, "in png_do_gray_to_rgb\n");

+   if (row_info->bit_depth >= 8 &&

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+       row != NULL && row_info != NULL &&

+#endif

+      !(row_info->color_type & PNG_COLOR_MASK_COLOR))

+   {

+      if (row_info->color_type == PNG_COLOR_TYPE_GRAY)

+      {

+         if (row_info->bit_depth == 8)

+         {

+            png_bytep sp = row + (png_size_t)row_width - 1;

+            png_bytep dp = sp  + (png_size_t)row_width * 2;

+            for (i = 0; i < row_width; i++)

+            {

+               *(dp--) = *sp;

+               *(dp--) = *sp;

+               *(dp--) = *(sp--);

+            }

+         }

+         else

+         {

+            png_bytep sp = row + (png_size_t)row_width * 2 - 1;

+            png_bytep dp = sp  + (png_size_t)row_width * 4;

+            for (i = 0; i < row_width; i++)

+            {

+               *(dp--) = *sp;

+               *(dp--) = *(sp - 1);

+               *(dp--) = *sp;

+               *(dp--) = *(sp - 1);

+               *(dp--) = *(sp--);

+               *(dp--) = *(sp--);

+            }

+         }

+      }

+      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

+      {

+         if (row_info->bit_depth == 8)

+         {

+            png_bytep sp = row + (png_size_t)row_width * 2 - 1;

+            png_bytep dp = sp  + (png_size_t)row_width * 2;

+            for (i = 0; i < row_width; i++)

+            {

+               *(dp--) = *(sp--);

+               *(dp--) = *sp;

+               *(dp--) = *sp;

+               *(dp--) = *(sp--);

+            }

+         }

+         else

+         {

+            png_bytep sp = row + (png_size_t)row_width * 4 - 1;

+            png_bytep dp = sp  + (png_size_t)row_width * 4;

+            for (i = 0; i < row_width; i++)

+            {

+               *(dp--) = *(sp--);

+               *(dp--) = *(sp--);

+               *(dp--) = *sp;

+               *(dp--) = *(sp - 1);

+               *(dp--) = *sp;

+               *(dp--) = *(sp - 1);

+               *(dp--) = *(sp--);

+               *(dp--) = *(sp--);

+            }

+         }

+      }

+      row_info->channels += (png_byte)2;

+      row_info->color_type |= PNG_COLOR_MASK_COLOR;

+      row_info->pixel_depth = (png_byte)(row_info->channels *

+         row_info->bit_depth);

+      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width);

+   }

+}

+#endif

+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)

+/* reduce RGB files to grayscale, with or without alpha

+ * using the equation given in Poynton's ColorFAQ at

+ * <http://www.inforamp.net/~poynton/>

+ * Copyright (c) 1998-01-04 Charles Poynton poynton at inforamp.net

+ *

+ *     Y = 0.212671 * R + 0.715160 * G + 0.072169 * B

+ *

+ *  We approximate this with

+ *

+ *     Y = 0.21268 * R    + 0.7151 * G    + 0.07217 * B

+ *

+ *  which can be expressed with integers as

+ *

+ *     Y = (6969 * R + 23434 * G + 2365 * B)/32768

+ *

+ *  The calculation is to be done in a linear colorspace.

+ *

+ *  Other integer coefficents can be used via png_set_rgb_to_gray().

+ */

+int /* PRIVATE */

+png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row)

+{

+   png_uint_32 i;

+   png_uint_32 row_width = row_info->width;

+   int rgb_error = 0;

+   png_debug(1, "in png_do_rgb_to_gray\n");

+   if (

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+       row != NULL && row_info != NULL &&

+#endif

+      (row_info->color_type & PNG_COLOR_MASK_COLOR))

+   {

+      png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff;

+      png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff;

+      png_uint_32 bc = png_ptr->rgb_to_gray_blue_coeff;

+      if (row_info->color_type == PNG_COLOR_TYPE_RGB)

+      {

+         if (row_info->bit_depth == 8)

+         {

+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

+            if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)

+            {

+               png_bytep sp = row;

+               png_bytep dp = row;

+               for (i = 0; i < row_width; i++)

+               {

+                  png_byte red   = png_ptr->gamma_to_1[*(sp++)];

+                  png_byte green = png_ptr->gamma_to_1[*(sp++)];

+                  png_byte blue  = png_ptr->gamma_to_1[*(sp++)];

+                  if(red != green || red != blue)

+                  {

+                     rgb_error |= 1;

+                     *(dp++) = png_ptr->gamma_from_1[

+                       (rc*red+gc*green+bc*blue)>>15];

+                  }

+                  else

+                     *(dp++) = *(sp-1);

+               }

+            }

+            else

+#endif

+            {

+               png_bytep sp = row;

+               png_bytep dp = row;

+               for (i = 0; i < row_width; i++)

+               {

+                  png_byte red   = *(sp++);

+                  png_byte green = *(sp++);

+                  png_byte blue  = *(sp++);

+                  if(red != green || red != blue)

+                  {

+                     rgb_error |= 1;

+                     *(dp++) = (png_byte)((rc*red+gc*green+bc*blue)>>15);

+                  }

+                  else

+                     *(dp++) = *(sp-1);

+               }

+            }

+         }

+         else /* RGB bit_depth == 16 */

+         {

+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

+            if (png_ptr->gamma_16_to_1 != NULL &&

+                png_ptr->gamma_16_from_1 != NULL)

+            {

+               png_bytep sp = row;

+               png_bytep dp = row;

+               for (i = 0; i < row_width; i++)

+               {

+                  png_uint_16 red, green, blue, w;

+                  red   = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

+                  green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

+                  blue  = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

+                  if(red == green && red == blue)

+                     w = red;

+                  else

+                  {

+                     png_uint_16 red_1   = png_ptr->gamma_16_to_1[(red&0xff) >>

+                                  png_ptr->gamma_shift][red>>8];

+                     png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >>

+                                  png_ptr->gamma_shift][green>>8];

+                     png_uint_16 blue_1  = png_ptr->gamma_16_to_1[(blue&0xff) >>

+                                  png_ptr->gamma_shift][blue>>8];

+                     png_uint_16 gray16  = (png_uint_16)((rc*red_1 + gc*green_1

+                                  + bc*blue_1)>>15);

+                     w = png_ptr->gamma_16_from_1[(gray16&0xff) >>

+                         png_ptr->gamma_shift][gray16 >> 8];

+                     rgb_error |= 1;

+                  }

+                  *(dp++) = (png_byte)((w>>8) & 0xff);

+                  *(dp++) = (png_byte)(w & 0xff);

+               }

+            }

+            else

+#endif

+            {

+               png_bytep sp = row;

+               png_bytep dp = row;

+               for (i = 0; i < row_width; i++)

+               {

+                  png_uint_16 red, green, blue, gray16;

+                  red   = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

+                  green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

+                  blue  = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

+                  if(red != green || red != blue)

+                     rgb_error |= 1;

+                  gray16  = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);

+                  *(dp++) = (png_byte)((gray16>>8) & 0xff);

+                  *(dp++) = (png_byte)(gray16 & 0xff);

+               }

+            }

+         }

+      }

+      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+      {

+         if (row_info->bit_depth == 8)

+         {

+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

+            if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)

+            {

+               png_bytep sp = row;

+               png_bytep dp = row;

+               for (i = 0; i < row_width; i++)

+               {

+                  png_byte red   = png_ptr->gamma_to_1[*(sp++)];

+                  png_byte green = png_ptr->gamma_to_1[*(sp++)];

+                  png_byte blue  = png_ptr->gamma_to_1[*(sp++)];

+                  if(red != green || red != blue)

+                     rgb_error |= 1;

+                  *(dp++) =  png_ptr->gamma_from_1

+                             [(rc*red + gc*green + bc*blue)>>15];

+                  *(dp++) = *(sp++);  /* alpha */

+               }

+            }

+            else

+#endif

+            {

+               png_bytep sp = row;

+               png_bytep dp = row;

+               for (i = 0; i < row_width; i++)

+               {

+                  png_byte red   = *(sp++);

+                  png_byte green = *(sp++);

+                  png_byte blue  = *(sp++);

+                  if(red != green || red != blue)

+                     rgb_error |= 1;

+                  *(dp++) =  (png_byte)((rc*red + gc*green + bc*blue)>>15);

+                  *(dp++) = *(sp++);  /* alpha */

+               }

+            }

+         }

+         else /* RGBA bit_depth == 16 */

+         {

+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

+            if (png_ptr->gamma_16_to_1 != NULL &&

+                png_ptr->gamma_16_from_1 != NULL)

+            {

+               png_bytep sp = row;

+               png_bytep dp = row;

+               for (i = 0; i < row_width; i++)

+               {

+                  png_uint_16 red, green, blue, w;

+                  red   = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

+                  green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

+                  blue  = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;

+                  if(red == green && red == blue)

+                     w = red;

+                  else

+                  {

+                     png_uint_16 red_1   = png_ptr->gamma_16_to_1[(red&0xff) >>

+                                  png_ptr->gamma_shift][red>>8];

+                     png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >>

+                                  png_ptr->gamma_shift][green>>8];

+                     png_uint_16 blue_1  = png_ptr->gamma_16_to_1[(blue&0xff) >>

+                                  png_ptr->gamma_shift][blue>>8];

+                     png_uint_16 gray16  = (png_uint_16)((rc * red_1

+                                  + gc * green_1 + bc * blue_1)>>15);

+                     w = png_ptr->gamma_16_from_1[(gray16&0xff) >>

+                         png_ptr->gamma_shift][gray16 >> 8];

+                     rgb_error |= 1;

+                  }

+                  *(dp++) = (png_byte)((w>>8) & 0xff);

+                  *(dp++) = (png_byte)(w & 0xff);

+                  *(dp++) = *(sp++);  /* alpha */

+                  *(dp++) = *(sp++);

+               }

+            }

+            else

+#endif

+            {

+               png_bytep sp = row;

+               png_bytep dp = row;

+               for (i = 0; i < row_width; i++)

+               {

+                  png_uint_16 red, green, blue, gray16;

+                  red   = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;

+                  green = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;

+                  blue  = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;

+                  if(red != green || red != blue)

+                     rgb_error |= 1;

+                  gray16  = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);

+                  *(dp++) = (png_byte)((gray16>>8) & 0xff);

+                  *(dp++) = (png_byte)(gray16 & 0xff);

+                  *(dp++) = *(sp++);  /* alpha */

+                  *(dp++) = *(sp++);

+               }

+            }

+         }

+      }

+   row_info->channels -= (png_byte)2;

+      row_info->color_type &= ~PNG_COLOR_MASK_COLOR;

+      row_info->pixel_depth = (png_byte)(row_info->channels *

+         row_info->bit_depth);

+      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width);

+   }

+   return rgb_error;

+}

+#endif

+/* Build a grayscale palette.  Palette is assumed to be 1 << bit_depth

+ * large of png_color.  This lets grayscale images be treated as

+ * paletted.  Most useful for gamma correction and simplification

+ * of code.

+ */

+void PNGAPI

+png_build_grayscale_palette(int bit_depth, png_colorp palette)

+{

+   int num_palette;

+   int color_inc;

+   int i;

+   int v;

+   png_debug(1, "in png_do_build_grayscale_palette\n");

+   if (palette == NULL)

+      return;

+   switch (bit_depth)

+   {

+      case 1:

+         num_palette = 2;

+         color_inc = 0xff;

+         break;

+      case 2:

+         num_palette = 4;

+         color_inc = 0x55;

+         break;

+      case 4:

+         num_palette = 16;

+         color_inc = 0x11;

+         break;

+      case 8:

+         num_palette = 256;

+         color_inc = 1;

+         break;

+      default:

+         num_palette = 0;

+         color_inc = 0;

+         break;

+   }

+   for (i = 0, v = 0; i < num_palette; i++, v += color_inc)

+   {

+      palette[i].red = (png_byte)v;

+      palette[i].green = (png_byte)v;

+      palette[i].blue = (png_byte)v;

+   }

+}

+/* This function is currently unused.  Do we really need it? */

+#if defined(PNG_READ_DITHER_SUPPORTED) && defined(PNG_CORRECT_PALETTE_SUPPORTED)

+void /* PRIVATE */

+png_correct_palette(png_structp png_ptr, png_colorp palette,

+   int num_palette)

+{

+   png_debug(1, "in png_correct_palette\n");

+#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \

+    defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)

+   if (png_ptr->transformations & (PNG_GAMMA | PNG_BACKGROUND))

+   {

+      png_color back, back_1;

+      if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)

+      {

+         back.red = png_ptr->gamma_table[png_ptr->background.red];

+         back.green = png_ptr->gamma_table[png_ptr->background.green];

+         back.blue = png_ptr->gamma_table[png_ptr->background.blue];

+         back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];

+         back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];

+         back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];

+      }

+      else

+      {

+         double g;

+         g = 1.0 / (png_ptr->background_gamma * png_ptr->screen_gamma);

+         if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_SCREEN ||

+             fabs(g - 1.0) < PNG_GAMMA_THRESHOLD)

+         {

+            back.red = png_ptr->background.red;

+            back.green = png_ptr->background.green;

+            back.blue = png_ptr->background.blue;

+         }

+         else

+         {

+            back.red =

+               (png_byte)(pow((double)png_ptr->background.red/255, g) *

+                255.0 + 0.5);

+            back.green =

+               (png_byte)(pow((double)png_ptr->background.green/255, g) *

+                255.0 + 0.5);

+            back.blue =

+               (png_byte)(pow((double)png_ptr->background.blue/255, g) *

+                255.0 + 0.5);

+         }

+         g = 1.0 / png_ptr->background_gamma;

+         back_1.red =

+            (png_byte)(pow((double)png_ptr->background.red/255, g) *

+             255.0 + 0.5);

+         back_1.green =

+            (png_byte)(pow((double)png_ptr->background.green/255, g) *

+             255.0 + 0.5);

+         back_1.blue =

+            (png_byte)(pow((double)png_ptr->background.blue/255, g) *

+             255.0 + 0.5);

+      }

+      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+      {

+         png_uint_32 i;

+         for (i = 0; i < (png_uint_32)num_palette; i++)

+         {

+            if (i < png_ptr->num_trans && png_ptr->trans[i] == 0)

+            {

+               palette[i] = back;

+            }

+            else if (i < png_ptr->num_trans && png_ptr->trans[i] != 0xff)

+            {

+               png_byte v, w;

+               v = png_ptr->gamma_to_1[png_ptr->palette[i].red];

+               png_composite(w, v, png_ptr->trans[i], back_1.red);

+               palette[i].red = png_ptr->gamma_from_1[w];

+               v = png_ptr->gamma_to_1[png_ptr->palette[i].green];

+               png_composite(w, v, png_ptr->trans[i], back_1.green);

+               palette[i].green = png_ptr->gamma_from_1[w];

+               v = png_ptr->gamma_to_1[png_ptr->palette[i].blue];

+               png_composite(w, v, png_ptr->trans[i], back_1.blue);

+               palette[i].blue = png_ptr->gamma_from_1[w];

+            }

+            else

+            {

+               palette[i].red = png_ptr->gamma_table[palette[i].red];

+               palette[i].green = png_ptr->gamma_table[palette[i].green];

+               palette[i].blue = png_ptr->gamma_table[palette[i].blue];

+            }

+         }

+      }

+      else

+      {

+         int i;

+         for (i = 0; i < num_palette; i++)

+         {

+            if (palette[i].red == (png_byte)png_ptr->trans_values.gray)

+            {

+               palette[i] = back;

+            }

+            else

+            {

+               palette[i].red = png_ptr->gamma_table[palette[i].red];

+               palette[i].green = png_ptr->gamma_table[palette[i].green];

+               palette[i].blue = png_ptr->gamma_table[palette[i].blue];

+            }

+         }

+      }

+   }

+   else

+#endif

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+   if (png_ptr->transformations & PNG_GAMMA)

+   {

+      int i;

+      for (i = 0; i < num_palette; i++)

+      {

+         palette[i].red = png_ptr->gamma_table[palette[i].red];

+         palette[i].green = png_ptr->gamma_table[palette[i].green];

+         palette[i].blue = png_ptr->gamma_table[palette[i].blue];

+      }

+   }

+#if defined(PNG_READ_BACKGROUND_SUPPORTED)

+   else

+#endif

+#endif

+#if defined(PNG_READ_BACKGROUND_SUPPORTED)

+   if (png_ptr->transformations & PNG_BACKGROUND)

+   {

+      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+      {

+         png_color back;

+         back.red   = (png_byte)png_ptr->background.red;

+         back.green = (png_byte)png_ptr->background.green;

+         back.blue  = (png_byte)png_ptr->background.blue;

+         for (i = 0; i < (int)png_ptr->num_trans; i++)

+         {

+            if (png_ptr->trans[i] == 0)

+            {

+               palette[i].red = back.red;

+               palette[i].green = back.green;

+               palette[i].blue = back.blue;

+            }

+            else if (png_ptr->trans[i] != 0xff)

+            {

+               png_composite(palette[i].red, png_ptr->palette[i].red,

+                  png_ptr->trans[i], back.red);

+               png_composite(palette[i].green, png_ptr->palette[i].green,

+                  png_ptr->trans[i], back.green);

+               png_composite(palette[i].blue, png_ptr->palette[i].blue,

+                  png_ptr->trans[i], back.blue);

+            }

+         }

+      }

+      else /* assume grayscale palette (what else could it be?) */

+      {

+         int i;

+         for (i = 0; i < num_palette; i++)

+         {

+            if (i == (png_byte)png_ptr->trans_values.gray)

+            {

+               palette[i].red = (png_byte)png_ptr->background.red;

+               palette[i].green = (png_byte)png_ptr->background.green;

+               palette[i].blue = (png_byte)png_ptr->background.blue;

+            }

+         }

+      }

+   }

+#endif

+}

+#endif

+#if defined(PNG_READ_BACKGROUND_SUPPORTED)

+/* Replace any alpha or transparency with the supplied background color.

+ * "background" is already in the screen gamma, while "background_1" is

+ * at a gamma of 1.0.  Paletted files have already been taken care of.

+ */

+void /* PRIVATE */

+png_do_background(png_row_infop row_info, png_bytep row,

+   png_color_16p trans_values, png_color_16p background

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+   , png_color_16p background_1,

+   png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,

+   png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,

+   png_uint_16pp gamma_16_to_1, int gamma_shift

+#endif

+   )

+{

+   png_bytep sp, dp;

+   png_uint_32 i;

+   png_uint_32 row_width=row_info->width;

+   int shift;

+   png_debug(1, "in png_do_background\n");

+   if (background != NULL &&

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+       row != NULL && row_info != NULL &&

+#endif

+      (!(row_info->color_type & PNG_COLOR_MASK_ALPHA) ||

+      (row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_values)))

+   {

+      switch (row_info->color_type)

+      {

+         case PNG_COLOR_TYPE_GRAY:

+         {

+            switch (row_info->bit_depth)

+            {

+               case 1:

+               {

+                  sp = row;

+                  shift = 7;

+                  for (i = 0; i < row_width; i++)

+                  {

+                     if ((png_uint_16)((*sp >> shift) & 0x01)

+                        == trans_values->gray)

+                     {

+                        *sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);

+                        *sp |= (png_byte)(background->gray << shift);

+                     }

+                     if (!shift)

+                     {

+                        shift = 7;

+                        sp++;

+                     }

+                     else

+                        shift--;

+                  }

+                  break;

+               }

+               case 2:

+               {

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+                  if (gamma_table != NULL)

+                  {

+                     sp = row;

+                     shift = 6;

+                     for (i = 0; i < row_width; i++)

+                     {

+                        if ((png_uint_16)((*sp >> shift) & 0x03)

+                            == trans_values->gray)

+                        {

+                           *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);

+                           *sp |= (png_byte)(background->gray << shift);

+                        }

+                        else

+                        {

+                           png_byte p = (png_byte)((*sp >> shift) & 0x03);

+                           png_byte g = (png_byte)((gamma_table [p | (p << 2) |

+                               (p << 4) | (p << 6)] >> 6) & 0x03);

+                           *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);

+                           *sp |= (png_byte)(g << shift);

+                        }

+                        if (!shift)

+                        {

+                           shift = 6;

+                           sp++;

+                        }

+                        else

+                           shift -= 2;

+                     }

+                  }

+                  else

+#endif

+                  {

+                     sp = row;

+                     shift = 6;

+                     for (i = 0; i < row_width; i++)

+                     {

+                        if ((png_uint_16)((*sp >> shift) & 0x03)

+                            == trans_values->gray)

+                        {

+                           *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);

+                           *sp |= (png_byte)(background->gray << shift);

+                        }

+                        if (!shift)

+                        {

+                           shift = 6;

+                           sp++;

+                        }

+                        else

+                           shift -= 2;

+                     }

+                  }

+                  break;

+               }

+               case 4:

+               {

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+                  if (gamma_table != NULL)

+                  {

+                     sp = row;

+                     shift = 4;

+                     for (i = 0; i < row_width; i++)

+                     {

+                        if ((png_uint_16)((*sp >> shift) & 0x0f)

+                            == trans_values->gray)

+                        {

+                           *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);

+                           *sp |= (png_byte)(background->gray << shift);

+                        }

+                        else

+                        {

+                           png_byte p = (png_byte)((*sp >> shift) & 0x0f);

+                           png_byte g = (png_byte)((gamma_table[p |

+                             (p << 4)] >> 4) & 0x0f);

+                           *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);

+                           *sp |= (png_byte)(g << shift);

+                        }

+                        if (!shift)

+                        {

+                           shift = 4;

+                           sp++;

+                        }

+                        else

+                           shift -= 4;

+                     }

+                  }

+                  else

+#endif

+                  {

+                     sp = row;

+                     shift = 4;

+                     for (i = 0; i < row_width; i++)

+                     {

+                        if ((png_uint_16)((*sp >> shift) & 0x0f)

+                            == trans_values->gray)

+                        {

+                           *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);

+                           *sp |= (png_byte)(background->gray << shift);

+                        }

+                        if (!shift)

+                        {

+                           shift = 4;

+                           sp++;

+                        }

+                        else

+                           shift -= 4;

+                     }

+                  }

+                  break;

+               }

+               case 8:

+               {

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+                  if (gamma_table != NULL)

+                  {

+                     sp = row;

+                     for (i = 0; i < row_width; i++, sp++)

+                     {

+                        if (*sp == trans_values->gray)

+                        {

+                           *sp = (png_byte)background->gray;

+                        }

+                        else

+                        {

+                           *sp = gamma_table[*sp];

+                        }

+                     }

+                  }

+                  else

+#endif

+                  {

+                     sp = row;

+                     for (i = 0; i < row_width; i++, sp++)

+                     {

+                        if (*sp == trans_values->gray)

+                        {

+                           *sp = (png_byte)background->gray;

+                        }

+                     }

+                  }

+                  break;

+               }

+               case 16:

+               {

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+                  if (gamma_16 != NULL)

+                  {

+                     sp = row;

+                     for (i = 0; i < row_width; i++, sp += 2)

+                     {

+                        png_uint_16 v;

+                        v = (png_uint_16)(((*sp) << 8) + *(sp + 1));

+                        if (v == trans_values->gray)

+                        {

+                           /* background is already in screen gamma */

+                           *sp = (png_byte)((background->gray >> 8) & 0xff);

+                           *(sp + 1) = (png_byte)(background->gray & 0xff);

+                        }

+                        else

+                        {

+                           v = gamma_16[*(sp + 1) >> gamma_shift][*sp];

+                           *sp = (png_byte)((v >> 8) & 0xff);

+                           *(sp + 1) = (png_byte)(v & 0xff);

+                        }

+                     }

+                  }

+                  else

+#endif

+                  {

+                     sp = row;

+                     for (i = 0; i < row_width; i++, sp += 2)

+                     {

+                        png_uint_16 v;

+                        v = (png_uint_16)(((*sp) << 8) + *(sp + 1));

+                        if (v == trans_values->gray)

+                        {

+                           *sp = (png_byte)((background->gray >> 8) & 0xff);

+                           *(sp + 1) = (png_byte)(background->gray & 0xff);

+                        }

+                     }

+                  }

+                  break;

+               }

+            }

+            break;

+         }

+         case PNG_COLOR_TYPE_RGB:

+         {

+            if (row_info->bit_depth == 8)

+            {

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+               if (gamma_table != NULL)

+               {

+                  sp = row;

+                  for (i = 0; i < row_width; i++, sp += 3)

+                  {

+                     if (*sp == trans_values->red &&

+                        *(sp + 1) == trans_values->green &&

+                        *(sp + 2) == trans_values->blue)

+                     {

+                        *sp = (png_byte)background->red;

+                        *(sp + 1) = (png_byte)background->green;

+                        *(sp + 2) = (png_byte)background->blue;

+                     }

+                     else

+                     {

+                        *sp = gamma_table[*sp];

+                        *(sp + 1) = gamma_table[*(sp + 1)];

+                        *(sp + 2) = gamma_table[*(sp + 2)];

+                     }

+                  }

+               }

+               else

+#endif

+               {

+                  sp = row;

+                  for (i = 0; i < row_width; i++, sp += 3)

+                  {

+                     if (*sp == trans_values->red &&

+                        *(sp + 1) == trans_values->green &&

+                        *(sp + 2) == trans_values->blue)

+                     {

+                        *sp = (png_byte)background->red;

+                        *(sp + 1) = (png_byte)background->green;

+                        *(sp + 2) = (png_byte)background->blue;

+                     }

+                  }

+               }

+            }

+            else /* if (row_info->bit_depth == 16) */

+            {

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+               if (gamma_16 != NULL)

+               {

+                  sp = row;

+                  for (i = 0; i < row_width; i++, sp += 6)

+                  {

+                     png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));

+                     png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));

+                     png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));

+                     if (r == trans_values->red && g == trans_values->green &&

+                        b == trans_values->blue)

+                     {

+                        /* background is already in screen gamma */

+                        *sp = (png_byte)((background->red >> 8) & 0xff);

+                        *(sp + 1) = (png_byte)(background->red & 0xff);

+                        *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);

+                        *(sp + 3) = (png_byte)(background->green & 0xff);

+                        *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);

+                        *(sp + 5) = (png_byte)(background->blue & 0xff);

+                     }

+                     else

+                     {

+                        png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];

+                        *sp = (png_byte)((v >> 8) & 0xff);

+                        *(sp + 1) = (png_byte)(v & 0xff);

+                        v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];

+                        *(sp + 2) = (png_byte)((v >> 8) & 0xff);

+                        *(sp + 3) = (png_byte)(v & 0xff);

+                        v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];

+                        *(sp + 4) = (png_byte)((v >> 8) & 0xff);

+                        *(sp + 5) = (png_byte)(v & 0xff);

+                     }

+                  }

+               }

+               else

+#endif

+               {

+                  sp = row;

+                  for (i = 0; i < row_width; i++, sp += 6)

+                  {

+                     png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp+1));

+                     png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));

+                     png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));

+                     if (r == trans_values->red && g == trans_values->green &&

+                        b == trans_values->blue)

+                     {

+                        *sp = (png_byte)((background->red >> 8) & 0xff);

+                        *(sp + 1) = (png_byte)(background->red & 0xff);

+                        *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);

+                        *(sp + 3) = (png_byte)(background->green & 0xff);

+                        *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);

+                        *(sp + 5) = (png_byte)(background->blue & 0xff);

+                     }

+                  }

+               }

+            }

+            break;

+         }

+         case PNG_COLOR_TYPE_GRAY_ALPHA:

+         {

+            if (row_info->bit_depth == 8)

+            {

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+               if (gamma_to_1 != NULL && gamma_from_1 != NULL &&

+                   gamma_table != NULL)

+               {

+                  sp = row;

+                  dp = row;

+                  for (i = 0; i < row_width; i++, sp += 2, dp++)

+                  {

+                     png_uint_16 a = *(sp + 1);

+                     if (a == 0xff)

+                     {

+                        *dp = gamma_table[*sp];

+                     }

+                     else if (a == 0)

+                     {

+                        /* background is already in screen gamma */

+                        *dp = (png_byte)background->gray;

+                     }

+                     else

+                     {

+                        png_byte v, w;

+                        v = gamma_to_1[*sp];

+                        png_composite(w, v, a, background_1->gray);

+                        *dp = gamma_from_1[w];

+                     }

+                  }

+               }

+               else

+#endif

+               {

+                  sp = row;

+                  dp = row;

+                  for (i = 0; i < row_width; i++, sp += 2, dp++)

+                  {

+                     png_byte a = *(sp + 1);

+                     if (a == 0xff)

+                     {

+                        *dp = *sp;

+                     }

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+                     else if (a == 0)

+                     {

+                        *dp = (png_byte)background->gray;

+                     }

+                     else

+                     {

+                        png_composite(*dp, *sp, a, background_1->gray);

+                     }

+#else

+                     *dp = (png_byte)background->gray;

+#endif

+                  }

+               }

+            }

+            else /* if (png_ptr->bit_depth == 16) */

+            {

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+               if (gamma_16 != NULL && gamma_16_from_1 != NULL &&

+                   gamma_16_to_1 != NULL)

+               {

+                  sp = row;

+                  dp = row;

+                  for (i = 0; i < row_width; i++, sp += 4, dp += 2)

+                  {

+                     png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));

+                     if (a == (png_uint_16)0xffff)

+                     {

+                        png_uint_16 v;

+                        v = gamma_16[*(sp + 1) >> gamma_shift][*sp];

+                        *dp = (png_byte)((v >> 8) & 0xff);

+                        *(dp + 1) = (png_byte)(v & 0xff);

+                     }

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+                     else if (a == 0)

+#else

+                     else

+#endif

+                     {

+                        /* background is already in screen gamma */

+                        *dp = (png_byte)((background->gray >> 8) & 0xff);

+                        *(dp + 1) = (png_byte)(background->gray & 0xff);

+                     }

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+                     else

+                     {

+                        png_uint_16 g, v, w;

+                        g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];

+                        png_composite_16(v, g, a, background_1->gray);

+                        w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8];

+                        *dp = (png_byte)((w >> 8) & 0xff);

+                        *(dp + 1) = (png_byte)(w & 0xff);

+                     }

+#endif

+                  }

+               }

+               else

+#endif

+               {

+                  sp = row;

+                  dp = row;

+                  for (i = 0; i < row_width; i++, sp += 4, dp += 2)

+                  {

+                     png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));

+                     if (a == (png_uint_16)0xffff)

+                     {

+                        png_memcpy(dp, sp, 2);

+                     }

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+                     else if (a == 0)

+#else

+                     else

+#endif

+                     {

+                        *dp = (png_byte)((background->gray >> 8) & 0xff);

+                        *(dp + 1) = (png_byte)(background->gray & 0xff);

+                     }

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+                     else

+                     {

+                        png_uint_16 g, v;

+                        g = (png_uint_16)(((*sp) << 8) + *(sp + 1));

+                        png_composite_16(v, g, a, background_1->gray);

+                        *dp = (png_byte)((v >> 8) & 0xff);

+                        *(dp + 1) = (png_byte)(v & 0xff);

+                     }

+#endif

+                  }

+               }

+            }

+            break;

+         }

+         case PNG_COLOR_TYPE_RGB_ALPHA:

+         {

+            if (row_info->bit_depth == 8)

+            {

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+               if (gamma_to_1 != NULL && gamma_from_1 != NULL &&

+                   gamma_table != NULL)

+               {

+                  sp = row;

+                  dp = row;

+                  for (i = 0; i < row_width; i++, sp += 4, dp += 3)

+                  {

+                     png_byte a = *(sp + 3);

+                     if (a == 0xff)

+                     {

+                        *dp = gamma_table[*sp];

+                        *(dp + 1) = gamma_table[*(sp + 1)];

+                        *(dp + 2) = gamma_table[*(sp + 2)];

+                     }

+                     else if (a == 0)

+                     {

+                        /* background is already in screen gamma */

+                        *dp = (png_byte)background->red;

+                        *(dp + 1) = (png_byte)background->green;

+                        *(dp + 2) = (png_byte)background->blue;

+                     }

+                     else

+                     {

+                        png_byte v, w;

+                        v = gamma_to_1[*sp];

+                        png_composite(w, v, a, background_1->red);

+                        *dp = gamma_from_1[w];

+                        v = gamma_to_1[*(sp + 1)];

+                        png_composite(w, v, a, background_1->green);

+                        *(dp + 1) = gamma_from_1[w];

+                        v = gamma_to_1[*(sp + 2)];

+                        png_composite(w, v, a, background_1->blue);

+                        *(dp + 2) = gamma_from_1[w];

+                     }

+                  }

+               }

+               else

+#endif

+               {

+                  sp = row;

+                  dp = row;

+                  for (i = 0; i < row_width; i++, sp += 4, dp += 3)

+                  {

+                     png_byte a = *(sp + 3);

+                     if (a == 0xff)

+                     {

+                        *dp = *sp;

+                        *(dp + 1) = *(sp + 1);

+                        *(dp + 2) = *(sp + 2);

+                     }

+                     else if (a == 0)

+                     {

+                        *dp = (png_byte)background->red;

+                        *(dp + 1) = (png_byte)background->green;

+                        *(dp + 2) = (png_byte)background->blue;

+                     }

+                     else

+                     {

+                        png_composite(*dp, *sp, a, background->red);

+                        png_composite(*(dp + 1), *(sp + 1), a,

+                           background->green);

+                        png_composite(*(dp + 2), *(sp + 2), a,

+                           background->blue);

+                     }

+                  }

+               }

+            }

+            else /* if (row_info->bit_depth == 16) */

+            {

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+               if (gamma_16 != NULL && gamma_16_from_1 != NULL &&

+                   gamma_16_to_1 != NULL)

+               {

+                  sp = row;

+                  dp = row;

+                  for (i = 0; i < row_width; i++, sp += 8, dp += 6)

+                  {

+                     png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))

+                         << 8) + (png_uint_16)(*(sp + 7)));

+                     if (a == (png_uint_16)0xffff)

+                     {

+                        png_uint_16 v;

+                        v = gamma_16[*(sp + 1) >> gamma_shift][*sp];

+                        *dp = (png_byte)((v >> 8) & 0xff);

+                        *(dp + 1) = (png_byte)(v & 0xff);

+                        v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];

+                        *(dp + 2) = (png_byte)((v >> 8) & 0xff);

+                        *(dp + 3) = (png_byte)(v & 0xff);

+                        v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];

+                        *(dp + 4) = (png_byte)((v >> 8) & 0xff);

+                        *(dp + 5) = (png_byte)(v & 0xff);

+                     }

+                     else if (a == 0)

+                     {

+                        /* background is already in screen gamma */

+                        *dp = (png_byte)((background->red >> 8) & 0xff);

+                        *(dp + 1) = (png_byte)(background->red & 0xff);

+                        *(dp + 2) = (png_byte)((background->green >> 8) & 0xff);

+                        *(dp + 3) = (png_byte)(background->green & 0xff);

+                        *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);

+                        *(dp + 5) = (png_byte)(background->blue & 0xff);

+                     }

+                     else

+                     {

+                        png_uint_16 v, w, x;

+                        v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];

+                        png_composite_16(w, v, a, background_1->red);

+                        x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];

+                        *dp = (png_byte)((x >> 8) & 0xff);

+                        *(dp + 1) = (png_byte)(x & 0xff);

+                        v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)];

+                        png_composite_16(w, v, a, background_1->green);

+                        x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];

+                        *(dp + 2) = (png_byte)((x >> 8) & 0xff);

+                        *(dp + 3) = (png_byte)(x & 0xff);

+                        v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)];

+                        png_composite_16(w, v, a, background_1->blue);

+                        x = gamma_16_from_1[(w & 0xff) >> gamma_shift][w >> 8];

+                        *(dp + 4) = (png_byte)((x >> 8) & 0xff);

+                        *(dp + 5) = (png_byte)(x & 0xff);

+                     }

+                  }

+               }

+               else

+#endif

+               {

+                  sp = row;

+                  dp = row;

+                  for (i = 0; i < row_width; i++, sp += 8, dp += 6)

+                  {

+                     png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))

+                        << 8) + (png_uint_16)(*(sp + 7)));

+                     if (a == (png_uint_16)0xffff)

+                     {

+                        png_memcpy(dp, sp, 6);

+                     }

+                     else if (a == 0)

+                     {

+                        *dp = (png_byte)((background->red >> 8) & 0xff);

+                        *(dp + 1) = (png_byte)(background->red & 0xff);

+                        *(dp + 2) = (png_byte)((background->green >> 8) & 0xff);

+                        *(dp + 3) = (png_byte)(background->green & 0xff);

+                        *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);

+                        *(dp + 5) = (png_byte)(background->blue & 0xff);

+                     }

+                     else

+                     {

+                        png_uint_16 v;

+                        png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));

+                        png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)

+                            + *(sp + 3));

+                        png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)

+                            + *(sp + 5));

+                        png_composite_16(v, r, a, background->red);

+                        *dp = (png_byte)((v >> 8) & 0xff);

+                        *(dp + 1) = (png_byte)(v & 0xff);

+                        png_composite_16(v, g, a, background->green);

+                        *(dp + 2) = (png_byte)((v >> 8) & 0xff);

+                        *(dp + 3) = (png_byte)(v & 0xff);

+                        png_composite_16(v, b, a, background->blue);

+                        *(dp + 4) = (png_byte)((v >> 8) & 0xff);

+                        *(dp + 5) = (png_byte)(v & 0xff);

+                     }

+                  }

+               }

+            }

+            break;

+         }

+      }

+      if (row_info->color_type & PNG_COLOR_MASK_ALPHA)

+      {

+         row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;

+         row_info->channels--;

+         row_info->pixel_depth = (png_byte)(row_info->channels *

+            row_info->bit_depth);

+         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width);

+      }

+   }

+}

+#endif

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+/* Gamma correct the image, avoiding the alpha channel.  Make sure

+ * you do this after you deal with the transparency issue on grayscale

+ * or RGB images. If your bit depth is 8, use gamma_table, if it

+ * is 16, use gamma_16_table and gamma_shift.  Build these with

+ * build_gamma_table().

+ */

+void /* PRIVATE */

+png_do_gamma(png_row_infop row_info, png_bytep row,

+   png_bytep gamma_table, png_uint_16pp gamma_16_table,

+   int gamma_shift)

+{

+   png_bytep sp;

+   png_uint_32 i;

+   png_uint_32 row_width=row_info->width;

+   png_debug(1, "in png_do_gamma\n");

+   if (

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+       row != NULL && row_info != NULL &&

+#endif

+       ((row_info->bit_depth <= 8 && gamma_table != NULL) ||

+        (row_info->bit_depth == 16 && gamma_16_table != NULL)))

+   {

+      switch (row_info->color_type)

+      {

+         case PNG_COLOR_TYPE_RGB:

+         {

+            if (row_info->bit_depth == 8)

+            {

+               sp = row;

+               for (i = 0; i < row_width; i++)

+               {

+                  *sp = gamma_table[*sp];

+                  sp++;

+                  *sp = gamma_table[*sp];

+                  sp++;

+                  *sp = gamma_table[*sp];

+                  sp++;

+               }

+            }

+            else /* if (row_info->bit_depth == 16) */

+            {

+               sp = row;

+               for (i = 0; i < row_width; i++)

+               {

+                  png_uint_16 v;

+                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

+                  *sp = (png_byte)((v >> 8) & 0xff);

+                  *(sp + 1) = (png_byte)(v & 0xff);

+                  sp += 2;

+                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

+                  *sp = (png_byte)((v >> 8) & 0xff);

+                  *(sp + 1) = (png_byte)(v & 0xff);

+                  sp += 2;

+                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

+                  *sp = (png_byte)((v >> 8) & 0xff);

+                  *(sp + 1) = (png_byte)(v & 0xff);

+                  sp += 2;

+               }

+            }

+            break;

+         }

+         case PNG_COLOR_TYPE_RGB_ALPHA:

+         {

+            if (row_info->bit_depth == 8)

+            {

+               sp = row;

+               for (i = 0; i < row_width; i++)

+               {

+                  *sp = gamma_table[*sp];

+                  sp++;

+                  *sp = gamma_table[*sp];

+                  sp++;

+                  *sp = gamma_table[*sp];

+                  sp++;

+                  sp++;

+               }

+            }

+            else /* if (row_info->bit_depth == 16) */

+            {

+               sp = row;

+               for (i = 0; i < row_width; i++)

+               {

+                  png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

+                  *sp = (png_byte)((v >> 8) & 0xff);

+                  *(sp + 1) = (png_byte)(v & 0xff);

+                  sp += 2;

+                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

+                  *sp = (png_byte)((v >> 8) & 0xff);

+                  *(sp + 1) = (png_byte)(v & 0xff);

+                  sp += 2;

+                  v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

+                  *sp = (png_byte)((v >> 8) & 0xff);

+                  *(sp + 1) = (png_byte)(v & 0xff);

+                  sp += 4;

+               }

+            }

+            break;

+         }

+         case PNG_COLOR_TYPE_GRAY_ALPHA:

+         {

+            if (row_info->bit_depth == 8)

+            {

+               sp = row;

+               for (i = 0; i < row_width; i++)

+               {

+                  *sp = gamma_table[*sp];

+                  sp += 2;

+               }

+            }

+            else /* if (row_info->bit_depth == 16) */

+            {

+               sp = row;

+               for (i = 0; i < row_width; i++)

+               {

+                  png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

+                  *sp = (png_byte)((v >> 8) & 0xff);

+                  *(sp + 1) = (png_byte)(v & 0xff);

+                  sp += 4;

+               }

+            }

+            break;

+         }

+         case PNG_COLOR_TYPE_GRAY:

+         {

+            if (row_info->bit_depth == 2)

+            {

+               sp = row;

+               for (i = 0; i < row_width; i += 4)

+               {

+                  int a = *sp & 0xc0;

+                  int b = *sp & 0x30;

+                  int c = *sp & 0x0c;

+                  int d = *sp & 0x03;

+                  *sp = (png_byte)(

+                        ((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)])   ) & 0xc0)|

+                        ((((int)gamma_table[(b<<2)|b|(b>>2)|(b>>4)])>>2) & 0x30)|

+                        ((((int)gamma_table[(c<<4)|(c<<2)|c|(c>>2)])>>4) & 0x0c)|

+                        ((((int)gamma_table[(d<<6)|(d<<4)|(d<<2)|d])>>6) ));

+                  sp++;

+               }

+            }

+            if (row_info->bit_depth == 4)

+            {

+               sp = row;

+               for (i = 0; i < row_width; i += 2)

+               {

+                  int msb = *sp & 0xf0;

+                  int lsb = *sp & 0x0f;

+                  *sp = (png_byte)((((int)gamma_table[msb | (msb >> 4)]) & 0xf0)

+                          | (((int)gamma_table[(lsb << 4) | lsb]) >> 4));

+                  sp++;

+               }

+            }

+            else if (row_info->bit_depth == 8)

+            {

+               sp = row;

+               for (i = 0; i < row_width; i++)

+               {

+                  *sp = gamma_table[*sp];

+                  sp++;

+               }

+            }

+            else if (row_info->bit_depth == 16)

+            {

+               sp = row;

+               for (i = 0; i < row_width; i++)

+               {

+                  png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];

+                  *sp = (png_byte)((v >> 8) & 0xff);

+                  *(sp + 1) = (png_byte)(v & 0xff);

+                  sp += 2;

+               }

+            }

+            break;

+         }

+      }

+   }

+}

+#endif

+#if defined(PNG_READ_EXPAND_SUPPORTED)

+/* Expands a palette row to an RGB or RGBA row depending

+ * upon whether you supply trans and num_trans.

+ */

+void /* PRIVATE */

+png_do_expand_palette(png_row_infop row_info, png_bytep row,

+   png_colorp palette, png_bytep trans, int num_trans)

+{

+   int shift, value;

+   png_bytep sp, dp;

+   png_uint_32 i;

+   png_uint_32 row_width=row_info->width;

+   png_debug(1, "in png_do_expand_palette\n");

+   if (

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+       row != NULL && row_info != NULL &&

+#endif

+       row_info->color_type == PNG_COLOR_TYPE_PALETTE)

+   {

+      if (row_info->bit_depth < 8)

+      {

+         switch (row_info->bit_depth)

+         {

+            case 1:

+            {

+               sp = row + (png_size_t)((row_width - 1) >> 3);

+               dp = row + (png_size_t)row_width - 1;

+               shift = 7 - (int)((row_width + 7) & 0x07);

+               for (i = 0; i < row_width; i++)

+               {

+                  if ((*sp >> shift) & 0x01)

+                     *dp = 1;

+                  else

+                     *dp = 0;

+                  if (shift == 7)

+                  {

+                     shift = 0;

+                     sp--;

+                  }

+                  else

+                     shift++;

+                  dp--;

+               }

+               break;

+            }

+            case 2:

+            {

+               sp = row + (png_size_t)((row_width - 1) >> 2);

+               dp = row + (png_size_t)row_width - 1;

+               shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);

+               for (i = 0; i < row_width; i++)

+               {

+                  value = (*sp >> shift) & 0x03;

+                  *dp = (png_byte)value;

+                  if (shift == 6)

+                  {

+                     shift = 0;

+                     sp--;

+                  }

+                  else

+                     shift += 2;

+                  dp--;

+               }

+               break;

+            }

+            case 4:

+            {

+               sp = row + (png_size_t)((row_width - 1) >> 1);

+               dp = row + (png_size_t)row_width - 1;

+               shift = (int)((row_width & 0x01) << 2);

+               for (i = 0; i < row_width; i++)

+               {

+                  value = (*sp >> shift) & 0x0f;

+                  *dp = (png_byte)value;

+                  if (shift == 4)

+                  {

+                     shift = 0;

+                     sp--;

+                  }

+                  else

+                     shift += 4;

+                  dp--;

+               }

+               break;

+            }

+         }

+         row_info->bit_depth = 8;

+         row_info->pixel_depth = 8;

+         row_info->rowbytes = row_width;

+      }

+      switch (row_info->bit_depth)

+      {

+         case 8:

+         {

+            if (trans != NULL)

+            {

+               sp = row + (png_size_t)row_width - 1;

+               dp = row + (png_size_t)(row_width << 2) - 1;

+               for (i = 0; i < row_width; i++)

+               {

+                  if ((int)(*sp) >= num_trans)

+                     *dp-- = 0xff;

+                  else

+                     *dp-- = trans[*sp];

+                  *dp-- = palette[*sp].blue;

+                  *dp-- = palette[*sp].green;

+                  *dp-- = palette[*sp].red;

+                  sp--;

+               }

+               row_info->bit_depth = 8;

+               row_info->pixel_depth = 32;

+               row_info->rowbytes = row_width * 4;

+               row_info->color_type = 6;

+               row_info->channels = 4;

+            }

+            else

+            {

+               sp = row + (png_size_t)row_width - 1;

+               dp = row + (png_size_t)(row_width * 3) - 1;

+               for (i = 0; i < row_width; i++)

+               {

+                  *dp-- = palette[*sp].blue;

+                  *dp-- = palette[*sp].green;

+                  *dp-- = palette[*sp].red;

+                  sp--;

+               }

+               row_info->bit_depth = 8;

+               row_info->pixel_depth = 24;

+               row_info->rowbytes = row_width * 3;

+               row_info->color_type = 2;

+               row_info->channels = 3;

+            }

+            break;

+         }

+      }

+   }

+}

+/* If the bit depth < 8, it is expanded to 8.  Also, if the

+ * transparency value is supplied, an alpha channel is built.

+ */

+void /* PRIVATE */

+png_do_expand(png_row_infop row_info, png_bytep row,

+   png_color_16p trans_value)

+{

+   int shift, value;

+   png_bytep sp, dp;

+   png_uint_32 i;

+   png_uint_32 row_width=row_info->width;

+   png_debug(1, "in png_do_expand\n");

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+   if (row != NULL && row_info != NULL)

+#endif

+   {

+      if (row_info->color_type == PNG_COLOR_TYPE_GRAY)

+      {

+         png_uint_16 gray = (png_uint_16)(trans_value ? trans_value->gray : 0);

+         if (row_info->bit_depth < 8)

+         {

+            switch (row_info->bit_depth)

+            {

+               case 1:

+               {

+                  gray = (png_uint_16)(gray*0xff);

+                  sp = row + (png_size_t)((row_width - 1) >> 3);

+                  dp = row + (png_size_t)row_width - 1;

+                  shift = 7 - (int)((row_width + 7) & 0x07);

+                  for (i = 0; i < row_width; i++)

+                  {

+                     if ((*sp >> shift) & 0x01)

+                        *dp = 0xff;

+                     else

+                        *dp = 0;

+                     if (shift == 7)

+                     {

+                        shift = 0;

+                        sp--;

+                     }

+                     else

+                        shift++;

+                     dp--;

+                  }

+                  break;

+               }

+               case 2:

+               {

+                  gray = (png_uint_16)(gray*0x55);

+                  sp = row + (png_size_t)((row_width - 1) >> 2);

+                  dp = row + (png_size_t)row_width - 1;

+                  shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);

+                  for (i = 0; i < row_width; i++)

+                  {

+                     value = (*sp >> shift) & 0x03;

+                     *dp = (png_byte)(value | (value << 2) | (value << 4) |

+                        (value << 6));

+                     if (shift == 6)

+                     {

+                        shift = 0;

+                        sp--;

+                     }

+                     else

+                        shift += 2;

+                     dp--;

+                  }

+                  break;

+               }

+               case 4:

+               {

+                  gray = (png_uint_16)(gray*0x11);

+                  sp = row + (png_size_t)((row_width - 1) >> 1);

+                  dp = row + (png_size_t)row_width - 1;

+                  shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);

+                  for (i = 0; i < row_width; i++)

+                  {

+                     value = (*sp >> shift) & 0x0f;

+                     *dp = (png_byte)(value | (value << 4));

+                     if (shift == 4)

+                     {

+                        shift = 0;

+                        sp--;

+                     }

+                     else

+                        shift = 4;

+                     dp--;

+                  }

+                  break;

+               }

+            }

+            row_info->bit_depth = 8;

+            row_info->pixel_depth = 8;

+            row_info->rowbytes = row_width;

+         }

+         if (trans_value != NULL)

+         {

+            if (row_info->bit_depth == 8)

+            {

+               sp = row + (png_size_t)row_width - 1;

+               dp = row + (png_size_t)(row_width << 1) - 1;

+               for (i = 0; i < row_width; i++)

+               {

+                  if (*sp == gray)

+                     *dp-- = 0;

+                  else

+                     *dp-- = 0xff;

+                  *dp-- = *sp--;

+               }

+            }

+            else if (row_info->bit_depth == 16)

+            {

+               sp = row + row_info->rowbytes - 1;

+               dp = row + (row_info->rowbytes << 1) - 1;

+               for (i = 0; i < row_width; i++)

+               {

+                  if (((png_uint_16)*(sp) |

+                     ((png_uint_16)*(sp - 1) << 8)) == gray)

+                  {

+                     *dp-- = 0;

+                     *dp-- = 0;

+                  }

+                  else

+                  {

+                     *dp-- = 0xff;

+                     *dp-- = 0xff;

+                  }

+                  *dp-- = *sp--;

+                  *dp-- = *sp--;

+               }

+            }

+            row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;

+            row_info->channels = 2;

+            row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1);

+            row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,

+               row_width);

+         }

+      }

+      else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_value)

+      {

+         if (row_info->bit_depth == 8)

+         {

+            sp = row + (png_size_t)row_info->rowbytes - 1;

+            dp = row + (png_size_t)(row_width << 2) - 1;

+            for (i = 0; i < row_width; i++)

+            {

+               if (*(sp - 2) == trans_value->red &&

+                  *(sp - 1) == trans_value->green &&

+                  *(sp - 0) == trans_value->blue)

+                  *dp-- = 0;

+               else

+                  *dp-- = 0xff;

+               *dp-- = *sp--;

+               *dp-- = *sp--;

+               *dp-- = *sp--;

+            }

+         }

+         else if (row_info->bit_depth == 16)

+         {

+            sp = row + row_info->rowbytes - 1;

+            dp = row + (png_size_t)(row_width << 3) - 1;

+            for (i = 0; i < row_width; i++)

+            {

+               if ((((png_uint_16)*(sp - 4) |

+                  ((png_uint_16)*(sp - 5) << 8)) == trans_value->red) &&

+                  (((png_uint_16)*(sp - 2) |

+                  ((png_uint_16)*(sp - 3) << 8)) == trans_value->green) &&

+                  (((png_uint_16)*(sp - 0) |

+                  ((png_uint_16)*(sp - 1) << 8)) == trans_value->blue))

+               {

+                  *dp-- = 0;

+                  *dp-- = 0;

+               }

+               else

+               {

+                  *dp-- = 0xff;

+                  *dp-- = 0xff;

+               }

+               *dp-- = *sp--;

+               *dp-- = *sp--;

+               *dp-- = *sp--;

+               *dp-- = *sp--;

+               *dp-- = *sp--;

+               *dp-- = *sp--;

+            }

+         }

+         row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;

+         row_info->channels = 4;

+         row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2);

+         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width);

+      }

+   }

+}

+#endif

+#if defined(PNG_READ_DITHER_SUPPORTED)

+void /* PRIVATE */

+png_do_dither(png_row_infop row_info, png_bytep row,

+    png_bytep palette_lookup, png_bytep dither_lookup)

+{

+   png_bytep sp, dp;

+   png_uint_32 i;

+   png_uint_32 row_width=row_info->width;

+   png_debug(1, "in png_do_dither\n");

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+   if (row != NULL && row_info != NULL)

+#endif

+   {

+      if (row_info->color_type == PNG_COLOR_TYPE_RGB &&

+         palette_lookup && row_info->bit_depth == 8)

+      {

+         int r, g, b, p;

+         sp = row;

+         dp = row;

+         for (i = 0; i < row_width; i++)

+         {

+            r = *sp++;

+            g = *sp++;

+            b = *sp++;

+            /* this looks real messy, but the compiler will reduce

+               it down to a reasonable formula.  For example, with

+               5 bits per color, we get:

+               p = (((r >> 3) & 0x1f) << 10) |

+                  (((g >> 3) & 0x1f) << 5) |

+                  ((b >> 3) & 0x1f);

+               */

+            p = (((r >> (8 - PNG_DITHER_RED_BITS)) &

+               ((1 << PNG_DITHER_RED_BITS) - 1)) <<

+               (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |

+               (((g >> (8 - PNG_DITHER_GREEN_BITS)) &

+               ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<

+               (PNG_DITHER_BLUE_BITS)) |

+               ((b >> (8 - PNG_DITHER_BLUE_BITS)) &

+               ((1 << PNG_DITHER_BLUE_BITS) - 1));

+            *dp++ = palette_lookup[p];

+         }

+         row_info->color_type = PNG_COLOR_TYPE_PALETTE;

+         row_info->channels = 1;

+         row_info->pixel_depth = row_info->bit_depth;

+         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width);

+      }

+      else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&

+         palette_lookup != NULL && row_info->bit_depth == 8)

+      {

+         int r, g, b, p;

+         sp = row;

+         dp = row;

+         for (i = 0; i < row_width; i++)

+         {

+            r = *sp++;

+            g = *sp++;

+            b = *sp++;

+            sp++;

+            p = (((r >> (8 - PNG_DITHER_RED_BITS)) &

+               ((1 << PNG_DITHER_RED_BITS) - 1)) <<

+               (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |

+               (((g >> (8 - PNG_DITHER_GREEN_BITS)) &

+               ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<

+               (PNG_DITHER_BLUE_BITS)) |

+               ((b >> (8 - PNG_DITHER_BLUE_BITS)) &

+               ((1 << PNG_DITHER_BLUE_BITS) - 1));

+            *dp++ = palette_lookup[p];

+         }

+         row_info->color_type = PNG_COLOR_TYPE_PALETTE;

+         row_info->channels = 1;

+         row_info->pixel_depth = row_info->bit_depth;

+         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width);

+      }

+      else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE &&

+         dither_lookup && row_info->bit_depth == 8)

+      {

+         sp = row;

+         for (i = 0; i < row_width; i++, sp++)

+         {

+            *sp = dither_lookup[*sp];

+         }

+      }

+   }

+}

+#endif

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+#if defined(PNG_READ_GAMMA_SUPPORTED)

+static int png_gamma_shift[] =

+   {0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0};

+/* We build the 8- or 16-bit gamma tables here.  Note that for 16-bit

+ * tables, we don't make a full table if we are reducing to 8-bit in

+ * the future.  Note also how the gamma_16 tables are segmented so that

+ * we don't need to allocate > 64K chunks for a full 16-bit table.

+ */

+void /* PRIVATE */

+png_build_gamma_table(png_structp png_ptr)

+{

+  png_debug(1, "in png_build_gamma_table\n");

+  if(png_ptr->gamma != 0.0)

+  {

+   if (png_ptr->bit_depth <= 8)

+   {

+      int i;

+      double g;

+      if (png_ptr->screen_gamma > .000001)

+         g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);

+      else

+         g = 1.0;

+      png_ptr->gamma_table = (png_bytep)png_malloc(png_ptr,

+         (png_uint_32)256);

+      for (i = 0; i < 256; i++)

+      {

+         png_ptr->gamma_table[i] = (png_byte)(pow((double)i / 255.0,

+            g) * 255.0 + .5);

+      }

+#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \

+    defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)

+      if (png_ptr->transformations & ((PNG_BACKGROUND) | PNG_RGB_TO_GRAY))

+      {

+         g = 1.0 / (png_ptr->gamma);

+         png_ptr->gamma_to_1 = (png_bytep)png_malloc(png_ptr,

+            (png_uint_32)256);

+         for (i = 0; i < 256; i++)

+         {

+            png_ptr->gamma_to_1[i] = (png_byte)(pow((double)i / 255.0,

+               g) * 255.0 + .5);

+         }

+         png_ptr->gamma_from_1 = (png_bytep)png_malloc(png_ptr,

+            (png_uint_32)256);

+         if(png_ptr->screen_gamma > 0.000001)

+            g = 1.0 / png_ptr->screen_gamma;

+         else

+            g = png_ptr->gamma;   /* probably doing rgb_to_gray */

+         for (i = 0; i < 256; i++)

+         {

+            png_ptr->gamma_from_1[i] = (png_byte)(pow((double)i / 255.0,

+               g) * 255.0 + .5);

+         }

+      }

+#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */

+   }

+   else

+   {

+      double g;

+      int i, j, shift, num;

+      int sig_bit;

+      png_uint_32 ig;

+      if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)

+      {

+         sig_bit = (int)png_ptr->sig_bit.red;

+         if ((int)png_ptr->sig_bit.green > sig_bit)

+            sig_bit = png_ptr->sig_bit.green;

+         if ((int)png_ptr->sig_bit.blue > sig_bit)

+            sig_bit = png_ptr->sig_bit.blue;

+      }

+      else

+      {

+         sig_bit = (int)png_ptr->sig_bit.gray;

+      }

+      if (sig_bit > 0)

+         shift = 16 - sig_bit;

+      else

+         shift = 0;

+      if (png_ptr->transformations & PNG_16_TO_8)

+      {

+         if (shift < (16 - PNG_MAX_GAMMA_8))

+            shift = (16 - PNG_MAX_GAMMA_8);

+      }

+      if (shift > 8)

+         shift = 8;

+      if (shift < 0)

+         shift = 0;

+      png_ptr->gamma_shift = (png_byte)shift;

+      num = (1 << (8 - shift));

+      if (png_ptr->screen_gamma > .000001)

+         g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);

+      else

+         g = 1.0;

+      png_ptr->gamma_16_table = (png_uint_16pp)png_malloc(png_ptr,

+         (png_uint_32)(num * png_sizeof (png_uint_16p)));

+      if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND))

+      {

+         double fin, fout;

+         png_uint_32 last, max;

+         for (i = 0; i < num; i++)

+         {

+            png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,

+               (png_uint_32)(256 * png_sizeof (png_uint_16)));

+         }

+         g = 1.0 / g;

+         last = 0;

+         for (i = 0; i < 256; i++)

+         {

+            fout = ((double)i + 0.5) / 256.0;

+            fin = pow(fout, g);

+            max = (png_uint_32)(fin * (double)((png_uint_32)num << 8));

+            while (last <= max)

+            {

+               png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]

+                  [(int)(last >> (8 - shift))] = (png_uint_16)(

+                  (png_uint_16)i | ((png_uint_16)i << 8));

+               last++;

+            }

+         }

+         while (last < ((png_uint_32)num << 8))

+         {

+            png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]

+               [(int)(last >> (8 - shift))] = (png_uint_16)65535L;

+            last++;

+         }

+      }

+      else

+      {

+         for (i = 0; i < num; i++)

+         {

+            png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,

+               (png_uint_32)(256 * png_sizeof (png_uint_16)));

+            ig = (((png_uint_32)i * (png_uint_32)png_gamma_shift[shift]) >> 4);

+            for (j = 0; j < 256; j++)

+            {

+               png_ptr->gamma_16_table[i][j] =

+                  (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /

+                     65535.0, g) * 65535.0 + .5);

+            }

+         }

+      }

+#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \

+    defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)

+      if (png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY))

+      {

+         g = 1.0 / (png_ptr->gamma);

+         png_ptr->gamma_16_to_1 = (png_uint_16pp)png_malloc(png_ptr,

+            (png_uint_32)(num * png_sizeof (png_uint_16p )));

+         for (i = 0; i < num; i++)

+         {

+            png_ptr->gamma_16_to_1[i] = (png_uint_16p)png_malloc(png_ptr,

+               (png_uint_32)(256 * png_sizeof (png_uint_16)));

+            ig = (((png_uint_32)i *

+               (png_uint_32)png_gamma_shift[shift]) >> 4);

+            for (j = 0; j < 256; j++)

+            {

+               png_ptr->gamma_16_to_1[i][j] =

+                  (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /

+                     65535.0, g) * 65535.0 + .5);

+            }

+         }

+         if(png_ptr->screen_gamma > 0.000001)

+            g = 1.0 / png_ptr->screen_gamma;

+         else

+            g = png_ptr->gamma;   /* probably doing rgb_to_gray */

+         png_ptr->gamma_16_from_1 = (png_uint_16pp)png_malloc(png_ptr,

+            (png_uint_32)(num * png_sizeof (png_uint_16p)));

+         for (i = 0; i < num; i++)

+         {

+            png_ptr->gamma_16_from_1[i] = (png_uint_16p)png_malloc(png_ptr,

+               (png_uint_32)(256 * png_sizeof (png_uint_16)));

+            ig = (((png_uint_32)i *

+               (png_uint_32)png_gamma_shift[shift]) >> 4);

+            for (j = 0; j < 256; j++)

+            {

+               png_ptr->gamma_16_from_1[i][j] =

+                  (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /

+                     65535.0, g) * 65535.0 + .5);

+            }

+         }

+      }

+#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */

+   }

+ }

+}

+#endif

+/* To do: install integer version of png_build_gamma_table here */

+#endif

+#if defined(PNG_MNG_FEATURES_SUPPORTED)

+/* undoes intrapixel differencing  */

+void /* PRIVATE */

+png_do_read_intrapixel(png_row_infop row_info, png_bytep row)

+{

+   png_debug(1, "in png_do_read_intrapixel\n");

+   if (

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+       row != NULL && row_info != NULL &&

+#endif

+       (row_info->color_type & PNG_COLOR_MASK_COLOR))

+   {

+      int bytes_per_pixel;

+      png_uint_32 row_width = row_info->width;

+      if (row_info->bit_depth == 8)

+      {

+         png_bytep rp;

+         png_uint_32 i;

+         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

+            bytes_per_pixel = 3;

+         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+            bytes_per_pixel = 4;

+         else

+            return;

+         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

+         {

+            *(rp) = (png_byte)((256 + *rp + *(rp+1))&0xff);

+            *(rp+2) = (png_byte)((256 + *(rp+2) + *(rp+1))&0xff);

+         }

+      }

+      else if (row_info->bit_depth == 16)

+      {

+         png_bytep rp;

+         png_uint_32 i;

+         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

+            bytes_per_pixel = 6;

+         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+            bytes_per_pixel = 8;

+         else

+            return;

+         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

+         {

+            png_uint_32 s0   = (*(rp  ) << 8) | *(rp+1);

+            png_uint_32 s1   = (*(rp+2) << 8) | *(rp+3);

+            png_uint_32 s2   = (*(rp+4) << 8) | *(rp+5);

+            png_uint_32 red  = (png_uint_32)((s0+s1+65536L) & 0xffffL);

+            png_uint_32 blue = (png_uint_32)((s2+s1+65536L) & 0xffffL);

+            *(rp  ) = (png_byte)((red >> 8) & 0xff);

+            *(rp+1) = (png_byte)(red & 0xff);

+            *(rp+4) = (png_byte)((blue >> 8) & 0xff);

+            *(rp+5) = (png_byte)(blue & 0xff);

+         }

+      }

+   }

+}

+#endif /* PNG_MNG_FEATURES_SUPPORTED */

--- /dev/null

+++ b/src/gfx/libpng/pngrutil.c

@@ -1,0 +1,3124 @@

+/* pngrutil.c - utilities to read a PNG file

+ *

+ * libpng version 1.2.8 - December 3, 2004

+ * For conditions of distribution and use, see copyright notice in png.h

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

+ *

+ * This file contains routines that are only called from within

+ * libpng itself during the course of reading an image.

+ */

+#define PNG_INTERNAL

+#include "png.h"

+#if defined(_WIN32_WCE)

+/* strtod() function is not supported on WindowsCE */

+#  ifdef PNG_FLOATING_POINT_SUPPORTED

+__inline double strtod(const char *nptr, char **endptr)

+{

+   double result = 0;

+   int len;

+   wchar_t *str, *end;

+   len = MultiByteToWideChar(CP_ACP, 0, nptr, -1, NULL, 0);

+   str = (wchar_t *)malloc(len * sizeof(wchar_t));

+   if ( NULL != str )

+   {

+      MultiByteToWideChar(CP_ACP, 0, nptr, -1, str, len);

+      result = wcstod(str, &end);

+      len = WideCharToMultiByte(CP_ACP, 0, end, -1, NULL, 0, NULL, NULL);

+      *endptr = (char *)nptr + (png_strlen(nptr) - len + 1);

+      free(str);

+   }

+   return result;

+}

+#  endif

+#endif

+png_uint_32 /* PRIVATE */

+png_get_uint_31(png_structp png_ptr, png_bytep buf)

+{

+   png_uint_32 i = png_get_uint_32(buf);

+   if (i > PNG_UINT_31_MAX)

+     png_error(png_ptr, "PNG unsigned integer out of range.\n");

+   return (i);

+}

+#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED

+/* Grab an unsigned 32-bit integer from a buffer in big-endian format. */

+png_uint_32 /* PRIVATE */

+png_get_uint_32(png_bytep buf)

+{

+   png_uint_32 i = ((png_uint_32)(*buf) << 24) +

+      ((png_uint_32)(*(buf + 1)) << 16) +

+      ((png_uint_32)(*(buf + 2)) << 8) +

+      (png_uint_32)(*(buf + 3));

+   return (i);

+}

+#if defined(PNG_READ_pCAL_SUPPORTED) || defined(PNG_READ_oFFs_SUPPORTED)

+/* Grab a signed 32-bit integer from a buffer in big-endian format.  The

+ * data is stored in the PNG file in two's complement format, and it is

+ * assumed that the machine format for signed integers is the same. */

+png_int_32 /* PRIVATE */

+png_get_int_32(png_bytep buf)

+{

+   png_int_32 i = ((png_int_32)(*buf) << 24) +

+      ((png_int_32)(*(buf + 1)) << 16) +

+      ((png_int_32)(*(buf + 2)) << 8) +

+      (png_int_32)(*(buf + 3));

+   return (i);

+}

+#endif /* PNG_READ_pCAL_SUPPORTED */

+/* Grab an unsigned 16-bit integer from a buffer in big-endian format. */

+png_uint_16 /* PRIVATE */

+png_get_uint_16(png_bytep buf)

+{

+   png_uint_16 i = (png_uint_16)(((png_uint_16)(*buf) << 8) +

+      (png_uint_16)(*(buf + 1)));

+   return (i);

+}

+#endif /* PNG_READ_BIG_ENDIAN_SUPPORTED */

+/* Read data, and (optionally) run it through the CRC. */

+void /* PRIVATE */

+png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)

+{

+   png_read_data(png_ptr, buf, length);

+   png_calculate_crc(png_ptr, buf, length);

+}

+/* Optionally skip data and then check the CRC.  Depending on whether we

+   are reading a ancillary or critical chunk, and how the program has set

+   things up, we may calculate the CRC on the data and print a message.

+   Returns '1' if there was a CRC error, '0' otherwise. */

+int /* PRIVATE */

+png_crc_finish(png_structp png_ptr, png_uint_32 skip)

+{

+   png_size_t i;

+   png_size_t istop = png_ptr->zbuf_size;

+   for (i = (png_size_t)skip; i > istop; i -= istop)

+   {

+      png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);

+   }

+   if (i)

+   {

+      png_crc_read(png_ptr, png_ptr->zbuf, i);

+   }

+   if (png_crc_error(png_ptr))

+   {

+      if (((png_ptr->chunk_name[0] & 0x20) &&                /* Ancillary */

+           !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) ||

+          (!(png_ptr->chunk_name[0] & 0x20) &&             /* Critical  */

+          (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE)))

+      {

+         png_chunk_warning(png_ptr, "CRC error");

+      }

+      else

+      {

+         png_chunk_error(png_ptr, "CRC error");

+      }

+      return (1);

+   }

+   return (0);

+}

+/* Compare the CRC stored in the PNG file with that calculated by libpng from

+   the data it has read thus far. */

+int /* PRIVATE */

+png_crc_error(png_structp png_ptr)

+{

+   png_byte crc_bytes[4];

+   png_uint_32 crc;

+   int need_crc = 1;

+   if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */

+   {

+      if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==

+          (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))

+         need_crc = 0;

+   }

+   else                                                    /* critical */

+   {

+      if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)

+         need_crc = 0;

+   }

+   png_read_data(png_ptr, crc_bytes, 4);

+   if (need_crc)

+   {

+      crc = png_get_uint_32(crc_bytes);

+      return ((int)(crc != png_ptr->crc));

+   }

+   else

+      return (0);

+}

+#if defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_READ_iTXt_SUPPORTED) || \

+    defined(PNG_READ_iCCP_SUPPORTED)

+/*

+ * Decompress trailing data in a chunk.  The assumption is that chunkdata

+ * points at an allocated area holding the contents of a chunk with a

+ * trailing compressed part.  What we get back is an allocated area

+ * holding the original prefix part and an uncompressed version of the

+ * trailing part (the malloc area passed in is freed).

+ */

+png_charp /* PRIVATE */

+png_decompress_chunk(png_structp png_ptr, int comp_type,

+                              png_charp chunkdata, png_size_t chunklength,

+                              png_size_t prefix_size, png_size_t *newlength)

+{

+   static char msg[] = "Error decoding compressed text";

+   png_charp text;

+   png_size_t text_size;

+   if (comp_type == PNG_COMPRESSION_TYPE_BASE)

+   {

+      int ret = Z_OK;

+      png_ptr->zstream.next_in = (png_bytep)(chunkdata + prefix_size);

+      png_ptr->zstream.avail_in = (uInt)(chunklength - prefix_size);

+      png_ptr->zstream.next_out = png_ptr->zbuf;

+      png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+      text_size = 0;

+      text = NULL;

+      while (png_ptr->zstream.avail_in)

+      {

+         ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);

+         if (ret != Z_OK && ret != Z_STREAM_END)

+         {

+            if (png_ptr->zstream.msg != NULL)

+               png_warning(png_ptr, png_ptr->zstream.msg);

+            else

+               png_warning(png_ptr, msg);

+            inflateReset(&png_ptr->zstream);

+            png_ptr->zstream.avail_in = 0;

+            if (text ==  NULL)

+            {

+               text_size = prefix_size + png_sizeof(msg) + 1;

+               text = (png_charp)png_malloc_warn(png_ptr, text_size);

+               if (text ==  NULL)

+                 {

+                    png_free(png_ptr,chunkdata);

+                    png_error(png_ptr,"Not enough memory to decompress chunk");

+                 }

+               png_memcpy(text, chunkdata, prefix_size);

+            }

+            text[text_size - 1] = 0x00;

+            /* Copy what we can of the error message into the text chunk */

+            text_size = (png_size_t)(chunklength - (text - chunkdata) - 1);

+            text_size = png_sizeof(msg) > text_size ? text_size :

+               png_sizeof(msg);

+            png_memcpy(text + prefix_size, msg, text_size + 1);

+            break;

+         }

+         if (!png_ptr->zstream.avail_out || ret == Z_STREAM_END)

+         {

+            if (text == NULL)

+            {

+               text_size = prefix_size +

+                   png_ptr->zbuf_size - png_ptr->zstream.avail_out;

+               text = (png_charp)png_malloc_warn(png_ptr, text_size + 1);

+               if (text ==  NULL)

+                 {

+                    png_free(png_ptr,chunkdata);

+                    png_error(png_ptr,"Not enough memory to decompress chunk.");

+                 }

+               png_memcpy(text + prefix_size, png_ptr->zbuf,

+                    text_size - prefix_size);

+               png_memcpy(text, chunkdata, prefix_size);

+               *(text + text_size) = 0x00;

+            }

+            else

+            {

+               png_charp tmp;

+               tmp = text;

+               text = (png_charp)png_malloc_warn(png_ptr,

+                  (png_uint_32)(text_size +

+                  png_ptr->zbuf_size - png_ptr->zstream.avail_out + 1));

+               if (text == NULL)

+               {

+                  png_free(png_ptr, tmp);

+                  png_free(png_ptr, chunkdata);

+                  png_error(png_ptr,"Not enough memory to decompress chunk..");

+               }

+               png_memcpy(text, tmp, text_size);

+               png_free(png_ptr, tmp);

+               png_memcpy(text + text_size, png_ptr->zbuf,

+                  (png_ptr->zbuf_size - png_ptr->zstream.avail_out));

+               text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;

+               *(text + text_size) = 0x00;

+            }

+            if (ret == Z_STREAM_END)

+               break;

+            else

+            {

+               png_ptr->zstream.next_out = png_ptr->zbuf;

+               png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+            }

+         }

+      }

+      if (ret != Z_STREAM_END)

+      {

+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)

+         char umsg[50];

+         if (ret == Z_BUF_ERROR)

+            sprintf(umsg,"Buffer error in compressed datastream in %s chunk",

+                png_ptr->chunk_name);

+         else if (ret == Z_DATA_ERROR)

+            sprintf(umsg,"Data error in compressed datastream in %s chunk",

+                png_ptr->chunk_name);

+         else

+            sprintf(umsg,"Incomplete compressed datastream in %s chunk",

+                png_ptr->chunk_name);

+         png_warning(png_ptr, umsg);

+#else

+         png_warning(png_ptr,

+            "Incomplete compressed datastream in chunk other than IDAT");

+#endif

+         text_size=prefix_size;

+         if (text ==  NULL)

+         {

+            text = (png_charp)png_malloc_warn(png_ptr, text_size+1);

+            if (text == NULL)

+              {

+                png_free(png_ptr, chunkdata);

+                png_error(png_ptr,"Not enough memory for text.");

+              }

+            png_memcpy(text, chunkdata, prefix_size);

+         }

+         *(text + text_size) = 0x00;

+      }

+      inflateReset(&png_ptr->zstream);

+      png_ptr->zstream.avail_in = 0;

+      png_free(png_ptr, chunkdata);

+      chunkdata = text;

+      *newlength=text_size;

+   }

+   else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */

+   {

+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)

+      char umsg[50];

+      sprintf(umsg, "Unknown zTXt compression type %d", comp_type);

+      png_warning(png_ptr, umsg);

+#else

+      png_warning(png_ptr, "Unknown zTXt compression type");

+#endif

+      *(chunkdata + prefix_size) = 0x00;

+      *newlength=prefix_size;

+   }

+   return chunkdata;

+}

+#endif

+/* read and check the IDHR chunk */

+void /* PRIVATE */

+png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+{

+   png_byte buf[13];

+   png_uint_32 width, height;

+   int bit_depth, color_type, compression_type, filter_type;

+   int interlace_type;

+   png_debug(1, "in png_handle_IHDR\n");

+   if (png_ptr->mode & PNG_HAVE_IHDR)

+      png_error(png_ptr, "Out of place IHDR");

+   /* check the length */

+   if (length != 13)

+      png_error(png_ptr, "Invalid IHDR chunk");

+   png_ptr->mode |= PNG_HAVE_IHDR;

+   png_crc_read(png_ptr, buf, 13);

+   png_crc_finish(png_ptr, 0);

+   width = png_get_uint_31(png_ptr, buf);

+   height = png_get_uint_31(png_ptr, buf + 4);

+   bit_depth = buf[8];

+   color_type = buf[9];

+   compression_type = buf[10];

+   filter_type = buf[11];

+   interlace_type = buf[12];

+   /* set internal variables */

+   png_ptr->width = width;

+   png_ptr->height = height;

+   png_ptr->bit_depth = (png_byte)bit_depth;

+   png_ptr->interlaced = (png_byte)interlace_type;

+   png_ptr->color_type = (png_byte)color_type;

+#if defined(PNG_MNG_FEATURES_SUPPORTED)

+   png_ptr->filter_type = (png_byte)filter_type;

+#endif

+   png_ptr->compression_type = (png_byte)compression_type;

+   /* find number of channels */

+   switch (png_ptr->color_type)

+   {

+      case PNG_COLOR_TYPE_GRAY:

+      case PNG_COLOR_TYPE_PALETTE:

+         png_ptr->channels = 1;

+         break;

+      case PNG_COLOR_TYPE_RGB:

+         png_ptr->channels = 3;

+         break;

+      case PNG_COLOR_TYPE_GRAY_ALPHA:

+         png_ptr->channels = 2;

+         break;

+      case PNG_COLOR_TYPE_RGB_ALPHA:

+         png_ptr->channels = 4;

+         break;

+   }

+   /* set up other useful info */

+   png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *

+   png_ptr->channels);

+   png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,png_ptr->width);

+   png_debug1(3,"bit_depth = %d\n", png_ptr->bit_depth);

+   png_debug1(3,"channels = %d\n", png_ptr->channels);

+   png_debug1(3,"rowbytes = %lu\n", png_ptr->rowbytes);

+   png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,

+      color_type, interlace_type, compression_type, filter_type);

+}

+/* read and check the palette */

+void /* PRIVATE */

+png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+{

+   png_color palette[PNG_MAX_PALETTE_LENGTH];

+   int num, i;

+#ifndef PNG_NO_POINTER_INDEXING

+   png_colorp pal_ptr;

+#endif

+   png_debug(1, "in png_handle_PLTE\n");

+   if (!(png_ptr->mode & PNG_HAVE_IHDR))

+      png_error(png_ptr, "Missing IHDR before PLTE");

+   else if (png_ptr->mode & PNG_HAVE_IDAT)

+   {

+      png_warning(png_ptr, "Invalid PLTE after IDAT");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   else if (png_ptr->mode & PNG_HAVE_PLTE)

+      png_error(png_ptr, "Duplicate PLTE chunk");

+   png_ptr->mode |= PNG_HAVE_PLTE;

+   if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))

+   {

+      png_warning(png_ptr,

+        "Ignoring PLTE chunk in grayscale PNG");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+#if !defined(PNG_READ_OPT_PLTE_SUPPORTED)

+   if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)

+   {

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+#endif

+   if (length > 3*PNG_MAX_PALETTE_LENGTH || length % 3)

+   {

+      if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)

+      {

+         png_warning(png_ptr, "Invalid palette chunk");

+         png_crc_finish(png_ptr, length);

+         return;

+      }

+      else

+      {

+         png_error(png_ptr, "Invalid palette chunk");

+      }

+   }

+   num = (int)length / 3;

+#ifndef PNG_NO_POINTER_INDEXING

+   for (i = 0, pal_ptr = palette; i < num; i++, pal_ptr++)

+   {

+      png_byte buf[3];

+      png_crc_read(png_ptr, buf, 3);

+      pal_ptr->red = buf[0];

+      pal_ptr->green = buf[1];

+      pal_ptr->blue = buf[2];

+   }

+#else

+   for (i = 0; i < num; i++)

+   {

+      png_byte buf[3];

+      png_crc_read(png_ptr, buf, 3);

+      /* don't depend upon png_color being any order */

+      palette[i].red = buf[0];

+      palette[i].green = buf[1];

+      palette[i].blue = buf[2];

+   }

+#endif

+   /* If we actually NEED the PLTE chunk (ie for a paletted image), we do

+      whatever the normal CRC configuration tells us.  However, if we

+      have an RGB image, the PLTE can be considered ancillary, so

+      we will act as though it is. */

+#if !defined(PNG_READ_OPT_PLTE_SUPPORTED)

+   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+#endif

+   {

+      png_crc_finish(png_ptr, 0);

+   }

+#if !defined(PNG_READ_OPT_PLTE_SUPPORTED)

+   else if (png_crc_error(png_ptr))  /* Only if we have a CRC error */

+   {

+      /* If we don't want to use the data from an ancillary chunk,

+         we have two options: an error abort, or a warning and we

+         ignore the data in this chunk (which should be OK, since

+         it's considered ancillary for a RGB or RGBA image). */

+      if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE))

+      {

+         if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)

+         {

+            png_chunk_error(png_ptr, "CRC error");

+         }

+         else

+         {

+            png_chunk_warning(png_ptr, "CRC error");

+            return;

+         }

+      }

+      /* Otherwise, we (optionally) emit a warning and use the chunk. */

+      else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN))

+      {

+         png_chunk_warning(png_ptr, "CRC error");

+      }

+   }

+#endif

+   png_set_PLTE(png_ptr, info_ptr, palette, num);

+#if defined(PNG_READ_tRNS_SUPPORTED)

+   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+   {

+      if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))

+      {

+         if (png_ptr->num_trans > (png_uint_16)num)

+         {

+            png_warning(png_ptr, "Truncating incorrect tRNS chunk length");

+            png_ptr->num_trans = (png_uint_16)num;

+         }

+         if (info_ptr->num_trans > (png_uint_16)num)

+         {

+            png_warning(png_ptr, "Truncating incorrect info tRNS chunk length");

+            info_ptr->num_trans = (png_uint_16)num;

+         }

+      }

+   }

+#endif

+}

+void /* PRIVATE */

+png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+{

+   png_debug(1, "in png_handle_IEND\n");

+   if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT))

+   {

+      png_error(png_ptr, "No image in file");

+   }

+   png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND);

+   if (length != 0)

+   {

+      png_warning(png_ptr, "Incorrect IEND chunk length");

+   }

+   png_crc_finish(png_ptr, length);

+   if (&info_ptr == NULL) /* quiet compiler warnings about unused info_ptr */

+      return;

+}

+#if defined(PNG_READ_gAMA_SUPPORTED)

+void /* PRIVATE */

+png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+{

+   png_fixed_point igamma;

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+   float file_gamma;

+#endif

+   png_byte buf[4];

+   png_debug(1, "in png_handle_gAMA\n");

+   if (!(png_ptr->mode & PNG_HAVE_IHDR))

+      png_error(png_ptr, "Missing IHDR before gAMA");

+   else if (png_ptr->mode & PNG_HAVE_IDAT)

+   {

+      png_warning(png_ptr, "Invalid gAMA after IDAT");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   else if (png_ptr->mode & PNG_HAVE_PLTE)

+      /* Should be an error, but we can cope with it */

+      png_warning(png_ptr, "Out of place gAMA chunk");

+   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)

+#if defined(PNG_READ_sRGB_SUPPORTED)

+      && !(info_ptr->valid & PNG_INFO_sRGB)

+#endif

+      )

+   {

+      png_warning(png_ptr, "Duplicate gAMA chunk");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   if (length != 4)

+   {

+      png_warning(png_ptr, "Incorrect gAMA chunk length");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   png_crc_read(png_ptr, buf, 4);

+   if (png_crc_finish(png_ptr, 0))

+      return;

+   igamma = (png_fixed_point)png_get_uint_32(buf);

+   /* check for zero gamma */

+   if (igamma == 0)

+      {

+         png_warning(png_ptr,

+           "Ignoring gAMA chunk with gamma=0");

+         return;

+      }

+#if defined(PNG_READ_sRGB_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_sRGB)

+      if (PNG_OUT_OF_RANGE(igamma, 45500L, 500))

+      {

+         png_warning(png_ptr,

+           "Ignoring incorrect gAMA value when sRGB is also present");

+#ifndef PNG_NO_CONSOLE_IO

+         fprintf(stderr, "gamma = (%d/100000)\n", (int)igamma);

+#endif

+         return;

+      }

+#endif /* PNG_READ_sRGB_SUPPORTED */

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+   file_gamma = (float)igamma / (float)100000.0;

+#  ifdef PNG_READ_GAMMA_SUPPORTED

+     png_ptr->gamma = file_gamma;

+#  endif

+     png_set_gAMA(png_ptr, info_ptr, file_gamma);

+#endif

+#ifdef PNG_FIXED_POINT_SUPPORTED

+   png_set_gAMA_fixed(png_ptr, info_ptr, igamma);

+#endif

+}

+#endif

+#if defined(PNG_READ_sBIT_SUPPORTED)

+void /* PRIVATE */

+png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+{

+   png_size_t truelen;

+   png_byte buf[4];

+   png_debug(1, "in png_handle_sBIT\n");

+   buf[0] = buf[1] = buf[2] = buf[3] = 0;

+   if (!(png_ptr->mode & PNG_HAVE_IHDR))

+      png_error(png_ptr, "Missing IHDR before sBIT");

+   else if (png_ptr->mode & PNG_HAVE_IDAT)

+   {

+      png_warning(png_ptr, "Invalid sBIT after IDAT");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   else if (png_ptr->mode & PNG_HAVE_PLTE)

+   {

+      /* Should be an error, but we can cope with it */

+      png_warning(png_ptr, "Out of place sBIT chunk");

+   }

+   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT))

+   {

+      png_warning(png_ptr, "Duplicate sBIT chunk");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+      truelen = 3;

+   else

+      truelen = (png_size_t)png_ptr->channels;

+   if (length != truelen || length > 4)

+   {

+      png_warning(png_ptr, "Incorrect sBIT chunk length");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   png_crc_read(png_ptr, buf, truelen);

+   if (png_crc_finish(png_ptr, 0))

+      return;

+   if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)

+   {

+      png_ptr->sig_bit.red = buf[0];

+      png_ptr->sig_bit.green = buf[1];

+      png_ptr->sig_bit.blue = buf[2];

+      png_ptr->sig_bit.alpha = buf[3];

+   }

+   else

+   {

+      png_ptr->sig_bit.gray = buf[0];

+      png_ptr->sig_bit.red = buf[0];

+      png_ptr->sig_bit.green = buf[0];

+      png_ptr->sig_bit.blue = buf[0];

+      png_ptr->sig_bit.alpha = buf[1];

+   }

+   png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit));

+}

+#endif

+#if defined(PNG_READ_cHRM_SUPPORTED)

+void /* PRIVATE */

+png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+{

+   png_byte buf[4];

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+   float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;

+#endif

+   png_fixed_point int_x_white, int_y_white, int_x_red, int_y_red, int_x_green,

+      int_y_green, int_x_blue, int_y_blue;

+   png_uint_32 uint_x, uint_y;

+   png_debug(1, "in png_handle_cHRM\n");

+   if (!(png_ptr->mode & PNG_HAVE_IHDR))

+      png_error(png_ptr, "Missing IHDR before cHRM");

+   else if (png_ptr->mode & PNG_HAVE_IDAT)

+   {

+      png_warning(png_ptr, "Invalid cHRM after IDAT");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   else if (png_ptr->mode & PNG_HAVE_PLTE)

+      /* Should be an error, but we can cope with it */

+      png_warning(png_ptr, "Missing PLTE before cHRM");

+   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)

+#if defined(PNG_READ_sRGB_SUPPORTED)

+      && !(info_ptr->valid & PNG_INFO_sRGB)

+#endif

+      )

+   {

+      png_warning(png_ptr, "Duplicate cHRM chunk");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   if (length != 32)

+   {

+      png_warning(png_ptr, "Incorrect cHRM chunk length");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   png_crc_read(png_ptr, buf, 4);

+   uint_x = png_get_uint_32(buf);

+   png_crc_read(png_ptr, buf, 4);

+   uint_y = png_get_uint_32(buf);

+   if (uint_x > 80000L || uint_y > 80000L ||

+      uint_x + uint_y > 100000L)

+   {

+      png_warning(png_ptr, "Invalid cHRM white point");

+      png_crc_finish(png_ptr, 24);

+      return;

+   }

+   int_x_white = (png_fixed_point)uint_x;

+   int_y_white = (png_fixed_point)uint_y;

+   png_crc_read(png_ptr, buf, 4);

+   uint_x = png_get_uint_32(buf);

+   png_crc_read(png_ptr, buf, 4);

+   uint_y = png_get_uint_32(buf);

+   if (uint_x > 80000L || uint_y > 80000L ||

+      uint_x + uint_y > 100000L)

+   {

+      png_warning(png_ptr, "Invalid cHRM red point");

+      png_crc_finish(png_ptr, 16);

+      return;

+   }

+   int_x_red = (png_fixed_point)uint_x;

+   int_y_red = (png_fixed_point)uint_y;

+   png_crc_read(png_ptr, buf, 4);

+   uint_x = png_get_uint_32(buf);

+   png_crc_read(png_ptr, buf, 4);

+   uint_y = png_get_uint_32(buf);

+   if (uint_x > 80000L || uint_y > 80000L ||

+      uint_x + uint_y > 100000L)

+   {

+      png_warning(png_ptr, "Invalid cHRM green point");

+      png_crc_finish(png_ptr, 8);

+      return;

+   }

+   int_x_green = (png_fixed_point)uint_x;

+   int_y_green = (png_fixed_point)uint_y;

+   png_crc_read(png_ptr, buf, 4);

+   uint_x = png_get_uint_32(buf);

+   png_crc_read(png_ptr, buf, 4);

+   uint_y = png_get_uint_32(buf);

+   if (uint_x > 80000L || uint_y > 80000L ||

+      uint_x + uint_y > 100000L)

+   {

+      png_warning(png_ptr, "Invalid cHRM blue point");

+      png_crc_finish(png_ptr, 0);

+      return;

+   }

+   int_x_blue = (png_fixed_point)uint_x;

+   int_y_blue = (png_fixed_point)uint_y;

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+   white_x = (float)int_x_white / (float)100000.0;

+   white_y = (float)int_y_white / (float)100000.0;

+   red_x   = (float)int_x_red   / (float)100000.0;

+   red_y   = (float)int_y_red   / (float)100000.0;

+   green_x = (float)int_x_green / (float)100000.0;

+   green_y = (float)int_y_green / (float)100000.0;

+   blue_x  = (float)int_x_blue  / (float)100000.0;

+   blue_y  = (float)int_y_blue  / (float)100000.0;

+#endif

+#if defined(PNG_READ_sRGB_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_sRGB)

+      {

+      if (PNG_OUT_OF_RANGE(int_x_white, 31270,  1000) ||

+          PNG_OUT_OF_RANGE(int_y_white, 32900,  1000) ||

+          PNG_OUT_OF_RANGE(int_x_red,   64000L, 1000) ||

+          PNG_OUT_OF_RANGE(int_y_red,   33000,  1000) ||

+          PNG_OUT_OF_RANGE(int_x_green, 30000,  1000) ||

+          PNG_OUT_OF_RANGE(int_y_green, 60000L, 1000) ||

+          PNG_OUT_OF_RANGE(int_x_blue,  15000,  1000) ||

+          PNG_OUT_OF_RANGE(int_y_blue,   6000,  1000))

+         {

+            png_warning(png_ptr,

+              "Ignoring incorrect cHRM value when sRGB is also present");

+#ifndef PNG_NO_CONSOLE_IO

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+            fprintf(stderr,"wx=%f, wy=%f, rx=%f, ry=%f\n",

+               white_x, white_y, red_x, red_y);

+            fprintf(stderr,"gx=%f, gy=%f, bx=%f, by=%f\n",

+               green_x, green_y, blue_x, blue_y);

+#else

+            fprintf(stderr,"wx=%ld, wy=%ld, rx=%ld, ry=%ld\n",

+               int_x_white, int_y_white, int_x_red, int_y_red);

+            fprintf(stderr,"gx=%ld, gy=%ld, bx=%ld, by=%ld\n",

+               int_x_green, int_y_green, int_x_blue, int_y_blue);

+#endif

+#endif /* PNG_NO_CONSOLE_IO */

+         }

+         png_crc_finish(png_ptr, 0);

+         return;

+      }

+#endif /* PNG_READ_sRGB_SUPPORTED */

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+   png_set_cHRM(png_ptr, info_ptr,

+      white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);

+#endif

+#ifdef PNG_FIXED_POINT_SUPPORTED

+   png_set_cHRM_fixed(png_ptr, info_ptr,

+      int_x_white, int_y_white, int_x_red, int_y_red, int_x_green,

+      int_y_green, int_x_blue, int_y_blue);

+#endif

+   if (png_crc_finish(png_ptr, 0))

+      return;

+}

+#endif

+#if defined(PNG_READ_sRGB_SUPPORTED)

+void /* PRIVATE */

+png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+{

+   int intent;

+   png_byte buf[1];

+   png_debug(1, "in png_handle_sRGB\n");

+   if (!(png_ptr->mode & PNG_HAVE_IHDR))

+      png_error(png_ptr, "Missing IHDR before sRGB");

+   else if (png_ptr->mode & PNG_HAVE_IDAT)

+   {

+      png_warning(png_ptr, "Invalid sRGB after IDAT");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   else if (png_ptr->mode & PNG_HAVE_PLTE)

+      /* Should be an error, but we can cope with it */

+      png_warning(png_ptr, "Out of place sRGB chunk");

+   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB))

+   {

+      png_warning(png_ptr, "Duplicate sRGB chunk");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   if (length != 1)

+   {

+      png_warning(png_ptr, "Incorrect sRGB chunk length");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   png_crc_read(png_ptr, buf, 1);

+   if (png_crc_finish(png_ptr, 0))

+      return;

+   intent = buf[0];

+   /* check for bad intent */

+   if (intent >= PNG_sRGB_INTENT_LAST)

+   {

+      png_warning(png_ptr, "Unknown sRGB intent");

+      return;

+   }

+#if defined(PNG_READ_gAMA_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED)

+   if ((info_ptr->valid & PNG_INFO_gAMA))

+   {

+   png_fixed_point igamma;

+#ifdef PNG_FIXED_POINT_SUPPORTED

+      igamma=info_ptr->int_gamma;

+#else

+#  ifdef PNG_FLOATING_POINT_SUPPORTED

+      igamma=(png_fixed_point)(info_ptr->gamma * 100000.);

+#  endif

+#endif

+      if (PNG_OUT_OF_RANGE(igamma, 45500L, 500))

+      {

+         png_warning(png_ptr,

+           "Ignoring incorrect gAMA value when sRGB is also present");

+#ifndef PNG_NO_CONSOLE_IO

+#  ifdef PNG_FIXED_POINT_SUPPORTED

+         fprintf(stderr,"incorrect gamma=(%d/100000)\n",(int)png_ptr->int_gamma);

+#  else

+#    ifdef PNG_FLOATING_POINT_SUPPORTED

+         fprintf(stderr,"incorrect gamma=%f\n",png_ptr->gamma);

+#    endif

+#  endif

+#endif

+      }

+   }

+#endif /* PNG_READ_gAMA_SUPPORTED */

+#ifdef PNG_READ_cHRM_SUPPORTED

+#ifdef PNG_FIXED_POINT_SUPPORTED

+   if (info_ptr->valid & PNG_INFO_cHRM)

+      if (PNG_OUT_OF_RANGE(info_ptr->int_x_white, 31270,  1000) ||

+          PNG_OUT_OF_RANGE(info_ptr->int_y_white, 32900,  1000) ||

+          PNG_OUT_OF_RANGE(info_ptr->int_x_red,   64000L, 1000) ||

+          PNG_OUT_OF_RANGE(info_ptr->int_y_red,   33000,  1000) ||

+          PNG_OUT_OF_RANGE(info_ptr->int_x_green, 30000,  1000) ||

+          PNG_OUT_OF_RANGE(info_ptr->int_y_green, 60000L, 1000) ||

+          PNG_OUT_OF_RANGE(info_ptr->int_x_blue,  15000,  1000) ||

+          PNG_OUT_OF_RANGE(info_ptr->int_y_blue,   6000,  1000))

+         {

+            png_warning(png_ptr,

+              "Ignoring incorrect cHRM value when sRGB is also present");

+         }

+#endif /* PNG_FIXED_POINT_SUPPORTED */

+#endif /* PNG_READ_cHRM_SUPPORTED */

+   png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent);

+}

+#endif /* PNG_READ_sRGB_SUPPORTED */

+#if defined(PNG_READ_iCCP_SUPPORTED)

+void /* PRIVATE */

+png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+/* Note: this does not properly handle chunks that are > 64K under DOS */

+{

+   png_charp chunkdata;

+   png_byte compression_type;

+   png_bytep pC;

+   png_charp profile;

+   png_uint_32 skip = 0;

+   png_uint_32 profile_size, profile_length;

+   png_size_t slength, prefix_length, data_length;

+   png_debug(1, "in png_handle_iCCP\n");

+   if (!(png_ptr->mode & PNG_HAVE_IHDR))

+      png_error(png_ptr, "Missing IHDR before iCCP");

+   else if (png_ptr->mode & PNG_HAVE_IDAT)

+   {

+      png_warning(png_ptr, "Invalid iCCP after IDAT");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   else if (png_ptr->mode & PNG_HAVE_PLTE)

+      /* Should be an error, but we can cope with it */

+      png_warning(png_ptr, "Out of place iCCP chunk");

+   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP))

+   {

+      png_warning(png_ptr, "Duplicate iCCP chunk");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+#ifdef PNG_MAX_MALLOC_64K

+   if (length > (png_uint_32)65535L)

+   {

+      png_warning(png_ptr, "iCCP chunk too large to fit in memory");

+      skip = length - (png_uint_32)65535L;

+      length = (png_uint_32)65535L;

+   }

+#endif

+   chunkdata = (png_charp)png_malloc(png_ptr, length + 1);

+   slength = (png_size_t)length;

+   png_crc_read(png_ptr, (png_bytep)chunkdata, slength);

+   if (png_crc_finish(png_ptr, skip))

+   {

+      png_free(png_ptr, chunkdata);

+      return;

+   }

+   chunkdata[slength] = 0x00;

+   for (profile = chunkdata; *profile; profile++)

+      /* empty loop to find end of name */ ;

+   ++profile;

+   /* there should be at least one zero (the compression type byte)

+      following the separator, and we should be on it  */

+   if ( profile >= chunkdata + slength)

+   {

+      png_free(png_ptr, chunkdata);

+      png_warning(png_ptr, "Malformed iCCP chunk");

+      return;

+   }

+   /* compression_type should always be zero */

+   compression_type = *profile++;

+   if (compression_type)

+   {

+      png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk");

+      compression_type=0x00;  /* Reset it to zero (libpng-1.0.6 through 1.0.8

+                                 wrote nonzero) */

+   }

+   prefix_length = profile - chunkdata;

+   chunkdata = png_decompress_chunk(png_ptr, compression_type, chunkdata,

+                                    slength, prefix_length, &data_length);

+   profile_length = data_length - prefix_length;

+   if ( prefix_length > data_length || profile_length < 4)

+   {

+      png_free(png_ptr, chunkdata);

+      png_warning(png_ptr, "Profile size field missing from iCCP chunk");

+      return;

+   }

+   /* Check the profile_size recorded in the first 32 bits of the ICC profile */

+   pC = (png_bytep)(chunkdata+prefix_length);

+   profile_size = ((*(pC  ))<<24) |

+                  ((*(pC+1))<<16) |

+                  ((*(pC+2))<< 8) |

+                  ((*(pC+3))    );

+   if(profile_size < profile_length)

+      profile_length = profile_size;

+   if(profile_size > profile_length)

+   {

+      png_free(png_ptr, chunkdata);

+      png_warning(png_ptr, "Ignoring truncated iCCP profile.\n");

+      return;

+   }

+   png_set_iCCP(png_ptr, info_ptr, chunkdata, compression_type,

+                chunkdata + prefix_length, profile_length);

+   png_free(png_ptr, chunkdata);

+}

+#endif /* PNG_READ_iCCP_SUPPORTED */

+#if defined(PNG_READ_sPLT_SUPPORTED)

+void /* PRIVATE */

+png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+/* Note: this does not properly handle chunks that are > 64K under DOS */

+{

+   png_bytep chunkdata;

+   png_bytep entry_start;

+   png_sPLT_t new_palette;

+#ifdef PNG_NO_POINTER_INDEXING

+   png_sPLT_entryp pp;

+#endif

+   int data_length, entry_size, i;

+   png_uint_32 skip = 0;

+   png_size_t slength;

+   png_debug(1, "in png_handle_sPLT\n");

+   if (!(png_ptr->mode & PNG_HAVE_IHDR))

+      png_error(png_ptr, "Missing IHDR before sPLT");

+   else if (png_ptr->mode & PNG_HAVE_IDAT)

+   {

+      png_warning(png_ptr, "Invalid sPLT after IDAT");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+#ifdef PNG_MAX_MALLOC_64K

+   if (length > (png_uint_32)65535L)

+   {

+      png_warning(png_ptr, "sPLT chunk too large to fit in memory");

+      skip = length - (png_uint_32)65535L;

+      length = (png_uint_32)65535L;

+   }

+#endif

+   chunkdata = (png_bytep)png_malloc(png_ptr, length + 1);

+   slength = (png_size_t)length;

+   png_crc_read(png_ptr, (png_bytep)chunkdata, slength);

+   if (png_crc_finish(png_ptr, skip))

+   {

+      png_free(png_ptr, chunkdata);

+      return;

+   }

+   chunkdata[slength] = 0x00;

+   for (entry_start = chunkdata; *entry_start; entry_start++)

+      /* empty loop to find end of name */ ;

+   ++entry_start;

+   /* a sample depth should follow the separator, and we should be on it  */

+   if (entry_start > chunkdata + slength)

+   {

+      png_free(png_ptr, chunkdata);

+      png_warning(png_ptr, "malformed sPLT chunk");

+      return;

+   }

+   new_palette.depth = *entry_start++;

+   entry_size = (new_palette.depth == 8 ? 6 : 10);

+   data_length = (slength - (entry_start - chunkdata));

+   /* integrity-check the data length */

+   if (data_length % entry_size)

+   {

+      png_free(png_ptr, chunkdata);

+      png_warning(png_ptr, "sPLT chunk has bad length");

+      return;

+   }

+   new_palette.nentries = (png_uint_32) (data_length / entry_size);

+   if ((png_uint_32) new_palette.nentries > (png_uint_32) (PNG_SIZE_MAX /

+       png_sizeof(png_sPLT_entry)))

+   {

+       png_warning(png_ptr, "sPLT chunk too long");

+       return;

+   }

+   new_palette.entries = (png_sPLT_entryp)png_malloc_warn(

+       png_ptr, new_palette.nentries * png_sizeof(png_sPLT_entry));

+   if (new_palette.entries == NULL)

+   {

+       png_warning(png_ptr, "sPLT chunk requires too much memory");

+       return;

+   }

+#ifndef PNG_NO_POINTER_INDEXING

+   for (i = 0; i < new_palette.nentries; i++)

+   {

+      png_sPLT_entryp pp = new_palette.entries + i;

+      if (new_palette.depth == 8)

+      {

+          pp->red = *entry_start++;

+          pp->green = *entry_start++;

+          pp->blue = *entry_start++;

+          pp->alpha = *entry_start++;

+      }

+      else

+      {

+          pp->red   = png_get_uint_16(entry_start); entry_start += 2;

+          pp->green = png_get_uint_16(entry_start); entry_start += 2;

+          pp->blue  = png_get_uint_16(entry_start); entry_start += 2;

+          pp->alpha = png_get_uint_16(entry_start); entry_start += 2;

+      }

+      pp->frequency = png_get_uint_16(entry_start); entry_start += 2;

+   }

+#else

+   pp = new_palette.entries;

+   for (i = 0; i < new_palette.nentries; i++)

+   {

+      if (new_palette.depth == 8)

+      {

+          pp[i].red   = *entry_start++;

+          pp[i].green = *entry_start++;

+          pp[i].blue  = *entry_start++;

+          pp[i].alpha = *entry_start++;

+      }

+      else

+      {

+          pp[i].red   = png_get_uint_16(entry_start); entry_start += 2;

+          pp[i].green = png_get_uint_16(entry_start); entry_start += 2;

+          pp[i].blue  = png_get_uint_16(entry_start); entry_start += 2;

+          pp[i].alpha = png_get_uint_16(entry_start); entry_start += 2;

+      }

+      pp->frequency = png_get_uint_16(entry_start); entry_start += 2;

+   }

+#endif

+   /* discard all chunk data except the name and stash that */

+   new_palette.name = (png_charp)chunkdata;

+   png_set_sPLT(png_ptr, info_ptr, &new_palette, 1);

+   png_free(png_ptr, chunkdata);

+   png_free(png_ptr, new_palette.entries);

+}

+#endif /* PNG_READ_sPLT_SUPPORTED */

+#if defined(PNG_READ_tRNS_SUPPORTED)

+void /* PRIVATE */

+png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+{

+   png_byte readbuf[PNG_MAX_PALETTE_LENGTH];

+   png_debug(1, "in png_handle_tRNS\n");

+   if (!(png_ptr->mode & PNG_HAVE_IHDR))

+      png_error(png_ptr, "Missing IHDR before tRNS");

+   else if (png_ptr->mode & PNG_HAVE_IDAT)

+   {

+      png_warning(png_ptr, "Invalid tRNS after IDAT");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))

+   {

+      png_warning(png_ptr, "Duplicate tRNS chunk");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)

+   {

+      png_byte buf[2];

+      if (length != 2)

+      {

+         png_warning(png_ptr, "Incorrect tRNS chunk length");

+         png_crc_finish(png_ptr, length);

+         return;

+      }

+      png_crc_read(png_ptr, buf, 2);

+      png_ptr->num_trans = 1;

+      png_ptr->trans_values.gray = png_get_uint_16(buf);

+   }

+   else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)

+   {

+      png_byte buf[6];

+      if (length != 6)

+      {

+         png_warning(png_ptr, "Incorrect tRNS chunk length");

+         png_crc_finish(png_ptr, length);

+         return;

+      }

+      png_crc_read(png_ptr, buf, (png_size_t)length);

+      png_ptr->num_trans = 1;

+      png_ptr->trans_values.red = png_get_uint_16(buf);

+      png_ptr->trans_values.green = png_get_uint_16(buf + 2);

+      png_ptr->trans_values.blue = png_get_uint_16(buf + 4);

+   }

+   else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+   {

+      if (!(png_ptr->mode & PNG_HAVE_PLTE))

+      {

+         /* Should be an error, but we can cope with it. */

+         png_warning(png_ptr, "Missing PLTE before tRNS");

+      }

+      if (length > (png_uint_32)png_ptr->num_palette ||

+          length > PNG_MAX_PALETTE_LENGTH)

+      {

+         png_warning(png_ptr, "Incorrect tRNS chunk length");

+         png_crc_finish(png_ptr, length);

+         return;

+      }

+      if (length == 0)

+      {

+         png_warning(png_ptr, "Zero length tRNS chunk");

+         png_crc_finish(png_ptr, length);

+         return;

+      }

+      png_crc_read(png_ptr, readbuf, (png_size_t)length);

+      png_ptr->num_trans = (png_uint_16)length;

+   }

+   else

+   {

+      png_warning(png_ptr, "tRNS chunk not allowed with alpha channel");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   if (png_crc_finish(png_ptr, 0))

+      return;

+   png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans,

+      &(png_ptr->trans_values));

+}

+#endif

+#if defined(PNG_READ_bKGD_SUPPORTED)

+void /* PRIVATE */

+png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+{

+   png_size_t truelen;

+   png_byte buf[6];

+   png_debug(1, "in png_handle_bKGD\n");

+   if (!(png_ptr->mode & PNG_HAVE_IHDR))

+      png_error(png_ptr, "Missing IHDR before bKGD");

+   else if (png_ptr->mode & PNG_HAVE_IDAT)

+   {

+      png_warning(png_ptr, "Invalid bKGD after IDAT");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&

+            !(png_ptr->mode & PNG_HAVE_PLTE))

+   {

+      png_warning(png_ptr, "Missing PLTE before bKGD");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD))

+   {

+      png_warning(png_ptr, "Duplicate bKGD chunk");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+      truelen = 1;

+   else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)

+      truelen = 6;

+   else

+      truelen = 2;

+   if (length != truelen)

+   {

+      png_warning(png_ptr, "Incorrect bKGD chunk length");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   png_crc_read(png_ptr, buf, truelen);

+   if (png_crc_finish(png_ptr, 0))

+      return;

+   /* We convert the index value into RGB components so that we can allow

+    * arbitrary RGB values for background when we have transparency, and

+    * so it is easy to determine the RGB values of the background color

+    * from the info_ptr struct. */

+   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+   {

+      png_ptr->background.index = buf[0];

+      if(info_ptr->num_palette)

+      {

+          if(buf[0] > info_ptr->num_palette)

+          {

+             png_warning(png_ptr, "Incorrect bKGD chunk index value");

+             return;

+          }

+          png_ptr->background.red =

+             (png_uint_16)png_ptr->palette[buf[0]].red;

+          png_ptr->background.green =

+             (png_uint_16)png_ptr->palette[buf[0]].green;

+          png_ptr->background.blue =

+             (png_uint_16)png_ptr->palette[buf[0]].blue;

+      }

+   }

+   else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */

+   {

+      png_ptr->background.red =

+      png_ptr->background.green =

+      png_ptr->background.blue =

+      png_ptr->background.gray = png_get_uint_16(buf);

+   }

+   else

+   {

+      png_ptr->background.red = png_get_uint_16(buf);

+      png_ptr->background.green = png_get_uint_16(buf + 2);

+      png_ptr->background.blue = png_get_uint_16(buf + 4);

+   }

+   png_set_bKGD(png_ptr, info_ptr, &(png_ptr->background));

+}

+#endif

+#if defined(PNG_READ_hIST_SUPPORTED)

+void /* PRIVATE */

+png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+{

+   unsigned int num, i;

+   png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH];

+   png_debug(1, "in png_handle_hIST\n");

+   if (!(png_ptr->mode & PNG_HAVE_IHDR))

+      png_error(png_ptr, "Missing IHDR before hIST");

+   else if (png_ptr->mode & PNG_HAVE_IDAT)

+   {

+      png_warning(png_ptr, "Invalid hIST after IDAT");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   else if (!(png_ptr->mode & PNG_HAVE_PLTE))

+   {

+      png_warning(png_ptr, "Missing PLTE before hIST");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST))

+   {

+      png_warning(png_ptr, "Duplicate hIST chunk");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   num = length / 2 ;

+   if (num != (unsigned int) png_ptr->num_palette || num >

+      (unsigned int) PNG_MAX_PALETTE_LENGTH)

+   {

+      png_warning(png_ptr, "Incorrect hIST chunk length");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   for (i = 0; i < num; i++)

+   {

+      png_byte buf[2];

+      png_crc_read(png_ptr, buf, 2);

+      readbuf[i] = png_get_uint_16(buf);

+   }

+   if (png_crc_finish(png_ptr, 0))

+      return;

+   png_set_hIST(png_ptr, info_ptr, readbuf);

+}

+#endif

+#if defined(PNG_READ_pHYs_SUPPORTED)

+void /* PRIVATE */

+png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+{

+   png_byte buf[9];

+   png_uint_32 res_x, res_y;

+   int unit_type;

+   png_debug(1, "in png_handle_pHYs\n");

+   if (!(png_ptr->mode & PNG_HAVE_IHDR))

+      png_error(png_ptr, "Missing IHDR before pHYs");

+   else if (png_ptr->mode & PNG_HAVE_IDAT)

+   {

+      png_warning(png_ptr, "Invalid pHYs after IDAT");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))

+   {

+      png_warning(png_ptr, "Duplicate pHYs chunk");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   if (length != 9)

+   {

+      png_warning(png_ptr, "Incorrect pHYs chunk length");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   png_crc_read(png_ptr, buf, 9);

+   if (png_crc_finish(png_ptr, 0))

+      return;

+   res_x = png_get_uint_32(buf);

+   res_y = png_get_uint_32(buf + 4);

+   unit_type = buf[8];

+   png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type);

+}

+#endif

+#if defined(PNG_READ_oFFs_SUPPORTED)

+void /* PRIVATE */

+png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+{

+   png_byte buf[9];

+   png_int_32 offset_x, offset_y;

+   int unit_type;

+   png_debug(1, "in png_handle_oFFs\n");

+   if (!(png_ptr->mode & PNG_HAVE_IHDR))

+      png_error(png_ptr, "Missing IHDR before oFFs");

+   else if (png_ptr->mode & PNG_HAVE_IDAT)

+   {

+      png_warning(png_ptr, "Invalid oFFs after IDAT");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))

+   {

+      png_warning(png_ptr, "Duplicate oFFs chunk");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   if (length != 9)

+   {

+      png_warning(png_ptr, "Incorrect oFFs chunk length");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   png_crc_read(png_ptr, buf, 9);

+   if (png_crc_finish(png_ptr, 0))

+      return;

+   offset_x = png_get_int_32(buf);

+   offset_y = png_get_int_32(buf + 4);

+   unit_type = buf[8];

+   png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type);

+}

+#endif

+#if defined(PNG_READ_pCAL_SUPPORTED)

+/* read the pCAL chunk (described in the PNG Extensions document) */

+void /* PRIVATE */

+png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+{

+   png_charp purpose;

+   png_int_32 X0, X1;

+   png_byte type, nparams;

+   png_charp buf, units, endptr;

+   png_charpp params;

+   png_size_t slength;

+   int i;

+   png_debug(1, "in png_handle_pCAL\n");

+   if (!(png_ptr->mode & PNG_HAVE_IHDR))

+      png_error(png_ptr, "Missing IHDR before pCAL");

+   else if (png_ptr->mode & PNG_HAVE_IDAT)

+   {

+      png_warning(png_ptr, "Invalid pCAL after IDAT");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL))

+   {

+      png_warning(png_ptr, "Duplicate pCAL chunk");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   png_debug1(2, "Allocating and reading pCAL chunk data (%lu bytes)\n",

+      length + 1);

+   purpose = (png_charp)png_malloc_warn(png_ptr, length + 1);

+   if (purpose == NULL)

+     {

+       png_warning(png_ptr, "No memory for pCAL purpose.");

+       return;

+     }

+   slength = (png_size_t)length;

+   png_crc_read(png_ptr, (png_bytep)purpose, slength);

+   if (png_crc_finish(png_ptr, 0))

+   {

+      png_free(png_ptr, purpose);

+      return;

+   }

+   purpose[slength] = 0x00; /* null terminate the last string */

+   png_debug(3, "Finding end of pCAL purpose string\n");

+   for (buf = purpose; *buf; buf++)

+      /* empty loop */ ;

+   endptr = purpose + slength;

+   /* We need to have at least 12 bytes after the purpose string

+      in order to get the parameter information. */

+   if (endptr <= buf + 12)

+   {

+      png_warning(png_ptr, "Invalid pCAL data");

+      png_free(png_ptr, purpose);

+      return;

+   }

+   png_debug(3, "Reading pCAL X0, X1, type, nparams, and units\n");

+   X0 = png_get_int_32((png_bytep)buf+1);

+   X1 = png_get_int_32((png_bytep)buf+5);

+   type = buf[9];

+   nparams = buf[10];

+   units = buf + 11;

+   png_debug(3, "Checking pCAL equation type and number of parameters\n");

+   /* Check that we have the right number of parameters for known

+      equation types. */

+   if ((type == PNG_EQUATION_LINEAR && nparams != 2) ||

+       (type == PNG_EQUATION_BASE_E && nparams != 3) ||

+       (type == PNG_EQUATION_ARBITRARY && nparams != 3) ||

+       (type == PNG_EQUATION_HYPERBOLIC && nparams != 4))

+   {

+      png_warning(png_ptr, "Invalid pCAL parameters for equation type");

+      png_free(png_ptr, purpose);

+      return;

+   }

+   else if (type >= PNG_EQUATION_LAST)

+   {

+      png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");

+   }

+   for (buf = units; *buf; buf++)

+      /* Empty loop to move past the units string. */ ;

+   png_debug(3, "Allocating pCAL parameters array\n");

+   params = (png_charpp)png_malloc_warn(png_ptr, (png_uint_32)(nparams

+      *png_sizeof(png_charp))) ;

+   if (params == NULL)

+     {

+       png_free(png_ptr, purpose);

+       png_warning(png_ptr, "No memory for pCAL params.");

+       return;

+     }

+   /* Get pointers to the start of each parameter string. */

+   for (i = 0; i < (int)nparams; i++)

+   {

+      buf++; /* Skip the null string terminator from previous parameter. */

+      png_debug1(3, "Reading pCAL parameter %d\n", i);

+      for (params[i] = buf; *buf != 0x00 && buf <= endptr; buf++)

+         /* Empty loop to move past each parameter string */ ;

+      /* Make sure we haven't run out of data yet */

+      if (buf > endptr)

+      {

+         png_warning(png_ptr, "Invalid pCAL data");

+         png_free(png_ptr, purpose);

+         png_free(png_ptr, params);

+         return;

+      }

+   }

+   png_set_pCAL(png_ptr, info_ptr, purpose, X0, X1, type, nparams,

+      units, params);

+   png_free(png_ptr, purpose);

+   png_free(png_ptr, params);

+}

+#endif

+#if defined(PNG_READ_sCAL_SUPPORTED)

+/* read the sCAL chunk */

+void /* PRIVATE */

+png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+{

+   png_charp buffer, ep;

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+   double width, height;

+   png_charp vp;

+#else

+#ifdef PNG_FIXED_POINT_SUPPORTED

+   png_charp swidth, sheight;

+#endif

+#endif

+   png_size_t slength;

+   png_debug(1, "in png_handle_sCAL\n");

+   if (!(png_ptr->mode & PNG_HAVE_IHDR))

+      png_error(png_ptr, "Missing IHDR before sCAL");

+   else if (png_ptr->mode & PNG_HAVE_IDAT)

+   {

+      png_warning(png_ptr, "Invalid sCAL after IDAT");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sCAL))

+   {

+      png_warning(png_ptr, "Duplicate sCAL chunk");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   png_debug1(2, "Allocating and reading sCAL chunk data (%lu bytes)\n",

+      length + 1);

+   buffer = (png_charp)png_malloc_warn(png_ptr, length + 1);

+   if (buffer == NULL)

+     {

+       png_warning(png_ptr, "Out of memory while processing sCAL chunk");

+       return;

+     }

+   slength = (png_size_t)length;

+   png_crc_read(png_ptr, (png_bytep)buffer, slength);

+   if (png_crc_finish(png_ptr, 0))

+   {

+      png_free(png_ptr, buffer);

+      return;

+   }

+   buffer[slength] = 0x00; /* null terminate the last string */

+   ep = buffer + 1;        /* skip unit byte */

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+   width = strtod(ep, &vp);

+   if (*vp)

+   {

+       png_warning(png_ptr, "malformed width string in sCAL chunk");

+       return;

+   }

+#else

+#ifdef PNG_FIXED_POINT_SUPPORTED

+   swidth = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);

+   if (swidth == NULL)

+     {

+       png_warning(png_ptr, "Out of memory while processing sCAL chunk width");

+       return;

+     }

+   png_memcpy(swidth, ep, (png_size_t)png_strlen(ep));

+#endif

+#endif

+   for (ep = buffer; *ep; ep++)

+      /* empty loop */ ;

+   ep++;

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+   height = strtod(ep, &vp);

+   if (*vp)

+   {

+       png_warning(png_ptr, "malformed height string in sCAL chunk");

+       return;

+   }

+#else

+#ifdef PNG_FIXED_POINT_SUPPORTED

+   sheight = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);

+   if (swidth == NULL)

+     {

+       png_warning(png_ptr, "Out of memory while processing sCAL chunk height");

+       return;

+     }

+   png_memcpy(sheight, ep, (png_size_t)png_strlen(ep));

+#endif

+#endif

+   if (buffer + slength < ep

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+      || width <= 0. || height <= 0.

+#endif

+      )

+   {

+      png_warning(png_ptr, "Invalid sCAL data");

+      png_free(png_ptr, buffer);

+#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)

+      png_free(png_ptr, swidth);

+      png_free(png_ptr, sheight);

+#endif

+      return;

+   }

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+   png_set_sCAL(png_ptr, info_ptr, buffer[0], width, height);

+#else

+#ifdef PNG_FIXED_POINT_SUPPORTED

+   png_set_sCAL_s(png_ptr, info_ptr, buffer[0], swidth, sheight);

+#endif

+#endif

+   png_free(png_ptr, buffer);

+#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)

+   png_free(png_ptr, swidth);

+   png_free(png_ptr, sheight);

+#endif

+}

+#endif

+#if defined(PNG_READ_tIME_SUPPORTED)

+void /* PRIVATE */

+png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+{

+   png_byte buf[7];

+   png_time mod_time;

+   png_debug(1, "in png_handle_tIME\n");

+   if (!(png_ptr->mode & PNG_HAVE_IHDR))

+      png_error(png_ptr, "Out of place tIME chunk");

+   else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME))

+   {

+      png_warning(png_ptr, "Duplicate tIME chunk");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   if (png_ptr->mode & PNG_HAVE_IDAT)

+      png_ptr->mode |= PNG_AFTER_IDAT;

+   if (length != 7)

+   {

+      png_warning(png_ptr, "Incorrect tIME chunk length");

+      png_crc_finish(png_ptr, length);

+      return;

+   }

+   png_crc_read(png_ptr, buf, 7);

+   if (png_crc_finish(png_ptr, 0))

+      return;

+   mod_time.second = buf[6];

+   mod_time.minute = buf[5];

+   mod_time.hour = buf[4];

+   mod_time.day = buf[3];

+   mod_time.month = buf[2];

+   mod_time.year = png_get_uint_16(buf);

+   png_set_tIME(png_ptr, info_ptr, &mod_time);

+}

+#endif

+#if defined(PNG_READ_tEXt_SUPPORTED)

+/* Note: this does not properly handle chunks that are > 64K under DOS */

+void /* PRIVATE */

+png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+{

+   png_textp text_ptr;

+   png_charp key;

+   png_charp text;

+   png_uint_32 skip = 0;

+   png_size_t slength;

+   int ret;

+   png_debug(1, "in png_handle_tEXt\n");

+   if (!(png_ptr->mode & PNG_HAVE_IHDR))

+      png_error(png_ptr, "Missing IHDR before tEXt");

+   if (png_ptr->mode & PNG_HAVE_IDAT)

+      png_ptr->mode |= PNG_AFTER_IDAT;

+#ifdef PNG_MAX_MALLOC_64K

+   if (length > (png_uint_32)65535L)

+   {

+      png_warning(png_ptr, "tEXt chunk too large to fit in memory");

+      skip = length - (png_uint_32)65535L;

+      length = (png_uint_32)65535L;

+   }

+#endif

+   key = (png_charp)png_malloc_warn(png_ptr, length + 1);

+   if (key == NULL)

+   {

+     png_warning(png_ptr, "No memory to process text chunk.");

+     return;

+   }

+   slength = (png_size_t)length;

+   png_crc_read(png_ptr, (png_bytep)key, slength);

+   if (png_crc_finish(png_ptr, skip))

+   {

+      png_free(png_ptr, key);

+      return;

+   }

+   key[slength] = 0x00;

+   for (text = key; *text; text++)

+      /* empty loop to find end of key */ ;

+   if (text != key + slength)

+      text++;

+   text_ptr = (png_textp)png_malloc_warn(png_ptr,

+      (png_uint_32)png_sizeof(png_text));

+   if (text_ptr == NULL)

+   {

+     png_warning(png_ptr, "Not enough memory to process text chunk.");

+     png_free(png_ptr, key);

+     return;

+   }

+   text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;

+   text_ptr->key = key;

+#ifdef PNG_iTXt_SUPPORTED

+   text_ptr->lang = NULL;

+   text_ptr->lang_key = NULL;

+   text_ptr->itxt_length = 0;

+#endif

+   text_ptr->text = text;

+   text_ptr->text_length = png_strlen(text);

+   ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1);

+   png_free(png_ptr, key);

+   png_free(png_ptr, text_ptr);

+   if (ret)

+     png_warning(png_ptr, "Insufficient memory to process text chunk.");

+}

+#endif

+#if defined(PNG_READ_zTXt_SUPPORTED)

+/* note: this does not correctly handle chunks that are > 64K under DOS */

+void /* PRIVATE */

+png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+{

+   png_textp text_ptr;

+   png_charp chunkdata;

+   png_charp text;

+   int comp_type;

+   int ret;

+   png_size_t slength, prefix_len, data_len;

+   png_debug(1, "in png_handle_zTXt\n");

+   if (!(png_ptr->mode & PNG_HAVE_IHDR))

+      png_error(png_ptr, "Missing IHDR before zTXt");

+   if (png_ptr->mode & PNG_HAVE_IDAT)

+      png_ptr->mode |= PNG_AFTER_IDAT;

+#ifdef PNG_MAX_MALLOC_64K

+   /* We will no doubt have problems with chunks even half this size, but

+      there is no hard and fast rule to tell us where to stop. */

+   if (length > (png_uint_32)65535L)

+   {

+     png_warning(png_ptr,"zTXt chunk too large to fit in memory");

+     png_crc_finish(png_ptr, length);

+     return;

+   }

+#endif

+   chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);

+   if (chunkdata == NULL)

+   {

+     png_warning(png_ptr,"Out of memory processing zTXt chunk.");

+     return;

+   }

+   slength = (png_size_t)length;

+   png_crc_read(png_ptr, (png_bytep)chunkdata, slength);

+   if (png_crc_finish(png_ptr, 0))

+   {

+      png_free(png_ptr, chunkdata);

+      return;

+   }

+   chunkdata[slength] = 0x00;

+   for (text = chunkdata; *text; text++)

+      /* empty loop */ ;

+   /* zTXt must have some text after the chunkdataword */

+   if (text == chunkdata + slength)

+   {

+      comp_type = PNG_TEXT_COMPRESSION_NONE;

+      png_warning(png_ptr, "Zero length zTXt chunk");

+   }

+   else

+   {

+       comp_type = *(++text);

+       if (comp_type != PNG_TEXT_COMPRESSION_zTXt)

+       {

+          png_warning(png_ptr, "Unknown compression type in zTXt chunk");

+          comp_type = PNG_TEXT_COMPRESSION_zTXt;

+       }

+       text++;        /* skip the compression_method byte */

+   }

+   prefix_len = text - chunkdata;

+   chunkdata = (png_charp)png_decompress_chunk(png_ptr, comp_type, chunkdata,

+                                    (png_size_t)length, prefix_len, &data_len);

+   text_ptr = (png_textp)png_malloc_warn(png_ptr,

+     (png_uint_32)png_sizeof(png_text));

+   if (text_ptr == NULL)

+   {

+     png_warning(png_ptr,"Not enough memory to process zTXt chunk.");

+     png_free(png_ptr, chunkdata);

+     return;

+   }

+   text_ptr->compression = comp_type;

+   text_ptr->key = chunkdata;

+#ifdef PNG_iTXt_SUPPORTED

+   text_ptr->lang = NULL;

+   text_ptr->lang_key = NULL;

+   text_ptr->itxt_length = 0;

+#endif

+   text_ptr->text = chunkdata + prefix_len;

+   text_ptr->text_length = data_len;

+   ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1);

+   png_free(png_ptr, text_ptr);

+   png_free(png_ptr, chunkdata);

+   if (ret)

+     png_error(png_ptr, "Insufficient memory to store zTXt chunk.");

+}

+#endif

+#if defined(PNG_READ_iTXt_SUPPORTED)

+/* note: this does not correctly handle chunks that are > 64K under DOS */

+void /* PRIVATE */

+png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+{

+   png_textp text_ptr;

+   png_charp chunkdata;

+   png_charp key, lang, text, lang_key;

+   int comp_flag;

+   int comp_type = 0;

+   int ret;

+   png_size_t slength, prefix_len, data_len;

+   png_debug(1, "in png_handle_iTXt\n");

+   if (!(png_ptr->mode & PNG_HAVE_IHDR))

+      png_error(png_ptr, "Missing IHDR before iTXt");

+   if (png_ptr->mode & PNG_HAVE_IDAT)

+      png_ptr->mode |= PNG_AFTER_IDAT;

+#ifdef PNG_MAX_MALLOC_64K

+   /* We will no doubt have problems with chunks even half this size, but

+      there is no hard and fast rule to tell us where to stop. */

+   if (length > (png_uint_32)65535L)

+   {

+     png_warning(png_ptr,"iTXt chunk too large to fit in memory");

+     png_crc_finish(png_ptr, length);

+     return;

+   }

+#endif

+   chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);

+   if (chunkdata == NULL)

+   {

+     png_warning(png_ptr, "No memory to process iTXt chunk.");

+     return;

+   }

+   slength = (png_size_t)length;

+   png_crc_read(png_ptr, (png_bytep)chunkdata, slength);

+   if (png_crc_finish(png_ptr, 0))

+   {

+      png_free(png_ptr, chunkdata);

+      return;

+   }

+   chunkdata[slength] = 0x00;

+   for (lang = chunkdata; *lang; lang++)

+      /* empty loop */ ;

+   lang++;        /* skip NUL separator */

+   /* iTXt must have a language tag (possibly empty), two compression bytes,

+      translated keyword (possibly empty), and possibly some text after the

+      keyword */

+   if (lang >= chunkdata + slength)

+   {

+      comp_flag = PNG_TEXT_COMPRESSION_NONE;

+      png_warning(png_ptr, "Zero length iTXt chunk");

+   }

+   else

+   {

+       comp_flag = *lang++;

+       comp_type = *lang++;

+   }

+   for (lang_key = lang; *lang_key; lang_key++)

+      /* empty loop */ ;

+   lang_key++;        /* skip NUL separator */

+   for (text = lang_key; *text; text++)

+      /* empty loop */ ;

+   text++;        /* skip NUL separator */

+   prefix_len = text - chunkdata;

+   key=chunkdata;

+   if (comp_flag)

+       chunkdata = png_decompress_chunk(png_ptr, comp_type, chunkdata,

+          (size_t)length, prefix_len, &data_len);

+   else

+       data_len=png_strlen(chunkdata + prefix_len);

+   text_ptr = (png_textp)png_malloc_warn(png_ptr,

+      (png_uint_32)png_sizeof(png_text));

+   if (text_ptr == NULL)

+   {

+     png_warning(png_ptr,"Not enough memory to process iTXt chunk.");

+     png_free(png_ptr, chunkdata);

+     return;

+   }

+   text_ptr->compression = (int)comp_flag + 1;

+   text_ptr->lang_key = chunkdata+(lang_key-key);

+   text_ptr->lang = chunkdata+(lang-key);

+   text_ptr->itxt_length = data_len;

+   text_ptr->text_length = 0;

+   text_ptr->key = chunkdata;

+   text_ptr->text = chunkdata + prefix_len;

+   ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1);

+   png_free(png_ptr, text_ptr);

+   png_free(png_ptr, chunkdata);

+   if (ret)

+     png_error(png_ptr, "Insufficient memory to store iTXt chunk.");

+}

+#endif

+/* This function is called when we haven't found a handler for a

+   chunk.  If there isn't a problem with the chunk itself (ie bad

+   chunk name, CRC, or a critical chunk), the chunk is silently ignored

+   -- unless the PNG_FLAG_UNKNOWN_CHUNKS_SUPPORTED flag is on in which

+   case it will be saved away to be written out later. */

+void /* PRIVATE */

+png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

+{

+   png_uint_32 skip = 0;

+   png_debug(1, "in png_handle_unknown\n");

+   if (png_ptr->mode & PNG_HAVE_IDAT)

+   {

+#ifdef PNG_USE_LOCAL_ARRAYS

+      PNG_IDAT;

+#endif

+      if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))  /* not an IDAT */

+         png_ptr->mode |= PNG_AFTER_IDAT;

+   }

+   png_check_chunk_name(png_ptr, png_ptr->chunk_name);

+   if (!(png_ptr->chunk_name[0] & 0x20))

+   {

+#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)

+      if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=

+           PNG_HANDLE_CHUNK_ALWAYS

+#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)

+           && png_ptr->read_user_chunk_fn == NULL

+#endif

+        )

+#endif

+          png_chunk_error(png_ptr, "unknown critical chunk");

+   }

+#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)

+   if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)

+   {

+       png_unknown_chunk chunk;

+#ifdef PNG_MAX_MALLOC_64K

+       if (length > (png_uint_32)65535L)

+       {

+           png_warning(png_ptr, "unknown chunk too large to fit in memory");

+           skip = length - (png_uint_32)65535L;

+           length = (png_uint_32)65535L;

+       }

+#endif

+       png_strcpy((png_charp)chunk.name, (png_charp)png_ptr->chunk_name);

+       chunk.data = (png_bytep)png_malloc(png_ptr, length);

+       chunk.size = (png_size_t)length;

+       png_crc_read(png_ptr, (png_bytep)chunk.data, length);

+#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)

+       if(png_ptr->read_user_chunk_fn != NULL)

+       {

+          /* callback to user unknown chunk handler */

+          if ((*(png_ptr->read_user_chunk_fn)) (png_ptr, &chunk) <= 0)

+          {

+             if (!(png_ptr->chunk_name[0] & 0x20))

+                if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=

+                     PNG_HANDLE_CHUNK_ALWAYS)

+                 {

+                   png_free(png_ptr, chunk.data);

+                   png_chunk_error(png_ptr, "unknown critical chunk");

+                 }

+             png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1);

+          }

+       }

+       else

+#endif

+          png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1);

+       png_free(png_ptr, chunk.data);

+   }

+   else

+#endif

+      skip = length;

+   png_crc_finish(png_ptr, skip);

+#if !defined(PNG_READ_USER_CHUNKS_SUPPORTED)

+   if (&info_ptr == NULL) /* quiet compiler warnings about unused info_ptr */

+      return;

+#endif

+}

+/* This function is called to verify that a chunk name is valid.

+   This function can't have the "critical chunk check" incorporated

+   into it, since in the future we will need to be able to call user

+   functions to handle unknown critical chunks after we check that

+   the chunk name itself is valid. */

+#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))

+void /* PRIVATE */

+png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name)

+{

+   png_debug(1, "in png_check_chunk_name\n");

+   if (isnonalpha(chunk_name[0]) || isnonalpha(chunk_name[1]) ||

+       isnonalpha(chunk_name[2]) || isnonalpha(chunk_name[3]))

+   {

+      png_chunk_error(png_ptr, "invalid chunk type");

+   }

+}

+/* Combines the row recently read in with the existing pixels in the

+   row.  This routine takes care of alpha and transparency if requested.

+   This routine also handles the two methods of progressive display

+   of interlaced images, depending on the mask value.

+   The mask value describes which pixels are to be combined with

+   the row.  The pattern always repeats every 8 pixels, so just 8

+   bits are needed.  A one indicates the pixel is to be combined,

+   a zero indicates the pixel is to be skipped.  This is in addition

+   to any alpha or transparency value associated with the pixel.  If

+   you want all pixels to be combined, pass 0xff (255) in mask.  */

+#ifndef PNG_HAVE_ASSEMBLER_COMBINE_ROW

+void /* PRIVATE */

+png_combine_row(png_structp png_ptr, png_bytep row, int mask)

+{

+   png_debug(1,"in png_combine_row\n");

+   if (mask == 0xff)

+   {

+      png_memcpy(row, png_ptr->row_buf + 1,

+         PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width));

+   }

+   else

+   {

+      switch (png_ptr->row_info.pixel_depth)

+      {

+         case 1:

+         {

+            png_bytep sp = png_ptr->row_buf + 1;

+            png_bytep dp = row;

+            int s_inc, s_start, s_end;

+            int m = 0x80;

+            int shift;

+            png_uint_32 i;

+            png_uint_32 row_width = png_ptr->width;

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+            if (png_ptr->transformations & PNG_PACKSWAP)

+            {

+                s_start = 0;

+                s_end = 7;

+                s_inc = 1;

+            }

+            else

+#endif

+            {

+                s_start = 7;

+                s_end = 0;

+                s_inc = -1;

+            }

+            shift = s_start;

+            for (i = 0; i < row_width; i++)

+            {

+               if (m & mask)

+               {

+                  int value;

+                  value = (*sp >> shift) & 0x01;

+                  *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);

+                  *dp |= (png_byte)(value << shift);

+               }

+               if (shift == s_end)

+               {

+                  shift = s_start;

+                  sp++;

+                  dp++;

+               }

+               else

+                  shift += s_inc;

+               if (m == 1)

+                  m = 0x80;

+               else

+                  m >>= 1;

+            }

+            break;

+         }

+         case 2:

+         {

+            png_bytep sp = png_ptr->row_buf + 1;

+            png_bytep dp = row;

+            int s_start, s_end, s_inc;

+            int m = 0x80;

+            int shift;

+            png_uint_32 i;

+            png_uint_32 row_width = png_ptr->width;

+            int value;

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+            if (png_ptr->transformations & PNG_PACKSWAP)

+            {

+               s_start = 0;

+               s_end = 6;

+               s_inc = 2;

+            }

+            else

+#endif

+            {

+               s_start = 6;

+               s_end = 0;

+               s_inc = -2;

+            }

+            shift = s_start;

+            for (i = 0; i < row_width; i++)

+            {

+               if (m & mask)

+               {

+                  value = (*sp >> shift) & 0x03;

+                  *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);

+                  *dp |= (png_byte)(value << shift);

+               }

+               if (shift == s_end)

+               {

+                  shift = s_start;

+                  sp++;

+                  dp++;

+               }

+               else

+                  shift += s_inc;

+               if (m == 1)

+                  m = 0x80;

+               else

+                  m >>= 1;

+            }

+            break;

+         }

+         case 4:

+         {

+            png_bytep sp = png_ptr->row_buf + 1;

+            png_bytep dp = row;

+            int s_start, s_end, s_inc;

+            int m = 0x80;

+            int shift;

+            png_uint_32 i;

+            png_uint_32 row_width = png_ptr->width;

+            int value;

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+            if (png_ptr->transformations & PNG_PACKSWAP)

+            {

+               s_start = 0;

+               s_end = 4;

+               s_inc = 4;

+            }

+            else

+#endif

+            {

+               s_start = 4;

+               s_end = 0;

+               s_inc = -4;

+            }

+            shift = s_start;

+            for (i = 0; i < row_width; i++)

+            {

+               if (m & mask)

+               {

+                  value = (*sp >> shift) & 0xf;

+                  *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);

+                  *dp |= (png_byte)(value << shift);

+               }

+               if (shift == s_end)

+               {

+                  shift = s_start;

+                  sp++;

+                  dp++;

+               }

+               else

+                  shift += s_inc;

+               if (m == 1)

+                  m = 0x80;

+               else

+                  m >>= 1;

+            }

+            break;

+         }

+         default:

+         {

+            png_bytep sp = png_ptr->row_buf + 1;

+            png_bytep dp = row;

+            png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);

+            png_uint_32 i;

+            png_uint_32 row_width = png_ptr->width;

+            png_byte m = 0x80;

+            for (i = 0; i < row_width; i++)

+            {

+               if (m & mask)

+               {

+                  png_memcpy(dp, sp, pixel_bytes);

+               }

+               sp += pixel_bytes;

+               dp += pixel_bytes;

+               if (m == 1)

+                  m = 0x80;

+               else

+                  m >>= 1;

+            }

+            break;

+         }

+      }

+   }

+}

+#endif /* !PNG_HAVE_ASSEMBLER_COMBINE_ROW */

+#ifdef PNG_READ_INTERLACING_SUPPORTED

+#ifndef PNG_HAVE_ASSEMBLER_READ_INTERLACE   /* else in pngvcrd.c, pnggccrd.c */

+/* OLD pre-1.0.9 interface:

+void png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,

+   png_uint_32 transformations)

+ */

+void /* PRIVATE */

+png_do_read_interlace(png_structp png_ptr)

+{

+   png_row_infop row_info = &(png_ptr->row_info);

+   png_bytep row = png_ptr->row_buf + 1;

+   int pass = png_ptr->pass;

+   png_uint_32 transformations = png_ptr->transformations;

+#ifdef PNG_USE_LOCAL_ARRAYS

+   /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */

+   /* offset to next interlace block */

+   const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

+#endif

+   png_debug(1,"in png_do_read_interlace (stock C version)\n");

+   if (row != NULL && row_info != NULL)

+   {

+      png_uint_32 final_width;

+      final_width = row_info->width * png_pass_inc[pass];

+      switch (row_info->pixel_depth)

+      {

+         case 1:

+         {

+            png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 3);

+            png_bytep dp = row + (png_size_t)((final_width - 1) >> 3);

+            int sshift, dshift;

+            int s_start, s_end, s_inc;

+            int jstop = png_pass_inc[pass];

+            png_byte v;

+            png_uint_32 i;

+            int j;

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+            if (transformations & PNG_PACKSWAP)

+            {

+                sshift = (int)((row_info->width + 7) & 0x07);

+                dshift = (int)((final_width + 7) & 0x07);

+                s_start = 7;

+                s_end = 0;

+                s_inc = -1;

+            }

+            else

+#endif

+            {

+                sshift = 7 - (int)((row_info->width + 7) & 0x07);

+                dshift = 7 - (int)((final_width + 7) & 0x07);

+                s_start = 0;

+                s_end = 7;

+                s_inc = 1;

+            }

+            for (i = 0; i < row_info->width; i++)

+            {

+               v = (png_byte)((*sp >> sshift) & 0x01);

+               for (j = 0; j < jstop; j++)

+               {

+                  *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff);

+                  *dp |= (png_byte)(v << dshift);

+                  if (dshift == s_end)

+                  {

+                     dshift = s_start;

+                     dp--;

+                  }

+                  else

+                     dshift += s_inc;

+               }

+               if (sshift == s_end)

+               {

+                  sshift = s_start;

+                  sp--;

+               }

+               else

+                  sshift += s_inc;

+            }

+            break;

+         }

+         case 2:

+         {

+            png_bytep sp = row + (png_uint_32)((row_info->width - 1) >> 2);

+            png_bytep dp = row + (png_uint_32)((final_width - 1) >> 2);

+            int sshift, dshift;

+            int s_start, s_end, s_inc;

+            int jstop = png_pass_inc[pass];

+            png_uint_32 i;

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+            if (transformations & PNG_PACKSWAP)

+            {

+               sshift = (int)(((row_info->width + 3) & 0x03) << 1);

+               dshift = (int)(((final_width + 3) & 0x03) << 1);

+               s_start = 6;

+               s_end = 0;

+               s_inc = -2;

+            }

+            else

+#endif

+            {

+               sshift = (int)((3 - ((row_info->width + 3) & 0x03)) << 1);

+               dshift = (int)((3 - ((final_width + 3) & 0x03)) << 1);

+               s_start = 0;

+               s_end = 6;

+               s_inc = 2;

+            }

+            for (i = 0; i < row_info->width; i++)

+            {

+               png_byte v;

+               int j;

+               v = (png_byte)((*sp >> sshift) & 0x03);

+               for (j = 0; j < jstop; j++)

+               {

+                  *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff);

+                  *dp |= (png_byte)(v << dshift);

+                  if (dshift == s_end)

+                  {

+                     dshift = s_start;

+                     dp--;

+                  }

+                  else

+                     dshift += s_inc;

+               }

+               if (sshift == s_end)

+               {

+                  sshift = s_start;

+                  sp--;

+               }

+               else

+                  sshift += s_inc;

+            }

+            break;

+         }

+         case 4:

+         {

+            png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 1);

+            png_bytep dp = row + (png_size_t)((final_width - 1) >> 1);

+            int sshift, dshift;

+            int s_start, s_end, s_inc;

+            png_uint_32 i;

+            int jstop = png_pass_inc[pass];

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+            if (transformations & PNG_PACKSWAP)

+            {

+               sshift = (int)(((row_info->width + 1) & 0x01) << 2);

+               dshift = (int)(((final_width + 1) & 0x01) << 2);

+               s_start = 4;

+               s_end = 0;

+               s_inc = -4;

+            }

+            else

+#endif

+            {

+               sshift = (int)((1 - ((row_info->width + 1) & 0x01)) << 2);

+               dshift = (int)((1 - ((final_width + 1) & 0x01)) << 2);

+               s_start = 0;

+               s_end = 4;

+               s_inc = 4;

+            }

+            for (i = 0; i < row_info->width; i++)

+            {

+               png_byte v = (png_byte)((*sp >> sshift) & 0xf);

+               int j;

+               for (j = 0; j < jstop; j++)

+               {

+                  *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff);

+                  *dp |= (png_byte)(v << dshift);

+                  if (dshift == s_end)

+                  {

+                     dshift = s_start;

+                     dp--;

+                  }

+                  else

+                     dshift += s_inc;

+               }

+               if (sshift == s_end)

+               {

+                  sshift = s_start;

+                  sp--;

+               }

+               else

+                  sshift += s_inc;

+            }

+            break;

+         }

+         default:

+         {

+            png_size_t pixel_bytes = (row_info->pixel_depth >> 3);

+            png_bytep sp = row + (png_size_t)(row_info->width - 1) * pixel_bytes;

+            png_bytep dp = row + (png_size_t)(final_width - 1) * pixel_bytes;

+            int jstop = png_pass_inc[pass];

+            png_uint_32 i;

+            for (i = 0; i < row_info->width; i++)

+            {

+               png_byte v[8];

+               int j;

+               png_memcpy(v, sp, pixel_bytes);

+               for (j = 0; j < jstop; j++)

+               {

+                  png_memcpy(dp, v, pixel_bytes);

+                  dp -= pixel_bytes;

+               }

+               sp -= pixel_bytes;

+            }

+            break;

+         }

+      }

+      row_info->width = final_width;

+      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,final_width);

+   }

+#if !defined(PNG_READ_PACKSWAP_SUPPORTED)

+   if (&transformations == NULL) /* silence compiler warning */

+      return;

+#endif

+}

+#endif /* !PNG_HAVE_ASSEMBLER_READ_INTERLACE */

+#endif /* PNG_READ_INTERLACING_SUPPORTED */

+#ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW

+void /* PRIVATE */

+png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,

+   png_bytep prev_row, int filter)

+{

+   png_debug(1, "in png_read_filter_row\n");

+   png_debug2(2,"row = %lu, filter = %d\n", png_ptr->row_number, filter);

+   switch (filter)

+   {

+      case PNG_FILTER_VALUE_NONE:

+         break;

+      case PNG_FILTER_VALUE_SUB:

+      {

+         png_uint_32 i;

+         png_uint_32 istop = row_info->rowbytes;

+         png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;

+         png_bytep rp = row + bpp;

+         png_bytep lp = row;

+         for (i = bpp; i < istop; i++)

+         {

+            *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff);

+            rp++;

+         }

+         break;

+      }

+      case PNG_FILTER_VALUE_UP:

+      {

+         png_uint_32 i;

+         png_uint_32 istop = row_info->rowbytes;

+         png_bytep rp = row;

+         png_bytep pp = prev_row;

+         for (i = 0; i < istop; i++)

+         {

+            *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);

+            rp++;

+         }

+         break;

+      }

+      case PNG_FILTER_VALUE_AVG:

+      {

+         png_uint_32 i;

+         png_bytep rp = row;

+         png_bytep pp = prev_row;

+         png_bytep lp = row;

+         png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;

+         png_uint_32 istop = row_info->rowbytes - bpp;

+         for (i = 0; i < bpp; i++)

+         {

+            *rp = (png_byte)(((int)(*rp) +

+               ((int)(*pp++) / 2 )) & 0xff);

+            rp++;

+         }

+         for (i = 0; i < istop; i++)

+         {

+            *rp = (png_byte)(((int)(*rp) +

+               (int)(*pp++ + *lp++) / 2 ) & 0xff);

+            rp++;

+         }

+         break;

+      }

+      case PNG_FILTER_VALUE_PAETH:

+      {

+         png_uint_32 i;

+         png_bytep rp = row;

+         png_bytep pp = prev_row;

+         png_bytep lp = row;

+         png_bytep cp = prev_row;

+         png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;

+         png_uint_32 istop=row_info->rowbytes - bpp;

+         for (i = 0; i < bpp; i++)

+         {

+            *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);

+            rp++;

+         }

+         for (i = 0; i < istop; i++)   /* use leftover rp,pp */

+         {

+            int a, b, c, pa, pb, pc, p;

+            a = *lp++;

+            b = *pp++;

+            c = *cp++;

+            p = b - c;

+            pc = a - c;

+#ifdef PNG_USE_ABS

+            pa = abs(p);

+            pb = abs(pc);

+            pc = abs(p + pc);

+#else

+            pa = p < 0 ? -p : p;

+            pb = pc < 0 ? -pc : pc;

+            pc = (p + pc) < 0 ? -(p + pc) : p + pc;

+#endif

+            /*

+               if (pa <= pb && pa <= pc)

+                  p = a;

+               else if (pb <= pc)

+                  p = b;

+               else

+                  p = c;

+             */

+            p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;

+            *rp = (png_byte)(((int)(*rp) + p) & 0xff);

+            rp++;

+         }

+         break;

+      }

+      default:

+         png_warning(png_ptr, "Ignoring bad adaptive filter type");

+         *row=0;

+         break;

+   }

+}

+#endif /* !PNG_HAVE_ASSEMBLER_READ_FILTER_ROW */

+void /* PRIVATE */

+png_read_finish_row(png_structp png_ptr)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */

+   /* start of interlace block */

+   const int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

+   /* offset to next interlace block */

+   const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

+   /* start of interlace block in the y direction */

+   const int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};

+   /* offset to next interlace block in the y direction */

+   const int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};

+#endif

+   png_debug(1, "in png_read_finish_row\n");

+   png_ptr->row_number++;

+   if (png_ptr->row_number < png_ptr->num_rows)

+      return;

+   if (png_ptr->interlaced)

+   {

+      png_ptr->row_number = 0;

+      png_memset_check(png_ptr, png_ptr->prev_row, 0, png_ptr->rowbytes + 1);

+      do

+      {

+         png_ptr->pass++;

+         if (png_ptr->pass >= 7)

+            break;

+         png_ptr->iwidth = (png_ptr->width +

+            png_pass_inc[png_ptr->pass] - 1 -

+            png_pass_start[png_ptr->pass]) /

+            png_pass_inc[png_ptr->pass];

+         png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,

+            png_ptr->iwidth) + 1;

+         if (!(png_ptr->transformations & PNG_INTERLACE))

+         {

+            png_ptr->num_rows = (png_ptr->height +

+               png_pass_yinc[png_ptr->pass] - 1 -

+               png_pass_ystart[png_ptr->pass]) /

+               png_pass_yinc[png_ptr->pass];

+            if (!(png_ptr->num_rows))

+               continue;

+         }

+         else  /* if (png_ptr->transformations & PNG_INTERLACE) */

+            break;

+      } while (png_ptr->iwidth == 0);

+      if (png_ptr->pass < 7)

+         return;

+   }

+   if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))

+   {

+#ifdef PNG_USE_LOCAL_ARRAYS

+      PNG_IDAT;

+#endif

+      char extra;

+      int ret;

+      png_ptr->zstream.next_out = (Byte *)&extra;

+      png_ptr->zstream.avail_out = (uInt)1;

+      for(;;)

+      {

+         if (!(png_ptr->zstream.avail_in))

+         {

+            while (!png_ptr->idat_size)

+            {

+               png_byte chunk_length[4];

+               png_crc_finish(png_ptr, 0);

+               png_read_data(png_ptr, chunk_length, 4);

+               png_ptr->idat_size = png_get_uint_31(png_ptr, chunk_length);

+               png_reset_crc(png_ptr);

+               png_crc_read(png_ptr, png_ptr->chunk_name, 4);

+               if (png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4))

+                  png_error(png_ptr, "Not enough image data");

+            }

+            png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;

+            png_ptr->zstream.next_in = png_ptr->zbuf;

+            if (png_ptr->zbuf_size > png_ptr->idat_size)

+               png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;

+            png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in);

+            png_ptr->idat_size -= png_ptr->zstream.avail_in;

+         }

+         ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);

+         if (ret == Z_STREAM_END)

+         {

+            if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in ||

+               png_ptr->idat_size)

+               png_warning(png_ptr, "Extra compressed data");

+            png_ptr->mode |= PNG_AFTER_IDAT;

+            png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

+            break;

+         }

+         if (ret != Z_OK)

+            png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :

+                      "Decompression Error");

+         if (!(png_ptr->zstream.avail_out))

+         {

+            png_warning(png_ptr, "Extra compressed data.");

+            png_ptr->mode |= PNG_AFTER_IDAT;

+            png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;

+            break;

+         }

+      }

+      png_ptr->zstream.avail_out = 0;

+   }

+   if (png_ptr->idat_size || png_ptr->zstream.avail_in)

+      png_warning(png_ptr, "Extra compression data");

+   inflateReset(&png_ptr->zstream);

+   png_ptr->mode |= PNG_AFTER_IDAT;

+}

+void /* PRIVATE */

+png_read_start_row(png_structp png_ptr)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */

+   /* start of interlace block */

+   const int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

+   /* offset to next interlace block */

+   const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

+   /* start of interlace block in the y direction */

+   const int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};

+   /* offset to next interlace block in the y direction */

+   const int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};

+#endif

+   int max_pixel_depth;

+   png_uint_32 row_bytes;

+   png_debug(1, "in png_read_start_row\n");

+   png_ptr->zstream.avail_in = 0;

+   png_init_read_transformations(png_ptr);

+   if (png_ptr->interlaced)

+   {

+      if (!(png_ptr->transformations & PNG_INTERLACE))

+         png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -

+            png_pass_ystart[0]) / png_pass_yinc[0];

+      else

+         png_ptr->num_rows = png_ptr->height;

+      png_ptr->iwidth = (png_ptr->width +

+         png_pass_inc[png_ptr->pass] - 1 -

+         png_pass_start[png_ptr->pass]) /

+         png_pass_inc[png_ptr->pass];

+         row_bytes = PNG_ROWBYTES(png_ptr->pixel_depth,png_ptr->iwidth) + 1;

+         png_ptr->irowbytes = (png_size_t)row_bytes;

+         if((png_uint_32)png_ptr->irowbytes != row_bytes)

+            png_error(png_ptr, "Rowbytes overflow in png_read_start_row");

+   }

+   else

+   {

+      png_ptr->num_rows = png_ptr->height;

+      png_ptr->iwidth = png_ptr->width;

+      png_ptr->irowbytes = png_ptr->rowbytes + 1;

+   }

+   max_pixel_depth = png_ptr->pixel_depth;

+#if defined(PNG_READ_PACK_SUPPORTED)

+   if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8)

+      max_pixel_depth = 8;

+#endif

+#if defined(PNG_READ_EXPAND_SUPPORTED)

+   if (png_ptr->transformations & PNG_EXPAND)

+   {

+      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+      {

+         if (png_ptr->num_trans)

+            max_pixel_depth = 32;

+         else

+            max_pixel_depth = 24;

+      }

+      else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)

+      {

+         if (max_pixel_depth < 8)

+            max_pixel_depth = 8;

+         if (png_ptr->num_trans)

+            max_pixel_depth *= 2;

+      }

+      else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)

+      {

+         if (png_ptr->num_trans)

+         {

+            max_pixel_depth *= 4;

+            max_pixel_depth /= 3;

+         }

+      }

+   }

+#endif

+#if defined(PNG_READ_FILLER_SUPPORTED)

+   if (png_ptr->transformations & (PNG_FILLER))

+   {

+      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+         max_pixel_depth = 32;

+      else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)

+      {

+         if (max_pixel_depth <= 8)

+            max_pixel_depth = 16;

+         else

+            max_pixel_depth = 32;

+      }

+      else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)

+      {

+         if (max_pixel_depth <= 32)

+            max_pixel_depth = 32;

+         else

+            max_pixel_depth = 64;

+      }

+   }

+#endif

+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)

+   if (png_ptr->transformations & PNG_GRAY_TO_RGB)

+   {

+      if (

+#if defined(PNG_READ_EXPAND_SUPPORTED)

+        (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) ||

+#endif

+#if defined(PNG_READ_FILLER_SUPPORTED)

+        (png_ptr->transformations & (PNG_FILLER)) ||

+#endif

+        png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

+      {

+         if (max_pixel_depth <= 16)

+            max_pixel_depth = 32;

+         else

+            max_pixel_depth = 64;

+      }

+      else

+      {

+         if (max_pixel_depth <= 8)

+           {

+             if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+               max_pixel_depth = 32;

+             else

+               max_pixel_depth = 24;

+           }

+         else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+            max_pixel_depth = 64;

+         else

+            max_pixel_depth = 48;

+      }

+   }

+#endif

+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) && \

+defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)

+   if(png_ptr->transformations & PNG_USER_TRANSFORM)

+     {

+       int user_pixel_depth=png_ptr->user_transform_depth*

+         png_ptr->user_transform_channels;

+       if(user_pixel_depth > max_pixel_depth)

+         max_pixel_depth=user_pixel_depth;

+     }

+#endif

+   /* align the width on the next larger 8 pixels.  Mainly used

+      for interlacing */

+   row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7));

+   /* calculate the maximum bytes needed, adding a byte and a pixel

+      for safety's sake */

+   row_bytes = PNG_ROWBYTES(max_pixel_depth,row_bytes) +

+      1 + ((max_pixel_depth + 7) >> 3);

+#ifdef PNG_MAX_MALLOC_64K

+   if (row_bytes > (png_uint_32)65536L)

+      png_error(png_ptr, "This image requires a row greater than 64KB");

+#endif

+   png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes+64);

+   png_ptr->row_buf = png_ptr->big_row_buf+32;

+#if defined(PNG_DEBUG) && defined(PNG_USE_PNGGCCRD)

+   png_ptr->row_buf_size = row_bytes;

+#endif

+#ifdef PNG_MAX_MALLOC_64K

+   if ((png_uint_32)png_ptr->rowbytes + 1 > (png_uint_32)65536L)

+      png_error(png_ptr, "This image requires a row greater than 64KB");

+#endif

+   if ((png_uint_32)png_ptr->rowbytes > PNG_SIZE_MAX - 1)

+      png_error(png_ptr, "Row has too many bytes to allocate in memory.");

+   png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)(

+      png_ptr->rowbytes + 1));

+   png_memset_check(png_ptr, png_ptr->prev_row, 0, png_ptr->rowbytes + 1);

+   png_debug1(3, "width = %lu,\n", png_ptr->width);

+   png_debug1(3, "height = %lu,\n", png_ptr->height);

+   png_debug1(3, "iwidth = %lu,\n", png_ptr->iwidth);

+   png_debug1(3, "num_rows = %lu\n", png_ptr->num_rows);

+   png_debug1(3, "rowbytes = %lu,\n", png_ptr->rowbytes);

+   png_debug1(3, "irowbytes = %lu,\n", png_ptr->irowbytes);

+   png_ptr->flags |= PNG_FLAG_ROW_INIT;

+}

--- /dev/null

+++ b/src/gfx/libpng/pngset.c

@@ -1,0 +1,1219 @@

+/* pngset.c - storage of image information into info struct

+ *

+ * libpng 1.2.8 - December 3, 2004

+ * For conditions of distribution and use, see copyright notice in png.h

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

+ *

+ * The functions here are used during reads to store data from the file

+ * into the info struct, and during writes to store application data

+ * into the info struct for writing into the file.  This abstracts the

+ * info struct and allows us to change the structure in the future.

+ */

+#define PNG_INTERNAL

+#include "png.h"

+#if defined(PNG_bKGD_SUPPORTED)

+void PNGAPI

+png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background)

+{

+   png_debug1(1, "in %s storage function\n", "bKGD");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+   png_memcpy(&(info_ptr->background), background, png_sizeof(png_color_16));

+   info_ptr->valid |= PNG_INFO_bKGD;

+}

+#endif

+#if defined(PNG_cHRM_SUPPORTED)

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+void PNGAPI

+png_set_cHRM(png_structp png_ptr, png_infop info_ptr,

+   double white_x, double white_y, double red_x, double red_y,

+   double green_x, double green_y, double blue_x, double blue_y)

+{

+   png_debug1(1, "in %s storage function\n", "cHRM");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+   if (white_x < 0.0 || white_y < 0.0 ||

+         red_x < 0.0 ||   red_y < 0.0 ||

+       green_x < 0.0 || green_y < 0.0 ||

+        blue_x < 0.0 ||  blue_y < 0.0)

+   {

+      png_warning(png_ptr,

+        "Ignoring attempt to set negative chromaticity value");

+      return;

+   }

+   if (white_x > 21474.83 || white_y > 21474.83 ||

+         red_x > 21474.83 ||   red_y > 21474.83 ||

+       green_x > 21474.83 || green_y > 21474.83 ||

+        blue_x > 21474.83 ||  blue_y > 21474.83)

+   {

+      png_warning(png_ptr,

+        "Ignoring attempt to set chromaticity value exceeding 21474.83");

+      return;

+   }

+   info_ptr->x_white = (float)white_x;

+   info_ptr->y_white = (float)white_y;

+   info_ptr->x_red   = (float)red_x;

+   info_ptr->y_red   = (float)red_y;

+   info_ptr->x_green = (float)green_x;

+   info_ptr->y_green = (float)green_y;

+   info_ptr->x_blue  = (float)blue_x;

+   info_ptr->y_blue  = (float)blue_y;

+#ifdef PNG_FIXED_POINT_SUPPORTED

+   info_ptr->int_x_white = (png_fixed_point)(white_x*100000.+0.5);

+   info_ptr->int_y_white = (png_fixed_point)(white_y*100000.+0.5);

+   info_ptr->int_x_red   = (png_fixed_point)(  red_x*100000.+0.5);

+   info_ptr->int_y_red   = (png_fixed_point)(  red_y*100000.+0.5);

+   info_ptr->int_x_green = (png_fixed_point)(green_x*100000.+0.5);

+   info_ptr->int_y_green = (png_fixed_point)(green_y*100000.+0.5);

+   info_ptr->int_x_blue  = (png_fixed_point)( blue_x*100000.+0.5);

+   info_ptr->int_y_blue  = (png_fixed_point)( blue_y*100000.+0.5);

+#endif

+   info_ptr->valid |= PNG_INFO_cHRM;

+}

+#endif

+#ifdef PNG_FIXED_POINT_SUPPORTED

+void PNGAPI

+png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,

+   png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,

+   png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,

+   png_fixed_point blue_x, png_fixed_point blue_y)

+{

+   png_debug1(1, "in %s storage function\n", "cHRM");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+   if (white_x < 0 || white_y < 0 ||

+         red_x < 0 ||   red_y < 0 ||

+       green_x < 0 || green_y < 0 ||

+        blue_x < 0 ||  blue_y < 0)

+   {

+      png_warning(png_ptr,

+        "Ignoring attempt to set negative chromaticity value");

+      return;

+   }

+   if (white_x > (double) PNG_UINT_31_MAX ||

+       white_y > (double) PNG_UINT_31_MAX ||

+         red_x > (double) PNG_UINT_31_MAX ||

+         red_y > (double) PNG_UINT_31_MAX ||

+       green_x > (double) PNG_UINT_31_MAX ||

+       green_y > (double) PNG_UINT_31_MAX ||

+        blue_x > (double) PNG_UINT_31_MAX ||

+        blue_y > (double) PNG_UINT_31_MAX)

+   {

+      png_warning(png_ptr,

+        "Ignoring attempt to set chromaticity value exceeding 21474.83");

+      return;

+   }

+   info_ptr->int_x_white = white_x;

+   info_ptr->int_y_white = white_y;

+   info_ptr->int_x_red   = red_x;

+   info_ptr->int_y_red   = red_y;

+   info_ptr->int_x_green = green_x;

+   info_ptr->int_y_green = green_y;

+   info_ptr->int_x_blue  = blue_x;

+   info_ptr->int_y_blue  = blue_y;

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+   info_ptr->x_white = (float)(white_x/100000.);

+   info_ptr->y_white = (float)(white_y/100000.);

+   info_ptr->x_red   = (float)(  red_x/100000.);

+   info_ptr->y_red   = (float)(  red_y/100000.);

+   info_ptr->x_green = (float)(green_x/100000.);

+   info_ptr->y_green = (float)(green_y/100000.);

+   info_ptr->x_blue  = (float)( blue_x/100000.);

+   info_ptr->y_blue  = (float)( blue_y/100000.);

+#endif

+   info_ptr->valid |= PNG_INFO_cHRM;

+}

+#endif

+#endif

+#if defined(PNG_gAMA_SUPPORTED)

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+void PNGAPI

+png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)

+{

+   double gamma;

+   png_debug1(1, "in %s storage function\n", "gAMA");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+   /* Check for overflow */

+   if (file_gamma > 21474.83)

+   {

+      png_warning(png_ptr, "Limiting gamma to 21474.83");

+      gamma=21474.83;

+   }

+   else

+      gamma=file_gamma;

+   info_ptr->gamma = (float)gamma;

+#ifdef PNG_FIXED_POINT_SUPPORTED

+   info_ptr->int_gamma = (int)(gamma*100000.+.5);

+#endif

+   info_ptr->valid |= PNG_INFO_gAMA;

+   if(gamma == 0.0)

+      png_warning(png_ptr, "Setting gamma=0");

+}

+#endif

+void PNGAPI

+png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point

+   int_gamma)

+{

+   png_fixed_point gamma;

+   png_debug1(1, "in %s storage function\n", "gAMA");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+   if (int_gamma > (png_fixed_point) PNG_UINT_31_MAX)

+   {

+     png_warning(png_ptr, "Limiting gamma to 21474.83");

+     gamma=PNG_UINT_31_MAX;

+   }

+   else

+   {

+     if (int_gamma < 0)

+     {

+       png_warning(png_ptr, "Setting negative gamma to zero");

+       gamma=0;

+     }

+     else

+       gamma=int_gamma;

+   }

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+   info_ptr->gamma = (float)(gamma/100000.);

+#endif

+#ifdef PNG_FIXED_POINT_SUPPORTED

+   info_ptr->int_gamma = gamma;

+#endif

+   info_ptr->valid |= PNG_INFO_gAMA;

+   if(gamma == 0)

+      png_warning(png_ptr, "Setting gamma=0");

+}

+#endif

+#if defined(PNG_hIST_SUPPORTED)

+void PNGAPI

+png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)

+{

+   int i;

+   png_debug1(1, "in %s storage function\n", "hIST");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+   if (info_ptr->num_palette == 0)

+   {

+       png_warning(png_ptr,

+          "Palette size 0, hIST allocation skipped.");

+       return;

+   }

+#ifdef PNG_FREE_ME_SUPPORTED

+   png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0);

+#endif

+   /* Changed from info->num_palette to 256 in version 1.2.1 */

+   png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr,

+      (png_uint_32)(256 * png_sizeof (png_uint_16)));

+   if (png_ptr->hist == NULL)

+     {

+       png_warning(png_ptr, "Insufficient memory for hIST chunk data.");

+       return;

+     }

+   for (i = 0; i < info_ptr->num_palette; i++)

+       png_ptr->hist[i] = hist[i];

+   info_ptr->hist = png_ptr->hist;

+   info_ptr->valid |= PNG_INFO_hIST;

+#ifdef PNG_FREE_ME_SUPPORTED

+   info_ptr->free_me |= PNG_FREE_HIST;

+#else

+   png_ptr->flags |= PNG_FLAG_FREE_HIST;

+#endif

+}

+#endif

+void PNGAPI

+png_set_IHDR(png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 width, png_uint_32 height, int bit_depth,

+   int color_type, int interlace_type, int compression_type,

+   int filter_type)

+{

+   png_debug1(1, "in %s storage function\n", "IHDR");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+   /* check for width and height valid values */

+   if (width == 0 || height == 0)

+      png_error(png_ptr, "Image width or height is zero in IHDR");

+#ifdef PNG_SET_USER_LIMITS_SUPPORTED

+   if (width > png_ptr->user_width_max || height > png_ptr->user_height_max)

+      png_error(png_ptr, "image size exceeds user limits in IHDR");

+#else

+   if (width > PNG_USER_WIDTH_MAX || height > PNG_USER_HEIGHT_MAX)

+      png_error(png_ptr, "image size exceeds user limits in IHDR");

+#endif

+   if (width > PNG_UINT_31_MAX || height > PNG_UINT_31_MAX)

+      png_error(png_ptr, "Invalid image size in IHDR");

+   if ( width > (PNG_UINT_32_MAX

+                 >> 3)      /* 8-byte RGBA pixels */

+                 - 64       /* bigrowbuf hack */

+                 - 1        /* filter byte */

+                 - 7*8      /* rounding of width to multiple of 8 pixels */

+                 - 8)       /* extra max_pixel_depth pad */

+      png_warning(png_ptr, "Width is too large for libpng to process pixels");

+   /* check other values */

+   if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&

+      bit_depth != 8 && bit_depth != 16)

+      png_error(png_ptr, "Invalid bit depth in IHDR");

+   if (color_type < 0 || color_type == 1 ||

+      color_type == 5 || color_type > 6)

+      png_error(png_ptr, "Invalid color type in IHDR");

+   if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||

+       ((color_type == PNG_COLOR_TYPE_RGB ||

+         color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||

+         color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))

+      png_error(png_ptr, "Invalid color type/bit depth combination in IHDR");

+   if (interlace_type >= PNG_INTERLACE_LAST)

+      png_error(png_ptr, "Unknown interlace method in IHDR");

+   if (compression_type != PNG_COMPRESSION_TYPE_BASE)

+      png_error(png_ptr, "Unknown compression method in IHDR");

+#if defined(PNG_MNG_FEATURES_SUPPORTED)

+   /* Accept filter_method 64 (intrapixel differencing) only if

+    * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and

+    * 2. Libpng did not read a PNG signature (this filter_method is only

+    *    used in PNG datastreams that are embedded in MNG datastreams) and

+    * 3. The application called png_permit_mng_features with a mask that

+    *    included PNG_FLAG_MNG_FILTER_64 and

+    * 4. The filter_method is 64 and

+    * 5. The color_type is RGB or RGBA

+    */

+   if((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&png_ptr->mng_features_permitted)

+      png_warning(png_ptr,"MNG features are not allowed in a PNG datastream\n");

+   if(filter_type != PNG_FILTER_TYPE_BASE)

+   {

+     if(!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&

+        (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&

+        ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&

+        (color_type == PNG_COLOR_TYPE_RGB ||

+         color_type == PNG_COLOR_TYPE_RGB_ALPHA)))

+        png_error(png_ptr, "Unknown filter method in IHDR");

+     if(png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)

+        png_warning(png_ptr, "Invalid filter method in IHDR");

+   }

+#else

+   if(filter_type != PNG_FILTER_TYPE_BASE)

+      png_error(png_ptr, "Unknown filter method in IHDR");

+#endif

+   info_ptr->width = width;

+   info_ptr->height = height;

+   info_ptr->bit_depth = (png_byte)bit_depth;

+   info_ptr->color_type =(png_byte) color_type;

+   info_ptr->compression_type = (png_byte)compression_type;

+   info_ptr->filter_type = (png_byte)filter_type;

+   info_ptr->interlace_type = (png_byte)interlace_type;

+   if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+      info_ptr->channels = 1;

+   else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)

+      info_ptr->channels = 3;

+   else

+      info_ptr->channels = 1;

+   if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)

+      info_ptr->channels++;

+   info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);

+   /* check for potential overflow */

+   if ( width > (PNG_UINT_32_MAX

+                 >> 3)      /* 8-byte RGBA pixels */

+                 - 64       /* bigrowbuf hack */

+                 - 1        /* filter byte */

+                 - 7*8      /* rounding of width to multiple of 8 pixels */

+                 - 8)       /* extra max_pixel_depth pad */

+      info_ptr->rowbytes = (png_size_t)0;

+   else

+      info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth,width);

+}

+#if defined(PNG_oFFs_SUPPORTED)

+void PNGAPI

+png_set_oFFs(png_structp png_ptr, png_infop info_ptr,

+   png_int_32 offset_x, png_int_32 offset_y, int unit_type)

+{

+   png_debug1(1, "in %s storage function\n", "oFFs");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+   info_ptr->x_offset = offset_x;

+   info_ptr->y_offset = offset_y;

+   info_ptr->offset_unit_type = (png_byte)unit_type;

+   info_ptr->valid |= PNG_INFO_oFFs;

+}

+#endif

+#if defined(PNG_pCAL_SUPPORTED)

+void PNGAPI

+png_set_pCAL(png_structp png_ptr, png_infop info_ptr,

+   png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,

+   png_charp units, png_charpp params)

+{

+   png_uint_32 length;

+   int i;

+   png_debug1(1, "in %s storage function\n", "pCAL");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+   length = png_strlen(purpose) + 1;

+   png_debug1(3, "allocating purpose for info (%lu bytes)\n", length);

+   info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length);

+   if (info_ptr->pcal_purpose == NULL)

+     {

+       png_warning(png_ptr, "Insufficient memory for pCAL purpose.");

+       return;

+     }

+   png_memcpy(info_ptr->pcal_purpose, purpose, (png_size_t)length);

+   png_debug(3, "storing X0, X1, type, and nparams in info\n");

+   info_ptr->pcal_X0 = X0;

+   info_ptr->pcal_X1 = X1;

+   info_ptr->pcal_type = (png_byte)type;

+   info_ptr->pcal_nparams = (png_byte)nparams;

+   length = png_strlen(units) + 1;

+   png_debug1(3, "allocating units for info (%lu bytes)\n", length);

+   info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length);

+   if (info_ptr->pcal_units == NULL)

+     {

+       png_warning(png_ptr, "Insufficient memory for pCAL units.");

+       return;

+     }

+   png_memcpy(info_ptr->pcal_units, units, (png_size_t)length);

+   info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr,

+      (png_uint_32)((nparams + 1) * png_sizeof(png_charp)));

+   if (info_ptr->pcal_params == NULL)

+     {

+       png_warning(png_ptr, "Insufficient memory for pCAL params.");

+       return;

+     }

+   info_ptr->pcal_params[nparams] = NULL;

+   for (i = 0; i < nparams; i++)

+   {

+      length = png_strlen(params[i]) + 1;

+      png_debug2(3, "allocating parameter %d for info (%lu bytes)\n", i, length);

+      info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length);

+      if (info_ptr->pcal_params[i] == NULL)

+        {

+          png_warning(png_ptr, "Insufficient memory for pCAL parameter.");

+          return;

+        }

+      png_memcpy(info_ptr->pcal_params[i], params[i], (png_size_t)length);

+   }

+   info_ptr->valid |= PNG_INFO_pCAL;

+#ifdef PNG_FREE_ME_SUPPORTED

+   info_ptr->free_me |= PNG_FREE_PCAL;

+#endif

+}

+#endif

+#if defined(PNG_READ_sCAL_SUPPORTED) || defined(PNG_WRITE_sCAL_SUPPORTED)

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+void PNGAPI

+png_set_sCAL(png_structp png_ptr, png_infop info_ptr,

+             int unit, double width, double height)

+{

+   png_debug1(1, "in %s storage function\n", "sCAL");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+   info_ptr->scal_unit = (png_byte)unit;

+   info_ptr->scal_pixel_width = width;

+   info_ptr->scal_pixel_height = height;

+   info_ptr->valid |= PNG_INFO_sCAL;

+}

+#else

+#ifdef PNG_FIXED_POINT_SUPPORTED

+void PNGAPI

+png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,

+             int unit, png_charp swidth, png_charp sheight)

+{

+   png_uint_32 length;

+   png_debug1(1, "in %s storage function\n", "sCAL");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+   info_ptr->scal_unit = (png_byte)unit;

+   length = png_strlen(swidth) + 1;

+   png_debug1(3, "allocating unit for info (%d bytes)\n", length);

+   info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, length);

+   if (info_ptr->scal_s_width == NULL)

+   {

+      png_warning(png_ptr, "Memory allocation failed while processing sCAL.");

+   }

+   png_memcpy(info_ptr->scal_s_width, swidth, (png_size_t)length);

+   length = png_strlen(sheight) + 1;

+   png_debug1(3, "allocating unit for info (%d bytes)\n", length);

+   info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, length);

+   if (info_ptr->scal_s_height == NULL)

+   {

+      png_free (png_ptr, info_ptr->scal_s_width);

+      png_warning(png_ptr, "Memory allocation failed while processing sCAL.");

+   }

+   png_memcpy(info_ptr->scal_s_height, sheight, (png_size_t)length);

+   info_ptr->valid |= PNG_INFO_sCAL;

+#ifdef PNG_FREE_ME_SUPPORTED

+   info_ptr->free_me |= PNG_FREE_SCAL;

+#endif

+}

+#endif

+#endif

+#endif

+#if defined(PNG_pHYs_SUPPORTED)

+void PNGAPI

+png_set_pHYs(png_structp png_ptr, png_infop info_ptr,

+   png_uint_32 res_x, png_uint_32 res_y, int unit_type)

+{

+   png_debug1(1, "in %s storage function\n", "pHYs");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+   info_ptr->x_pixels_per_unit = res_x;

+   info_ptr->y_pixels_per_unit = res_y;

+   info_ptr->phys_unit_type = (png_byte)unit_type;

+   info_ptr->valid |= PNG_INFO_pHYs;

+}

+#endif

+void PNGAPI

+png_set_PLTE(png_structp png_ptr, png_infop info_ptr,

+   png_colorp palette, int num_palette)

+{

+   png_debug1(1, "in %s storage function\n", "PLTE");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+   /*

+    * It may not actually be necessary to set png_ptr->palette here;

+    * we do it for backward compatibility with the way the png_handle_tRNS

+    * function used to do the allocation.

+    */

+#ifdef PNG_FREE_ME_SUPPORTED

+   png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0);

+#endif

+   /* Changed in libpng-1.2.1 to allocate 256 instead of num_palette entries,

+      in case of an invalid PNG file that has too-large sample values. */

+   png_ptr->palette = (png_colorp)png_malloc(png_ptr,

+      256 * png_sizeof(png_color));

+   png_memset(png_ptr->palette, 0, 256 * png_sizeof(png_color));

+   png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof (png_color));

+   info_ptr->palette = png_ptr->palette;

+   info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;

+#ifdef PNG_FREE_ME_SUPPORTED

+   info_ptr->free_me |= PNG_FREE_PLTE;

+#else

+   png_ptr->flags |= PNG_FLAG_FREE_PLTE;

+#endif

+   info_ptr->valid |= PNG_INFO_PLTE;

+}

+#if defined(PNG_sBIT_SUPPORTED)

+void PNGAPI

+png_set_sBIT(png_structp png_ptr, png_infop info_ptr,

+   png_color_8p sig_bit)

+{

+   png_debug1(1, "in %s storage function\n", "sBIT");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+   png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof (png_color_8));

+   info_ptr->valid |= PNG_INFO_sBIT;

+}

+#endif

+#if defined(PNG_sRGB_SUPPORTED)

+void PNGAPI

+png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent)

+{

+   png_debug1(1, "in %s storage function\n", "sRGB");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+   info_ptr->srgb_intent = (png_byte)intent;

+   info_ptr->valid |= PNG_INFO_sRGB;

+}

+void PNGAPI

+png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,

+   int intent)

+{

+#if defined(PNG_gAMA_SUPPORTED)

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+   float file_gamma;

+#endif

+#ifdef PNG_FIXED_POINT_SUPPORTED

+   png_fixed_point int_file_gamma;

+#endif

+#endif

+#if defined(PNG_cHRM_SUPPORTED)

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+   float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;

+#endif

+#ifdef PNG_FIXED_POINT_SUPPORTED

+   png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,

+      int_green_y, int_blue_x, int_blue_y;

+#endif

+#endif

+   png_debug1(1, "in %s storage function\n", "sRGB_gAMA_and_cHRM");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+   png_set_sRGB(png_ptr, info_ptr, intent);

+#if defined(PNG_gAMA_SUPPORTED)

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+   file_gamma = (float).45455;

+   png_set_gAMA(png_ptr, info_ptr, file_gamma);

+#endif

+#ifdef PNG_FIXED_POINT_SUPPORTED

+   int_file_gamma = 45455L;

+   png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma);

+#endif

+#endif

+#if defined(PNG_cHRM_SUPPORTED)

+#ifdef PNG_FIXED_POINT_SUPPORTED

+   int_white_x = 31270L;

+   int_white_y = 32900L;

+   int_red_x   = 64000L;

+   int_red_y   = 33000L;

+   int_green_x = 30000L;

+   int_green_y = 60000L;

+   int_blue_x  = 15000L;

+   int_blue_y  =  6000L;

+   png_set_cHRM_fixed(png_ptr, info_ptr,

+      int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, int_green_y,

+      int_blue_x, int_blue_y);

+#endif

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+   white_x = (float).3127;

+   white_y = (float).3290;

+   red_x   = (float).64;

+   red_y   = (float).33;

+   green_x = (float).30;

+   green_y = (float).60;

+   blue_x  = (float).15;

+   blue_y  = (float).06;

+   png_set_cHRM(png_ptr, info_ptr,

+      white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);

+#endif

+#endif

+}

+#endif

+#if defined(PNG_iCCP_SUPPORTED)

+void PNGAPI

+png_set_iCCP(png_structp png_ptr, png_infop info_ptr,

+             png_charp name, int compression_type,

+             png_charp profile, png_uint_32 proflen)

+{

+   png_charp new_iccp_name;

+   png_charp new_iccp_profile;

+   png_debug1(1, "in %s storage function\n", "iCCP");

+   if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)

+      return;

+   new_iccp_name = (png_charp)png_malloc_warn(png_ptr, png_strlen(name)+1);

+   if (new_iccp_name == NULL)

+   {

+      png_warning(png_ptr, "Insufficient memory to process iCCP chunk.");

+      return;

+   }

+   png_strcpy(new_iccp_name, name);

+   new_iccp_profile = (png_charp)png_malloc_warn(png_ptr, proflen);

+   if (new_iccp_profile == NULL)

+   {

+      png_free (png_ptr, new_iccp_name);

+      png_warning(png_ptr, "Insufficient memory to process iCCP profile.");

+      return;

+   }

+   png_memcpy(new_iccp_profile, profile, (png_size_t)proflen);

+   png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0);

+   info_ptr->iccp_proflen = proflen;

+   info_ptr->iccp_name = new_iccp_name;

+   info_ptr->iccp_profile = new_iccp_profile;

+   /* Compression is always zero but is here so the API and info structure

+    * does not have to change if we introduce multiple compression types */

+   info_ptr->iccp_compression = (png_byte)compression_type;

+#ifdef PNG_FREE_ME_SUPPORTED

+   info_ptr->free_me |= PNG_FREE_ICCP;

+#endif

+   info_ptr->valid |= PNG_INFO_iCCP;

+}

+#endif

+#if defined(PNG_TEXT_SUPPORTED)

+void PNGAPI

+png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,

+   int num_text)

+{

+   int ret;

+   ret=png_set_text_2(png_ptr, info_ptr, text_ptr, num_text);

+   if (ret)

+     png_error(png_ptr, "Insufficient memory to store text");

+}

+int /* PRIVATE */

+png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,

+   int num_text)

+{

+   int i;

+   png_debug1(1, "in %s storage function\n", (png_ptr->chunk_name[0] == '\0' ?

+      "text" : (png_const_charp)png_ptr->chunk_name));

+   if (png_ptr == NULL || info_ptr == NULL || num_text == 0)

+      return(0);

+   /* Make sure we have enough space in the "text" array in info_struct

+    * to hold all of the incoming text_ptr objects.

+    */

+   if (info_ptr->num_text + num_text > info_ptr->max_text)

+   {

+      if (info_ptr->text != NULL)

+      {

+         png_textp old_text;

+         int old_max;

+         old_max = info_ptr->max_text;

+         info_ptr->max_text = info_ptr->num_text + num_text + 8;

+         old_text = info_ptr->text;

+         info_ptr->text = (png_textp)png_malloc_warn(png_ptr,

+            (png_uint_32)(info_ptr->max_text * png_sizeof (png_text)));

+         if (info_ptr->text == NULL)

+           {

+             png_free(png_ptr, old_text);

+             return(1);

+           }

+         png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max *

+            png_sizeof(png_text)));

+         png_free(png_ptr, old_text);

+      }

+      else

+      {

+         info_ptr->max_text = num_text + 8;

+         info_ptr->num_text = 0;

+         info_ptr->text = (png_textp)png_malloc_warn(png_ptr,

+            (png_uint_32)(info_ptr->max_text * png_sizeof (png_text)));

+         if (info_ptr->text == NULL)

+           return(1);

+#ifdef PNG_FREE_ME_SUPPORTED

+         info_ptr->free_me |= PNG_FREE_TEXT;

+#endif

+      }

+      png_debug1(3, "allocated %d entries for info_ptr->text\n",

+         info_ptr->max_text);

+   }

+   for (i = 0; i < num_text; i++)

+   {

+      png_size_t text_length,key_len;

+      png_size_t lang_len,lang_key_len;

+      png_textp textp = &(info_ptr->text[info_ptr->num_text]);

+      if (text_ptr[i].key == NULL)

+          continue;

+      key_len = png_strlen(text_ptr[i].key);

+      if(text_ptr[i].compression <= 0)

+      {

+        lang_len = 0;

+        lang_key_len = 0;

+      }

+      else

+#ifdef PNG_iTXt_SUPPORTED

+      {

+        /* set iTXt data */

+        if (text_ptr[i].lang != NULL)

+          lang_len = png_strlen(text_ptr[i].lang);

+        else

+          lang_len = 0;

+        if (text_ptr[i].lang_key != NULL)

+          lang_key_len = png_strlen(text_ptr[i].lang_key);

+        else

+          lang_key_len = 0;

+      }

+#else

+      {

+        png_warning(png_ptr, "iTXt chunk not supported.");

+        continue;

+      }

+#endif

+      if (text_ptr[i].text == NULL || text_ptr[i].text[0] == '\0')

+      {

+         text_length = 0;

+#ifdef PNG_iTXt_SUPPORTED

+         if(text_ptr[i].compression > 0)

+            textp->compression = PNG_ITXT_COMPRESSION_NONE;

+         else

+#endif

+            textp->compression = PNG_TEXT_COMPRESSION_NONE;

+      }

+      else

+      {

+         text_length = png_strlen(text_ptr[i].text);

+         textp->compression = text_ptr[i].compression;

+      }

+      textp->key = (png_charp)png_malloc_warn(png_ptr,

+         (png_uint_32)(key_len + text_length + lang_len + lang_key_len + 4));

+      if (textp->key == NULL)

+        return(1);

+      png_debug2(2, "Allocated %lu bytes at %x in png_set_text\n",

+         (png_uint_32)(key_len + lang_len + lang_key_len + text_length + 4),

+         (int)textp->key);

+      png_memcpy(textp->key, text_ptr[i].key,

+         (png_size_t)(key_len));

+      *(textp->key+key_len) = '\0';

+#ifdef PNG_iTXt_SUPPORTED

+      if (text_ptr[i].compression > 0)

+      {

+         textp->lang=textp->key + key_len + 1;

+         png_memcpy(textp->lang, text_ptr[i].lang, lang_len);

+         *(textp->lang+lang_len) = '\0';

+         textp->lang_key=textp->lang + lang_len + 1;

+         png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len);

+         *(textp->lang_key+lang_key_len) = '\0';

+         textp->text=textp->lang_key + lang_key_len + 1;

+      }

+      else

+#endif

+      {

+#ifdef PNG_iTXt_SUPPORTED

+         textp->lang=NULL;

+         textp->lang_key=NULL;

+#endif

+         textp->text=textp->key + key_len + 1;

+      }

+      if(text_length)

+         png_memcpy(textp->text, text_ptr[i].text,

+            (png_size_t)(text_length));

+      *(textp->text+text_length) = '\0';

+#ifdef PNG_iTXt_SUPPORTED

+      if(textp->compression > 0)

+      {

+         textp->text_length = 0;

+         textp->itxt_length = text_length;

+      }

+      else

+#endif

+      {

+         textp->text_length = text_length;

+#ifdef PNG_iTXt_SUPPORTED

+         textp->itxt_length = 0;

+#endif

+      }

+      info_ptr->text[info_ptr->num_text]= *textp;

+      info_ptr->num_text++;

+      png_debug1(3, "transferred text chunk %d\n", info_ptr->num_text);

+   }

+   return(0);

+}

+#endif

+#if defined(PNG_tIME_SUPPORTED)

+void PNGAPI

+png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time)

+{

+   png_debug1(1, "in %s storage function\n", "tIME");

+   if (png_ptr == NULL || info_ptr == NULL ||

+       (png_ptr->mode & PNG_WROTE_tIME))

+      return;

+   png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof (png_time));

+   info_ptr->valid |= PNG_INFO_tIME;

+}

+#endif

+#if defined(PNG_tRNS_SUPPORTED)

+void PNGAPI

+png_set_tRNS(png_structp png_ptr, png_infop info_ptr,

+   png_bytep trans, int num_trans, png_color_16p trans_values)

+{

+   png_debug1(1, "in %s storage function\n", "tRNS");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+   if (trans != NULL)

+   {

+       /*

+        * It may not actually be necessary to set png_ptr->trans here;

+        * we do it for backward compatibility with the way the png_handle_tRNS

+        * function used to do the allocation.

+        */

+#ifdef PNG_FREE_ME_SUPPORTED

+       png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);

+#endif

+       /* Changed from num_trans to 256 in version 1.2.1 */

+       png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr,

+           (png_uint_32)256);

+       png_memcpy(info_ptr->trans, trans, (png_size_t)num_trans);

+#ifdef PNG_FREE_ME_SUPPORTED

+       info_ptr->free_me |= PNG_FREE_TRNS;

+#else

+       png_ptr->flags |= PNG_FLAG_FREE_TRNS;

+#endif

+   }

+   if (trans_values != NULL)

+   {

+      png_memcpy(&(info_ptr->trans_values), trans_values,

+         png_sizeof(png_color_16));

+      if (num_trans == 0)

+        num_trans = 1;

+   }

+   info_ptr->num_trans = (png_uint_16)num_trans;

+   info_ptr->valid |= PNG_INFO_tRNS;

+}

+#endif

+#if defined(PNG_sPLT_SUPPORTED)

+void PNGAPI

+png_set_sPLT(png_structp png_ptr,

+             png_infop info_ptr, png_sPLT_tp entries, int nentries)

+{

+    png_sPLT_tp np;

+    int i;

+    np = (png_sPLT_tp)png_malloc_warn(png_ptr,

+        (info_ptr->splt_palettes_num + nentries) * png_sizeof(png_sPLT_t));

+    if (np == NULL)

+    {

+      png_warning(png_ptr, "No memory for sPLT palettes.");

+      return;

+    }

+    png_memcpy(np, info_ptr->splt_palettes,

+           info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t));

+    png_free(png_ptr, info_ptr->splt_palettes);

+    info_ptr->splt_palettes=NULL;

+    for (i = 0; i < nentries; i++)

+    {

+        png_sPLT_tp to = np + info_ptr->splt_palettes_num + i;

+        png_sPLT_tp from = entries + i;

+        to->name = (png_charp)png_malloc(png_ptr,

+            png_strlen(from->name) + 1);

+        /* TODO: use png_malloc_warn */

+        png_strcpy(to->name, from->name);

+        to->entries = (png_sPLT_entryp)png_malloc(png_ptr,

+            from->nentries * png_sizeof(png_sPLT_t));

+        /* TODO: use png_malloc_warn */

+        png_memcpy(to->entries, from->entries,

+            from->nentries * png_sizeof(png_sPLT_t));

+        to->nentries = from->nentries;

+        to->depth = from->depth;

+    }

+    info_ptr->splt_palettes = np;

+    info_ptr->splt_palettes_num += nentries;

+    info_ptr->valid |= PNG_INFO_sPLT;

+#ifdef PNG_FREE_ME_SUPPORTED

+    info_ptr->free_me |= PNG_FREE_SPLT;

+#endif

+}

+#endif /* PNG_sPLT_SUPPORTED */

+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)

+void PNGAPI

+png_set_unknown_chunks(png_structp png_ptr,

+   png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)

+{

+    png_unknown_chunkp np;

+    int i;

+    if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0)

+        return;

+    np = (png_unknown_chunkp)png_malloc_warn(png_ptr,

+        (info_ptr->unknown_chunks_num + num_unknowns) *

+        png_sizeof(png_unknown_chunk));

+    if (np == NULL)

+    {

+       png_warning(png_ptr, "Out of memory while processing unknown chunk.");

+       return;

+    }

+    png_memcpy(np, info_ptr->unknown_chunks,

+           info_ptr->unknown_chunks_num * png_sizeof(png_unknown_chunk));

+    png_free(png_ptr, info_ptr->unknown_chunks);

+    info_ptr->unknown_chunks=NULL;

+    for (i = 0; i < num_unknowns; i++)

+    {

+        png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i;

+        png_unknown_chunkp from = unknowns + i;

+        png_strncpy((png_charp)to->name, (png_charp)from->name, 5);

+        to->data = (png_bytep)png_malloc_warn(png_ptr, from->size);

+        if (to->data == NULL)

+        {

+           png_warning(png_ptr, "Out of memory processing unknown chunk.");

+        }

+        else

+        {

+           png_memcpy(to->data, from->data, from->size);

+           to->size = from->size;

+           /* note our location in the read or write sequence */

+           to->location = (png_byte)(png_ptr->mode & 0xff);

+        }

+    }

+    info_ptr->unknown_chunks = np;

+    info_ptr->unknown_chunks_num += num_unknowns;

+#ifdef PNG_FREE_ME_SUPPORTED

+    info_ptr->free_me |= PNG_FREE_UNKN;

+#endif

+}

+void PNGAPI

+png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr,

+   int chunk, int location)

+{

+   if(png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk <

+         (int)info_ptr->unknown_chunks_num)

+      info_ptr->unknown_chunks[chunk].location = (png_byte)location;

+}

+#endif

+#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \

+    defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)

+void PNGAPI

+png_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted)

+{

+   /* This function is deprecated in favor of png_permit_mng_features()

+      and will be removed from libpng-2.0.0 */

+   png_debug(1, "in png_permit_empty_plte, DEPRECATED.\n");

+   if (png_ptr == NULL)

+      return;

+   png_ptr->mng_features_permitted = (png_byte)

+     ((png_ptr->mng_features_permitted & (~(PNG_FLAG_MNG_EMPTY_PLTE))) |

+     ((empty_plte_permitted & PNG_FLAG_MNG_EMPTY_PLTE)));

+}

+#endif

+#if defined(PNG_MNG_FEATURES_SUPPORTED)

+png_uint_32 PNGAPI

+png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features)

+{

+   png_debug(1, "in png_permit_mng_features\n");

+   if (png_ptr == NULL)

+      return (png_uint_32)0;

+   png_ptr->mng_features_permitted =

+     (png_byte)(mng_features & PNG_ALL_MNG_FEATURES);

+   return (png_uint_32)png_ptr->mng_features_permitted;

+}

+#endif

+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)

+void PNGAPI

+png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep

+   chunk_list, int num_chunks)

+{

+    png_bytep new_list, p;

+    int i, old_num_chunks;

+    if (num_chunks == 0)

+    {

+      if(keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE)

+        png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS;

+      else

+        png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;

+      if(keep == PNG_HANDLE_CHUNK_ALWAYS)

+        png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS;

+      else

+        png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;

+      return;

+    }

+    if (chunk_list == NULL)

+      return;

+    old_num_chunks=png_ptr->num_chunk_list;

+    new_list=(png_bytep)png_malloc(png_ptr,

+       (png_uint_32)(5*(num_chunks+old_num_chunks)));

+    if(png_ptr->chunk_list != NULL)

+    {

+       png_memcpy(new_list, png_ptr->chunk_list,

+          (png_size_t)(5*old_num_chunks));

+       png_free(png_ptr, png_ptr->chunk_list);

+       png_ptr->chunk_list=NULL;

+    }

+    png_memcpy(new_list+5*old_num_chunks, chunk_list,

+       (png_size_t)(5*num_chunks));

+    for (p=new_list+5*old_num_chunks+4, i=0; i<num_chunks; i++, p+=5)

+       *p=(png_byte)keep;

+    png_ptr->num_chunk_list=old_num_chunks+num_chunks;

+    png_ptr->chunk_list=new_list;

+#ifdef PNG_FREE_ME_SUPPORTED

+    png_ptr->free_me |= PNG_FREE_LIST;

+#endif

+}

+#endif

+#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)

+void PNGAPI

+png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr,

+   png_user_chunk_ptr read_user_chunk_fn)

+{

+   png_debug(1, "in png_set_read_user_chunk_fn\n");

+   png_ptr->read_user_chunk_fn = read_user_chunk_fn;

+   png_ptr->user_chunk_ptr = user_chunk_ptr;

+}

+#endif

+#if defined(PNG_INFO_IMAGE_SUPPORTED)

+void PNGAPI

+png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers)

+{

+   png_debug1(1, "in %s storage function\n", "rows");

+   if (png_ptr == NULL || info_ptr == NULL)

+      return;

+   if(info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers))

+      png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);

+   info_ptr->row_pointers = row_pointers;

+   if(row_pointers)

+      info_ptr->valid |= PNG_INFO_IDAT;

+}

+#endif

+#ifdef PNG_WRITE_SUPPORTED

+void PNGAPI

+png_set_compression_buffer_size(png_structp png_ptr, png_uint_32 size)

+{

+    if(png_ptr->zbuf)

+       png_free(png_ptr, png_ptr->zbuf);

+    png_ptr->zbuf_size = (png_size_t)size;

+    png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size);

+    png_ptr->zstream.next_out = png_ptr->zbuf;

+    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+}

+#endif

+void PNGAPI

+png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask)

+{

+   if (png_ptr && info_ptr)

+      info_ptr->valid &= ~(mask);

+}

+#ifndef PNG_1_0_X

+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED

+/* this function was added to libpng 1.2.0 and should always exist by default */

+void PNGAPI

+png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags)

+{

+    png_uint_32 settable_asm_flags;

+    png_uint_32 settable_mmx_flags;

+    settable_mmx_flags =

+#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW

+                         PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  |

+#endif

+#ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE

+                         PNG_ASM_FLAG_MMX_READ_INTERLACE    |

+#endif

+#ifdef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW

+                         PNG_ASM_FLAG_MMX_READ_FILTER_SUB   |

+                         PNG_ASM_FLAG_MMX_READ_FILTER_UP    |

+                         PNG_ASM_FLAG_MMX_READ_FILTER_AVG   |

+                         PNG_ASM_FLAG_MMX_READ_FILTER_PAETH |

+#endif

+                         0;

+    /* could be some non-MMX ones in the future, but not currently: */

+    settable_asm_flags = settable_mmx_flags;

+    if (!(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_COMPILED) ||

+        !(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU))

+    {

+        /* clear all MMX flags if MMX isn't supported */

+        settable_asm_flags &= ~settable_mmx_flags;

+        png_ptr->asm_flags &= ~settable_mmx_flags;

+    }

+    /* we're replacing the settable bits with those passed in by the user,

+     * so first zero them out of the master copy, then logical-OR in the

+     * allowed subset that was requested */

+    png_ptr->asm_flags &= ~settable_asm_flags;               /* zero them */

+    png_ptr->asm_flags |= (asm_flags & settable_asm_flags);  /* set them */

+}

+#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */

+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED

+/* this function was added to libpng 1.2.0 */

+void PNGAPI

+png_set_mmx_thresholds (png_structp png_ptr,

+                        png_byte mmx_bitdepth_threshold,

+                        png_uint_32 mmx_rowbytes_threshold)

+{

+    png_ptr->mmx_bitdepth_threshold = mmx_bitdepth_threshold;

+    png_ptr->mmx_rowbytes_threshold = mmx_rowbytes_threshold;

+}

+#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */

+#ifdef PNG_SET_USER_LIMITS_SUPPORTED

+/* this function was added to libpng 1.2.6 */

+void PNGAPI

+png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max,

+    png_uint_32 user_height_max)

+{

+    /* Images with dimensions larger than these limits will be

+     * rejected by png_set_IHDR().  To accept any PNG datastream

+     * regardless of dimensions, set both limits to 0x7ffffffL.

+     */

+    png_ptr->user_width_max = user_width_max;

+    png_ptr->user_height_max = user_height_max;

+}

+#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */

+#endif /* ?PNG_1_0_X */

--- /dev/null

+++ b/src/gfx/libpng/pngtest.c

@@ -1,0 +1,1554 @@

+/* pngtest.c - a simple test program to test libpng

+ *

+ * libpng 1.2.8 - December 3, 2004

+ * For conditions of distribution and use, see copyright notice in png.h

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

+ *

+ * This program reads in a PNG image, writes it out again, and then

+ * compares the two files.  If the files are identical, this shows that

+ * the basic chunk handling, filtering, and (de)compression code is working

+ * properly.  It does not currently test all of the transforms, although

+ * it probably should.

+ *

+ * The program will report "FAIL" in certain legitimate cases:

+ * 1) when the compression level or filter selection method is changed.

+ * 2) when the maximum IDAT size (PNG_ZBUF_SIZE in pngconf.h) is not 8192.

+ * 3) unknown unsafe-to-copy ancillary chunks or unknown critical chunks

+ *    exist in the input file.

+ * 4) others not listed here...

+ * In these cases, it is best to check with another tool such as "pngcheck"

+ * to see what the differences between the two files are.

+ *

+ * If a filename is given on the command-line, then this file is used

+ * for the input, rather than the default "pngtest.png".  This allows

+ * testing a wide variety of files easily.  You can also test a number

+ * of files at once by typing "pngtest -m file1.png file2.png ..."

+ */

+#include "png.h"

+#if defined(_WIN32_WCE)

+#  if _WIN32_WCE < 211

+     __error__ (f|w)printf functions are not supported on old WindowsCE.;

+#  endif

+#  include <windows.h>

+#  include <stdlib.h>

+#  define READFILE(file, data, length, check) \

+     if (ReadFile(file, data, length, &check,NULL)) check = 0

+#  define WRITEFILE(file, data, length, check)) \

+     if (WriteFile(file, data, length, &check, NULL)) check = 0

+#  define FCLOSE(file) CloseHandle(file)

+#else

+#  include <stdio.h>

+#  include <stdlib.h>

+#  include <assert.h>

+#  define READFILE(file, data, length, check) \

+     check=(png_size_t)fread(data,(png_size_t)1,length,file)

+#  define WRITEFILE(file, data, length, check) \

+     check=(png_size_t)fwrite(data,(png_size_t)1, length, file)

+#  define FCLOSE(file) fclose(file)

+#endif

+#if defined(PNG_NO_STDIO)

+#  if defined(_WIN32_WCE)

+     typedef HANDLE                png_FILE_p;

+#  else

+     typedef FILE                * png_FILE_p;

+#  endif

+#endif

+/* Makes pngtest verbose so we can find problems (needs to be before png.h) */

+#ifndef PNG_DEBUG

+#  define PNG_DEBUG 0

+#endif

+#if !PNG_DEBUG

+#  define SINGLE_ROWBUF_ALLOC  /* makes buffer overruns easier to nail */

+#endif

+/* Turn on CPU timing

+#define PNGTEST_TIMING

+*/

+#ifdef PNG_NO_FLOATING_POINT_SUPPORTED

+#undef PNGTEST_TIMING

+#endif

+#ifdef PNGTEST_TIMING

+static float t_start, t_stop, t_decode, t_encode, t_misc;

+#include <time.h>

+#endif

+/* Define png_jmpbuf() in case we are using a pre-1.0.6 version of libpng */

+#ifndef png_jmpbuf

+#  define png_jmpbuf(png_ptr) png_ptr->jmpbuf

+#endif

+#ifdef PNGTEST_TIMING

+static float t_start, t_stop, t_decode, t_encode, t_misc;

+#if !defined(PNG_tIME_SUPPORTED)

+#include <time.h>

+#endif

+#endif

+#if defined(PNG_TIME_RFC1123_SUPPORTED)

+static int tIME_chunk_present=0;

+static char tIME_string[30] = "no tIME chunk present in file";

+#endif

+static int verbose = 0;

+int test_one_file PNGARG((PNG_CONST char *inname, PNG_CONST char *outname));

+#ifdef __TURBOC__

+#include <mem.h>

+#endif

+/* defined so I can write to a file on gui/windowing platforms */

+/*  #define STDERR stderr  */

+#define STDERR stdout   /* for DOS */

+/* example of using row callbacks to make a simple progress meter */

+static int status_pass=1;

+static int status_dots_requested=0;

+static int status_dots=1;

+void

+#ifdef PNG_1_0_X

+PNGAPI

+#endif

+read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass);

+void

+#ifdef PNG_1_0_X

+PNGAPI

+#endif

+read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)

+{

+    if(png_ptr == NULL || row_number > PNG_UINT_31_MAX) return;

+    if(status_pass != pass)

+    {

+       fprintf(stdout,"\n Pass %d: ",pass);

+       status_pass = pass;

+       status_dots = 31;

+    }

+    status_dots--;

+    if(status_dots == 0)

+    {

+       fprintf(stdout, "\n         ");

+       status_dots=30;

+    }

+    fprintf(stdout, "r");

+}

+void

+#ifdef PNG_1_0_X

+PNGAPI

+#endif

+write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass);

+void

+#ifdef PNG_1_0_X

+PNGAPI

+#endif

+write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)

+{

+    if(png_ptr == NULL || row_number > PNG_UINT_31_MAX || pass > 7) return;

+    fprintf(stdout, "w");

+}

+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)

+/* Example of using user transform callback (we don't transform anything,

+   but merely examine the row filters.  We set this to 256 rather than

+   5 in case illegal filter values are present.) */

+static png_uint_32 filters_used[256];

+void

+#ifdef PNG_1_0_X

+PNGAPI

+#endif

+count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data);

+void

+#ifdef PNG_1_0_X

+PNGAPI

+#endif

+count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data)

+{

+    if(png_ptr != NULL && row_info != NULL)

+      ++filters_used[*(data-1)];

+}

+#endif

+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

+/* example of using user transform callback (we don't transform anything,

+   but merely count the zero samples) */

+static png_uint_32 zero_samples;

+void

+#ifdef PNG_1_0_X

+PNGAPI

+#endif

+count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data);

+void

+#ifdef PNG_1_0_X

+PNGAPI

+#endif

+count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data)

+{

+   png_bytep dp = data;

+   if(png_ptr == NULL)return;

+   /* contents of row_info:

+    *  png_uint_32 width      width of row

+    *  png_uint_32 rowbytes   number of bytes in row

+    *  png_byte color_type    color type of pixels

+    *  png_byte bit_depth     bit depth of samples

+    *  png_byte channels      number of channels (1-4)

+    *  png_byte pixel_depth   bits per pixel (depth*channels)

+    */

+    /* counts the number of zero samples (or zero pixels if color_type is 3 */

+    if(row_info->color_type == 0 || row_info->color_type == 3)

+    {

+       int pos=0;

+       png_uint_32 n, nstop;

+       for (n=0, nstop=row_info->width; n<nstop; n++)

+       {

+          if(row_info->bit_depth == 1)

+          {

+             if(((*dp << pos++ ) & 0x80) == 0) zero_samples++;

+             if(pos == 8)

+             {

+                pos = 0;

+                dp++;

+             }

+          }

+          if(row_info->bit_depth == 2)

+          {

+             if(((*dp << (pos+=2)) & 0xc0) == 0) zero_samples++;

+             if(pos == 8)

+             {

+                pos = 0;

+                dp++;

+             }

+          }

+          if(row_info->bit_depth == 4)

+          {

+             if(((*dp << (pos+=4)) & 0xf0) == 0) zero_samples++;

+             if(pos == 8)

+             {

+                pos = 0;

+                dp++;

+             }

+          }

+          if(row_info->bit_depth == 8)

+             if(*dp++ == 0) zero_samples++;

+          if(row_info->bit_depth == 16)

+          {

+             if((*dp | *(dp+1)) == 0) zero_samples++;

+             dp+=2;

+          }

+       }

+    }

+    else /* other color types */

+    {

+       png_uint_32 n, nstop;

+       int channel;

+       int color_channels = row_info->channels;

+       if(row_info->color_type > 3)color_channels--;

+       for (n=0, nstop=row_info->width; n<nstop; n++)

+       {

+          for (channel = 0; channel < color_channels; channel++)

+          {

+             if(row_info->bit_depth == 8)

+                if(*dp++ == 0) zero_samples++;

+             if(row_info->bit_depth == 16)

+             {

+                if((*dp | *(dp+1)) == 0) zero_samples++;

+                dp+=2;

+             }

+          }

+          if(row_info->color_type > 3)

+          {

+             dp++;

+             if(row_info->bit_depth == 16)dp++;

+          }

+       }

+    }

+}

+#endif /* PNG_WRITE_USER_TRANSFORM_SUPPORTED */

+static int wrote_question = 0;

+#if defined(PNG_NO_STDIO)

+/* START of code to validate stdio-free compilation */

+/* These copies of the default read/write functions come from pngrio.c and */

+/* pngwio.c.  They allow "don't include stdio" testing of the library. */

+/* This is the function that does the actual reading of data.  If you are

+   not reading from a standard C stream, you should create a replacement

+   read_data function and use it at run time with png_set_read_fn(), rather

+   than changing the library. */

+#ifndef USE_FAR_KEYWORD

+static void

+pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length)

+{

+   png_size_t check;

+   /* fread() returns 0 on error, so it is OK to store this in a png_size_t

+    * instead of an int, which is what fread() actually returns.

+    */

+   READFILE((png_FILE_p)png_ptr->io_ptr, data, length, check);

+   if (check != length)

+   {

+      png_error(png_ptr, "Read Error!");

+   }

+}

+#else

+/* this is the model-independent version. Since the standard I/O library

+   can't handle far buffers in the medium and small models, we have to copy

+   the data.

+*/

+#define NEAR_BUF_SIZE 1024

+#define MIN(a,b) (a <= b ? a : b)

+static void

+pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length)

+{

+   int check;

+   png_byte *n_data;

+   png_FILE_p io_ptr;

+   /* Check if data really is near. If so, use usual code. */

+   n_data = (png_byte *)CVT_PTR_NOCHECK(data);

+   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);

+   if ((png_bytep)n_data == data)

+   {

+      READFILE(io_ptr, n_data, length, check);

+   }

+   else

+   {

+      png_byte buf[NEAR_BUF_SIZE];

+      png_size_t read, remaining, err;

+      check = 0;

+      remaining = length;

+      do

+      {

+         read = MIN(NEAR_BUF_SIZE, remaining);

+         READFILE(io_ptr, buf, 1, err);

+         png_memcpy(data, buf, read); /* copy far buffer to near buffer */

+         if(err != read)

+            break;

+         else

+            check += err;

+         data += read;

+         remaining -= read;

+      }

+      while (remaining != 0);

+   }

+   if (check != length)

+   {

+      png_error(png_ptr, "read Error");

+   }

+}

+#endif /* USE_FAR_KEYWORD */

+#if defined(PNG_WRITE_FLUSH_SUPPORTED)

+static void

+pngtest_flush(png_structp png_ptr)

+{

+#if !defined(_WIN32_WCE)

+   png_FILE_p io_ptr;

+   io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr));

+   if (io_ptr != NULL)

+      fflush(io_ptr);

+#endif

+}

+#endif

+/* This is the function that does the actual writing of data.  If you are

+   not writing to a standard C stream, you should create a replacement

+   write_data function and use it at run time with png_set_write_fn(), rather

+   than changing the library. */

+#ifndef USE_FAR_KEYWORD

+static void

+pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)

+{

+   png_uint_32 check;

+   WRITEFILE((png_FILE_p)png_ptr->io_ptr,  data, length, check);

+   if (check != length)

+   {

+      png_error(png_ptr, "Write Error");

+   }

+}

+#else

+/* this is the model-independent version. Since the standard I/O library

+   can't handle far buffers in the medium and small models, we have to copy

+   the data.

+*/

+#define NEAR_BUF_SIZE 1024

+#define MIN(a,b) (a <= b ? a : b)

+static void

+pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length)

+{

+   png_uint_32 check;

+   png_byte *near_data;  /* Needs to be "png_byte *" instead of "png_bytep" */

+   png_FILE_p io_ptr;

+   /* Check if data really is near. If so, use usual code. */

+   near_data = (png_byte *)CVT_PTR_NOCHECK(data);

+   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);

+   if ((png_bytep)near_data == data)

+   {

+      WRITEFILE(io_ptr, near_data, length, check);

+   }

+   else

+   {

+      png_byte buf[NEAR_BUF_SIZE];

+      png_size_t written, remaining, err;

+      check = 0;

+      remaining = length;

+      do

+      {

+         written = MIN(NEAR_BUF_SIZE, remaining);

+         png_memcpy(buf, data, written); /* copy far buffer to near buffer */

+         WRITEFILE(io_ptr, buf, written, err);

+         if (err != written)

+            break;

+         else

+            check += err;

+         data += written;

+         remaining -= written;

+      }

+      while (remaining != 0);

+   }

+   if (check != length)

+   {

+      png_error(png_ptr, "Write Error");

+   }

+}

+#endif /* USE_FAR_KEYWORD */

+/* This function is called when there is a warning, but the library thinks

+ * it can continue anyway.  Replacement functions don't have to do anything

+ * here if you don't want to.  In the default configuration, png_ptr is

+ * not used, but it is passed in case it may be useful.

+ */

+static void

+pngtest_warning(png_structp png_ptr, png_const_charp message)

+{

+   PNG_CONST char *name = "UNKNOWN (ERROR!)";

+   if (png_ptr != NULL && png_ptr->error_ptr != NULL)

+      name = png_ptr->error_ptr;

+   fprintf(STDERR, "%s: libpng warning: %s\n", name, message);

+}

+/* This is the default error handling function.  Note that replacements for

+ * this function MUST NOT RETURN, or the program will likely crash.  This

+ * function is used by default, or if the program supplies NULL for the

+ * error function pointer in png_set_error_fn().

+ */

+static void

+pngtest_error(png_structp png_ptr, png_const_charp message)

+{

+   pngtest_warning(png_ptr, message);

+   /* We can return because png_error calls the default handler, which is

+    * actually OK in this case. */

+}

+#endif /* PNG_NO_STDIO */

+/* END of code to validate stdio-free compilation */

+/* START of code to validate memory allocation and deallocation */

+#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

+/* Allocate memory.  For reasonable files, size should never exceed

+   64K.  However, zlib may allocate more then 64K if you don't tell

+   it not to.  See zconf.h and png.h for more information.  zlib does

+   need to allocate exactly 64K, so whatever you call here must

+   have the ability to do that.

+   This piece of code can be compiled to validate max 64K allocations

+   by setting MAXSEG_64K in zlib zconf.h *or* PNG_MAX_MALLOC_64K. */

+typedef struct memory_information

+{

+   png_uint_32               size;

+   png_voidp                 pointer;

+   struct memory_information FAR *next;

+} memory_information;

+typedef memory_information FAR *memory_infop;

+static memory_infop pinformation = NULL;

+static int current_allocation = 0;

+static int maximum_allocation = 0;

+static int total_allocation = 0;

+static int num_allocations = 0;

+png_voidp png_debug_malloc PNGARG((png_structp png_ptr, png_uint_32 size));

+void png_debug_free PNGARG((png_structp png_ptr, png_voidp ptr));

+png_voidp

+png_debug_malloc(png_structp png_ptr, png_uint_32 size)

+{

+   /* png_malloc has already tested for NULL; png_create_struct calls

+      png_debug_malloc directly, with png_ptr == NULL which is OK */

+   if (size == 0)

+      return (NULL);

+   /* This calls the library allocator twice, once to get the requested

+      buffer and once to get a new free list entry. */

+   {

+      /* Disable malloc_fn and free_fn */

+      memory_infop pinfo;

+      png_set_mem_fn(png_ptr, NULL, NULL, NULL);

+      pinfo = (memory_infop)png_malloc(png_ptr,

+         (png_uint_32)png_sizeof (*pinfo));

+      pinfo->size = size;

+      current_allocation += size;

+      total_allocation += size;

+      num_allocations ++;

+      if (current_allocation > maximum_allocation)

+         maximum_allocation = current_allocation;

+      pinfo->pointer = (png_voidp)png_malloc(png_ptr, size);

+      /* Restore malloc_fn and free_fn */

+      png_set_mem_fn(png_ptr, png_voidp_NULL, (png_malloc_ptr)png_debug_malloc,

+         (png_free_ptr)png_debug_free);

+      if (size != 0 && pinfo->pointer == NULL)

+      {

+         current_allocation -= size;

+         total_allocation -= size;

+         png_error(png_ptr,

+           "out of memory in pngtest->png_debug_malloc.");

+      }

+      pinfo->next = pinformation;

+      pinformation = pinfo;

+      /* Make sure the caller isn't assuming zeroed memory. */

+      png_memset(pinfo->pointer, 0xdd, pinfo->size);

+      if(verbose)

+         printf("png_malloc %lu bytes at %x\n",size,pinfo->pointer);

+      assert(pinfo->size != 12345678);

+      return (png_voidp)(pinfo->pointer);

+   }

+}

+/* Free a pointer.  It is removed from the list at the same time. */

+void

+png_debug_free(png_structp png_ptr, png_voidp ptr)

+{

+   if (png_ptr == NULL)

+      fprintf(STDERR, "NULL pointer to png_debug_free.\n");

+   if (ptr == 0)

+   {

+#if 0 /* This happens all the time. */

+      fprintf(STDERR, "WARNING: freeing NULL pointer\n");

+#endif

+      return;

+   }

+   /* Unlink the element from the list. */

+   {

+      memory_infop FAR *ppinfo = &pinformation;

+      for (;;)

+      {

+         memory_infop pinfo = *ppinfo;

+         if (pinfo->pointer == ptr)

+         {

+            *ppinfo = pinfo->next;

+            current_allocation -= pinfo->size;

+            if (current_allocation < 0)

+               fprintf(STDERR, "Duplicate free of memory\n");

+            /* We must free the list element too, but first kill

+               the memory that is to be freed. */

+            png_memset(ptr, 0x55, pinfo->size);

+            png_free_default(png_ptr, pinfo);

+            pinfo=NULL;

+            break;

+         }

+         if (pinfo->next == NULL)

+         {

+            fprintf(STDERR, "Pointer %x not found\n", (unsigned int)ptr);

+            break;

+         }

+         ppinfo = &pinfo->next;

+      }

+   }

+   /* Finally free the data. */

+   if(verbose)

+      printf("Freeing %x\n",ptr);

+   png_free_default(png_ptr, ptr);

+   ptr=NULL;

+}

+#endif /* PNG_USER_MEM_SUPPORTED && PNG_DEBUG */

+/* END of code to test memory allocation/deallocation */

+/* Test one file */

+int

+test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)

+{

+   static png_FILE_p fpin;

+   static png_FILE_p fpout;  /* "static" prevents setjmp corruption */

+   png_structp read_ptr;

+   png_infop read_info_ptr, end_info_ptr;

+#ifdef PNG_WRITE_SUPPORTED

+   png_structp write_ptr;

+   png_infop write_info_ptr;

+   png_infop write_end_info_ptr;

+#else

+   png_structp write_ptr = NULL;

+   png_infop write_info_ptr = NULL;

+   png_infop write_end_info_ptr = NULL;

+#endif

+   png_bytep row_buf;

+   png_uint_32 y;

+   png_uint_32 width, height;

+   int num_pass, pass;

+   int bit_depth, color_type;

+#ifdef PNG_SETJMP_SUPPORTED

+#ifdef USE_FAR_KEYWORD

+   jmp_buf jmpbuf;

+#endif

+#endif

+#if defined(_WIN32_WCE)

+   TCHAR path[MAX_PATH];

+#endif

+   char inbuf[256], outbuf[256];

+   row_buf = NULL;

+#if defined(_WIN32_WCE)

+   MultiByteToWideChar(CP_ACP, 0, inname, -1, path, MAX_PATH);

+   if ((fpin = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)

+#else

+   if ((fpin = fopen(inname, "rb")) == NULL)

+#endif

+   {

+      fprintf(STDERR, "Could not find input file %s\n", inname);

+      return (1);

+   }

+#if defined(_WIN32_WCE)

+   MultiByteToWideChar(CP_ACP, 0, outname, -1, path, MAX_PATH);

+   if ((fpout = CreateFile(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL)) == INVALID_HANDLE_VALUE)

+#else

+   if ((fpout = fopen(outname, "wb")) == NULL)

+#endif

+   {

+      fprintf(STDERR, "Could not open output file %s\n", outname);

+      FCLOSE(fpin);

+      return (1);

+   }

+   png_debug(0, "Allocating read and write structures\n");

+#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

+   read_ptr = png_create_read_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL,

+      png_error_ptr_NULL, png_error_ptr_NULL, png_voidp_NULL,

+      (png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free);

+#else

+   read_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL,

+      png_error_ptr_NULL, png_error_ptr_NULL);

+#endif

+#if defined(PNG_NO_STDIO)

+   png_set_error_fn(read_ptr, (png_voidp)inname, pngtest_error,

+       pngtest_warning);

+#endif

+#ifdef PNG_WRITE_SUPPORTED

+#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

+   write_ptr = png_create_write_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL,

+      png_error_ptr_NULL, png_error_ptr_NULL, png_voidp_NULL,

+      (png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free);

+#else

+   write_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL,

+      png_error_ptr_NULL, png_error_ptr_NULL);

+#endif

+#if defined(PNG_NO_STDIO)

+   png_set_error_fn(write_ptr, (png_voidp)inname, pngtest_error,

+       pngtest_warning);

+#endif

+#endif

+   png_debug(0, "Allocating read_info, write_info and end_info structures\n");

+   read_info_ptr = png_create_info_struct(read_ptr);

+   end_info_ptr = png_create_info_struct(read_ptr);

+#ifdef PNG_WRITE_SUPPORTED

+   write_info_ptr = png_create_info_struct(write_ptr);

+   write_end_info_ptr = png_create_info_struct(write_ptr);

+#endif

+#ifdef PNG_SETJMP_SUPPORTED

+   png_debug(0, "Setting jmpbuf for read struct\n");

+#ifdef USE_FAR_KEYWORD

+   if (setjmp(jmpbuf))

+#else

+   if (setjmp(png_jmpbuf(read_ptr)))

+#endif

+   {

+      fprintf(STDERR, "%s -> %s: libpng read error\n", inname, outname);

+      if (row_buf)

+         png_free(read_ptr, row_buf);

+      png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);

+#ifdef PNG_WRITE_SUPPORTED

+      png_destroy_info_struct(write_ptr, &write_end_info_ptr);

+      png_destroy_write_struct(&write_ptr, &write_info_ptr);

+#endif

+      FCLOSE(fpin);

+      FCLOSE(fpout);

+      return (1);

+   }

+#ifdef USE_FAR_KEYWORD

+   png_memcpy(png_jmpbuf(read_ptr),jmpbuf,png_sizeof(jmp_buf));

+#endif

+#ifdef PNG_WRITE_SUPPORTED

+   png_debug(0, "Setting jmpbuf for write struct\n");

+#ifdef USE_FAR_KEYWORD

+   if (setjmp(jmpbuf))

+#else

+   if (setjmp(png_jmpbuf(write_ptr)))

+#endif

+   {

+      fprintf(STDERR, "%s -> %s: libpng write error\n", inname, outname);

+      png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);

+      png_destroy_info_struct(write_ptr, &write_end_info_ptr);

+#ifdef PNG_WRITE_SUPPORTED

+      png_destroy_write_struct(&write_ptr, &write_info_ptr);

+#endif

+      FCLOSE(fpin);

+      FCLOSE(fpout);

+      return (1);

+   }

+#ifdef USE_FAR_KEYWORD

+   png_memcpy(png_jmpbuf(write_ptr),jmpbuf,png_sizeof(jmp_buf));

+#endif

+#endif

+#endif

+   png_debug(0, "Initializing input and output streams\n");

+#if !defined(PNG_NO_STDIO)

+   png_init_io(read_ptr, fpin);

+#  ifdef PNG_WRITE_SUPPORTED

+   png_init_io(write_ptr, fpout);

+#  endif

+#else

+   png_set_read_fn(read_ptr, (png_voidp)fpin, pngtest_read_data);

+#  ifdef PNG_WRITE_SUPPORTED

+   png_set_write_fn(write_ptr, (png_voidp)fpout,  pngtest_write_data,

+#    if defined(PNG_WRITE_FLUSH_SUPPORTED)

+      pngtest_flush);

+#    else

+      NULL);

+#    endif

+#  endif

+#endif

+   if(status_dots_requested == 1)

+   {

+#ifdef PNG_WRITE_SUPPORTED

+      png_set_write_status_fn(write_ptr, write_row_callback);

+#endif

+      png_set_read_status_fn(read_ptr, read_row_callback);

+   }

+   else

+   {

+#ifdef PNG_WRITE_SUPPORTED

+      png_set_write_status_fn(write_ptr, png_write_status_ptr_NULL);

+#endif

+      png_set_read_status_fn(read_ptr, png_read_status_ptr_NULL);

+   }

+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)

+   {

+     int i;

+     for(i=0; i<256; i++)

+        filters_used[i]=0;

+     png_set_read_user_transform_fn(read_ptr, count_filters);

+   }

+#endif

+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

+   zero_samples=0;

+   png_set_write_user_transform_fn(write_ptr, count_zero_samples);

+#endif

+#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)

+#  ifndef PNG_HANDLE_CHUNK_ALWAYS

+#    define PNG_HANDLE_CHUNK_ALWAYS       3

+#  endif

+   png_set_keep_unknown_chunks(read_ptr, PNG_HANDLE_CHUNK_ALWAYS,

+      png_bytep_NULL, 0);

+#endif

+#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)

+#  ifndef PNG_HANDLE_CHUNK_IF_SAFE

+#    define PNG_HANDLE_CHUNK_IF_SAFE      2

+#  endif

+   png_set_keep_unknown_chunks(write_ptr, PNG_HANDLE_CHUNK_IF_SAFE,

+      png_bytep_NULL, 0);

+#endif

+   png_debug(0, "Reading info struct\n");

+   png_read_info(read_ptr, read_info_ptr);

+   png_debug(0, "Transferring info struct\n");

+   {

+      int interlace_type, compression_type, filter_type;

+      if (png_get_IHDR(read_ptr, read_info_ptr, &width, &height, &bit_depth,

+          &color_type, &interlace_type, &compression_type, &filter_type))

+      {

+         png_set_IHDR(write_ptr, write_info_ptr, width, height, bit_depth,

+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)

+            color_type, interlace_type, compression_type, filter_type);

+#else

+            color_type, PNG_INTERLACE_NONE, compression_type, filter_type);

+#endif

+      }

+   }

+#if defined(PNG_FIXED_POINT_SUPPORTED)

+#if defined(PNG_cHRM_SUPPORTED)

+   {

+      png_fixed_point white_x, white_y, red_x, red_y, green_x, green_y, blue_x,

+         blue_y;

+      if (png_get_cHRM_fixed(read_ptr, read_info_ptr, &white_x, &white_y, &red_x,

+         &red_y, &green_x, &green_y, &blue_x, &blue_y))

+      {

+         png_set_cHRM_fixed(write_ptr, write_info_ptr, white_x, white_y, red_x,

+            red_y, green_x, green_y, blue_x, blue_y);

+      }

+   }

+#endif

+#if defined(PNG_gAMA_SUPPORTED)

+   {

+      png_fixed_point gamma;

+      if (png_get_gAMA_fixed(read_ptr, read_info_ptr, &gamma))

+      {

+         png_set_gAMA_fixed(write_ptr, write_info_ptr, gamma);

+      }

+   }

+#endif

+#else /* Use floating point versions */

+#if defined(PNG_FLOATING_POINT_SUPPORTED)

+#if defined(PNG_cHRM_SUPPORTED)

+   {

+      double white_x, white_y, red_x, red_y, green_x, green_y, blue_x,

+         blue_y;

+      if (png_get_cHRM(read_ptr, read_info_ptr, &white_x, &white_y, &red_x,

+         &red_y, &green_x, &green_y, &blue_x, &blue_y))

+      {

+         png_set_cHRM(write_ptr, write_info_ptr, white_x, white_y, red_x,

+            red_y, green_x, green_y, blue_x, blue_y);

+      }

+   }

+#endif

+#if defined(PNG_gAMA_SUPPORTED)

+   {

+      double gamma;

+      if (png_get_gAMA(read_ptr, read_info_ptr, &gamma))

+      {

+         png_set_gAMA(write_ptr, write_info_ptr, gamma);

+      }

+   }

+#endif

+#endif /* floating point */

+#endif /* fixed point */

+#if defined(PNG_iCCP_SUPPORTED)

+   {

+      png_charp name;

+      png_charp profile;

+      png_uint_32 proflen;

+      int compression_type;

+      if (png_get_iCCP(read_ptr, read_info_ptr, &name, &compression_type,

+                      &profile, &proflen))

+      {

+         png_set_iCCP(write_ptr, write_info_ptr, name, compression_type,

+                      profile, proflen);

+      }

+   }

+#endif

+#if defined(PNG_sRGB_SUPPORTED)

+   {

+      int intent;

+      if (png_get_sRGB(read_ptr, read_info_ptr, &intent))

+      {

+         png_set_sRGB(write_ptr, write_info_ptr, intent);

+      }

+   }

+#endif

+   {

+      png_colorp palette;

+      int num_palette;

+      if (png_get_PLTE(read_ptr, read_info_ptr, &palette, &num_palette))

+      {

+         png_set_PLTE(write_ptr, write_info_ptr, palette, num_palette);

+      }

+   }

+#if defined(PNG_bKGD_SUPPORTED)

+   {

+      png_color_16p background;

+      if (png_get_bKGD(read_ptr, read_info_ptr, &background))

+      {

+         png_set_bKGD(write_ptr, write_info_ptr, background);

+      }

+   }

+#endif

+#if defined(PNG_hIST_SUPPORTED)

+   {

+      png_uint_16p hist;

+      if (png_get_hIST(read_ptr, read_info_ptr, &hist))

+      {

+         png_set_hIST(write_ptr, write_info_ptr, hist);

+      }

+   }

+#endif

+#if defined(PNG_oFFs_SUPPORTED)

+   {

+      png_int_32 offset_x, offset_y;

+      int unit_type;

+      if (png_get_oFFs(read_ptr, read_info_ptr,&offset_x,&offset_y,&unit_type))

+      {

+         png_set_oFFs(write_ptr, write_info_ptr, offset_x, offset_y, unit_type);

+      }

+   }

+#endif

+#if defined(PNG_pCAL_SUPPORTED)

+   {

+      png_charp purpose, units;

+      png_charpp params;

+      png_int_32 X0, X1;

+      int type, nparams;

+      if (png_get_pCAL(read_ptr, read_info_ptr, &purpose, &X0, &X1, &type,

+         &nparams, &units, &params))

+      {

+         png_set_pCAL(write_ptr, write_info_ptr, purpose, X0, X1, type,

+            nparams, units, params);

+      }

+   }

+#endif

+#if defined(PNG_pHYs_SUPPORTED)

+   {

+      png_uint_32 res_x, res_y;

+      int unit_type;

+      if (png_get_pHYs(read_ptr, read_info_ptr, &res_x, &res_y, &unit_type))

+      {

+         png_set_pHYs(write_ptr, write_info_ptr, res_x, res_y, unit_type);

+      }

+   }

+#endif

+#if defined(PNG_sBIT_SUPPORTED)

+   {

+      png_color_8p sig_bit;

+      if (png_get_sBIT(read_ptr, read_info_ptr, &sig_bit))

+      {

+         png_set_sBIT(write_ptr, write_info_ptr, sig_bit);

+      }

+   }

+#endif

+#if defined(PNG_sCAL_SUPPORTED)

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+   {

+      int unit;

+      double scal_width, scal_height;

+      if (png_get_sCAL(read_ptr, read_info_ptr, &unit, &scal_width,

+         &scal_height))

+      {

+         png_set_sCAL(write_ptr, write_info_ptr, unit, scal_width, scal_height);

+      }

+   }

+#else

+#ifdef PNG_FIXED_POINT_SUPPORTED

+   {

+      int unit;

+      png_charp scal_width, scal_height;

+      if (png_get_sCAL_s(read_ptr, read_info_ptr, &unit, &scal_width,

+          &scal_height))

+      {

+         png_set_sCAL_s(write_ptr, write_info_ptr, unit, scal_width, scal_height);

+      }

+   }

+#endif

+#endif

+#endif

+#if defined(PNG_TEXT_SUPPORTED)

+   {

+      png_textp text_ptr;

+      int num_text;

+      if (png_get_text(read_ptr, read_info_ptr, &text_ptr, &num_text) > 0)

+      {

+         png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks\n", num_text);

+         png_set_text(write_ptr, write_info_ptr, text_ptr, num_text);

+      }

+   }

+#endif

+#if defined(PNG_tIME_SUPPORTED)

+   {

+      png_timep mod_time;

+      if (png_get_tIME(read_ptr, read_info_ptr, &mod_time))

+      {

+         png_set_tIME(write_ptr, write_info_ptr, mod_time);

+#if defined(PNG_TIME_RFC1123_SUPPORTED)

+         /* we have to use png_strcpy instead of "=" because the string

+            pointed to by png_convert_to_rfc1123() gets free'ed before

+            we use it */

+         png_strcpy(tIME_string,png_convert_to_rfc1123(read_ptr, mod_time));

+         tIME_chunk_present++;

+#endif /* PNG_TIME_RFC1123_SUPPORTED */

+      }

+   }

+#endif

+#if defined(PNG_tRNS_SUPPORTED)

+   {

+      png_bytep trans;

+      int num_trans;

+      png_color_16p trans_values;

+      if (png_get_tRNS(read_ptr, read_info_ptr, &trans, &num_trans,

+         &trans_values))

+      {

+         png_set_tRNS(write_ptr, write_info_ptr, trans, num_trans,

+            trans_values);

+      }

+   }

+#endif

+#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)

+   {

+      png_unknown_chunkp unknowns;

+      int num_unknowns = (int)png_get_unknown_chunks(read_ptr, read_info_ptr,

+         &unknowns);

+      if (num_unknowns)

+      {

+         png_size_t i;

+         png_set_unknown_chunks(write_ptr, write_info_ptr, unknowns,

+           num_unknowns);

+         /* copy the locations from the read_info_ptr.  The automatically

+            generated locations in write_info_ptr are wrong because we

+            haven't written anything yet */

+         for (i = 0; i < (png_size_t)num_unknowns; i++)

+           png_set_unknown_chunk_location(write_ptr, write_info_ptr, i,

+             unknowns[i].location);

+      }

+   }

+#endif

+#ifdef PNG_WRITE_SUPPORTED

+   png_debug(0, "\nWriting info struct\n");

+/* If we wanted, we could write info in two steps:

+   png_write_info_before_PLTE(write_ptr, write_info_ptr);

+ */

+   png_write_info(write_ptr, write_info_ptr);

+#endif

+#ifdef SINGLE_ROWBUF_ALLOC

+   png_debug(0, "\nAllocating row buffer...");

+   row_buf = (png_bytep)png_malloc(read_ptr,

+      png_get_rowbytes(read_ptr, read_info_ptr));

+   png_debug1(0, "0x%08lx\n\n", (unsigned long)row_buf);

+#endif /* SINGLE_ROWBUF_ALLOC */

+   png_debug(0, "Writing row data\n");

+#if defined(PNG_READ_INTERLACING_SUPPORTED) || \

+  defined(PNG_WRITE_INTERLACING_SUPPORTED)

+   num_pass = png_set_interlace_handling(read_ptr);

+#  ifdef PNG_WRITE_SUPPORTED

+   png_set_interlace_handling(write_ptr);

+#  endif

+#else

+   num_pass=1;

+#endif

+#ifdef PNGTEST_TIMING

+   t_stop = (float)clock();

+   t_misc += (t_stop - t_start);

+   t_start = t_stop;

+#endif

+   for (pass = 0; pass < num_pass; pass++)

+   {

+      png_debug1(0, "Writing row data for pass %d\n",pass);

+      for (y = 0; y < height; y++)

+      {

+#ifndef SINGLE_ROWBUF_ALLOC

+         png_debug2(0, "\nAllocating row buffer (pass %d, y = %ld)...", pass,y);

+         row_buf = (png_bytep)png_malloc(read_ptr,

+            png_get_rowbytes(read_ptr, read_info_ptr));

+         png_debug2(0, "0x%08lx (%ld bytes)\n", (unsigned long)row_buf,

+            png_get_rowbytes(read_ptr, read_info_ptr));

+#endif /* !SINGLE_ROWBUF_ALLOC */

+         png_read_rows(read_ptr, (png_bytepp)&row_buf, png_bytepp_NULL, 1);

+#ifdef PNG_WRITE_SUPPORTED

+#ifdef PNGTEST_TIMING

+         t_stop = (float)clock();

+         t_decode += (t_stop - t_start);

+         t_start = t_stop;

+#endif

+         png_write_rows(write_ptr, (png_bytepp)&row_buf, 1);

+#ifdef PNGTEST_TIMING

+         t_stop = (float)clock();

+         t_encode += (t_stop - t_start);

+         t_start = t_stop;

+#endif

+#endif /* PNG_WRITE_SUPPORTED */

+#ifndef SINGLE_ROWBUF_ALLOC

+         png_debug2(0, "Freeing row buffer (pass %d, y = %ld)\n\n", pass, y);

+         png_free(read_ptr, row_buf);

+#endif /* !SINGLE_ROWBUF_ALLOC */

+      }

+   }

+#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)

+   png_free_data(read_ptr, read_info_ptr, PNG_FREE_UNKN, -1);

+#endif

+#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)

+   png_free_data(write_ptr, write_info_ptr, PNG_FREE_UNKN, -1);

+#endif

+   png_debug(0, "Reading and writing end_info data\n");

+   png_read_end(read_ptr, end_info_ptr);

+#if defined(PNG_TEXT_SUPPORTED)

+   {

+      png_textp text_ptr;

+      int num_text;

+      if (png_get_text(read_ptr, end_info_ptr, &text_ptr, &num_text) > 0)

+      {

+         png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks\n", num_text);

+         png_set_text(write_ptr, write_end_info_ptr, text_ptr, num_text);

+      }

+   }

+#endif

+#if defined(PNG_tIME_SUPPORTED)

+   {

+      png_timep mod_time;

+      if (png_get_tIME(read_ptr, end_info_ptr, &mod_time))

+      {

+         png_set_tIME(write_ptr, write_end_info_ptr, mod_time);

+#if defined(PNG_TIME_RFC1123_SUPPORTED)

+         /* we have to use png_strcpy instead of "=" because the string

+            pointed to by png_convert_to_rfc1123() gets free'ed before

+            we use it */

+         png_strcpy(tIME_string,png_convert_to_rfc1123(read_ptr, mod_time));

+         tIME_chunk_present++;

+#endif /* PNG_TIME_RFC1123_SUPPORTED */

+      }

+   }

+#endif

+#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)

+   {

+      png_unknown_chunkp unknowns;

+      int num_unknowns;

+      num_unknowns = (int)png_get_unknown_chunks(read_ptr, end_info_ptr,

+         &unknowns);

+      if (num_unknowns)

+      {

+         png_size_t i;

+         png_set_unknown_chunks(write_ptr, write_end_info_ptr, unknowns,

+           num_unknowns);

+         /* copy the locations from the read_info_ptr.  The automatically

+            generated locations in write_end_info_ptr are wrong because we

+            haven't written the end_info yet */

+         for (i = 0; i < (png_size_t)num_unknowns; i++)

+           png_set_unknown_chunk_location(write_ptr, write_end_info_ptr, i,

+             unknowns[i].location);

+      }

+   }

+#endif

+#ifdef PNG_WRITE_SUPPORTED

+   png_write_end(write_ptr, write_end_info_ptr);

+#endif

+#ifdef PNG_EASY_ACCESS_SUPPORTED

+   if(verbose)

+   {

+      png_uint_32 iwidth, iheight;

+      iwidth = png_get_image_width(write_ptr, write_info_ptr);

+      iheight = png_get_image_height(write_ptr, write_info_ptr);

+      fprintf(STDERR, "Image width = %lu, height = %lu\n",

+         iwidth, iheight);

+   }

+#endif

+   png_debug(0, "Destroying data structs\n");

+#ifdef SINGLE_ROWBUF_ALLOC

+   png_debug(1, "destroying row_buf for read_ptr\n");

+   png_free(read_ptr, row_buf);

+   row_buf=NULL;

+#endif /* SINGLE_ROWBUF_ALLOC */

+   png_debug(1, "destroying read_ptr, read_info_ptr, end_info_ptr\n");

+   png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);

+#ifdef PNG_WRITE_SUPPORTED

+   png_debug(1, "destroying write_end_info_ptr\n");

+   png_destroy_info_struct(write_ptr, &write_end_info_ptr);

+   png_debug(1, "destroying write_ptr, write_info_ptr\n");

+   png_destroy_write_struct(&write_ptr, &write_info_ptr);

+#endif

+   png_debug(0, "Destruction complete.\n");

+   FCLOSE(fpin);

+   FCLOSE(fpout);

+   png_debug(0, "Opening files for comparison\n");

+#if defined(_WIN32_WCE)

+   MultiByteToWideChar(CP_ACP, 0, inname, -1, path, MAX_PATH);

+   if ((fpin = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)

+#else

+   if ((fpin = fopen(inname, "rb")) == NULL)

+#endif

+   {

+      fprintf(STDERR, "Could not find file %s\n", inname);

+      return (1);

+   }

+#if defined(_WIN32_WCE)

+   MultiByteToWideChar(CP_ACP, 0, outname, -1, path, MAX_PATH);

+   if ((fpout = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)

+#else

+   if ((fpout = fopen(outname, "rb")) == NULL)

+#endif

+   {

+      fprintf(STDERR, "Could not find file %s\n", outname);

+      FCLOSE(fpin);

+      return (1);

+   }

+   for(;;)

+   {

+      png_size_t num_in, num_out;

+      READFILE(fpin, inbuf, 1, num_in);

+      READFILE(fpout, outbuf, 1, num_out);

+      if (num_in != num_out)

+      {

+         fprintf(STDERR, "\nFiles %s and %s are of a different size\n",

+                 inname, outname);

+         if(wrote_question == 0)

+         {

+            fprintf(STDERR,

+         "   Was %s written with the same maximum IDAT chunk size (%d bytes),",

+              inname,PNG_ZBUF_SIZE);

+            fprintf(STDERR,

+              "\n   filtering heuristic (libpng default), compression");

+            fprintf(STDERR,

+              " level (zlib default),\n   and zlib version (%s)?\n\n",

+              ZLIB_VERSION);

+            wrote_question=1;

+         }

+         FCLOSE(fpin);

+         FCLOSE(fpout);

+         return (0);

+      }

+      if (!num_in)

+         break;

+      if (png_memcmp(inbuf, outbuf, num_in))

+      {

+         fprintf(STDERR, "\nFiles %s and %s are different\n", inname, outname);

+         if(wrote_question == 0)

+         {

+            fprintf(STDERR,

+         "   Was %s written with the same maximum IDAT chunk size (%d bytes),",

+                 inname,PNG_ZBUF_SIZE);

+            fprintf(STDERR,

+              "\n   filtering heuristic (libpng default), compression");

+            fprintf(STDERR,

+              " level (zlib default),\n   and zlib version (%s)?\n\n",

+              ZLIB_VERSION);

+            wrote_question=1;

+         }

+         FCLOSE(fpin);

+         FCLOSE(fpout);

+         return (0);

+      }

+   }

+   FCLOSE(fpin);

+   FCLOSE(fpout);

+   return (0);

+}

+/* input and output filenames */

+#ifdef RISCOS

+static PNG_CONST char *inname = "pngtest/png";

+static PNG_CONST char *outname = "pngout/png";

+#else

+static PNG_CONST char *inname = "pngtest.png";

+static PNG_CONST char *outname = "pngout.png";

+#endif

+int

+main(int argc, char *argv[])

+{

+   int multiple = 0;

+   int ierror = 0;

+   fprintf(STDERR, "Testing libpng version %s\n", PNG_LIBPNG_VER_STRING);

+   fprintf(STDERR, "   with zlib   version %s\n", ZLIB_VERSION);

+   fprintf(STDERR,"%s",png_get_copyright(NULL));

+   /* Show the version of libpng used in building the library */

+   fprintf(STDERR," library (%lu):%s", png_access_version_number(),

+      png_get_header_version(NULL));

+   /* Show the version of libpng used in building the application */

+   fprintf(STDERR," pngtest (%lu):%s", (unsigned long)PNG_LIBPNG_VER,

+      PNG_HEADER_VERSION_STRING);

+   fprintf(STDERR," png_sizeof(png_struct)=%ld, png_sizeof(png_info)=%ld\n",

+                    (long)png_sizeof(png_struct), (long)png_sizeof(png_info));

+   /* Do some consistency checking on the memory allocation settings, I'm

+      not sure this matters, but it is nice to know, the first of these

+      tests should be impossible because of the way the macros are set

+      in pngconf.h */

+#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)

+      fprintf(STDERR, " NOTE: Zlib compiled for max 64k, libpng not\n");

+#endif

+   /* I think the following can happen. */

+#if !defined(MAXSEG_64K) && defined(PNG_MAX_MALLOC_64K)

+      fprintf(STDERR, " NOTE: libpng compiled for max 64k, zlib not\n");

+#endif

+   if (strcmp(png_libpng_ver, PNG_LIBPNG_VER_STRING))

+   {

+      fprintf(STDERR,

+         "Warning: versions are different between png.h and png.c\n");

+      fprintf(STDERR, "  png.h version: %s\n", PNG_LIBPNG_VER_STRING);

+      fprintf(STDERR, "  png.c version: %s\n\n", png_libpng_ver);

+      ++ierror;

+   }

+   if (argc > 1)

+   {

+      if (strcmp(argv[1], "-m") == 0)

+      {

+         multiple = 1;

+         status_dots_requested = 0;

+      }

+      else if (strcmp(argv[1], "-mv") == 0 ||

+               strcmp(argv[1], "-vm") == 0 )

+      {

+         multiple = 1;

+         verbose = 1;

+         status_dots_requested = 1;

+      }

+      else if (strcmp(argv[1], "-v") == 0)

+      {

+         verbose = 1;

+         status_dots_requested = 1;

+         inname = argv[2];

+      }

+      else

+      {

+         inname = argv[1];

+         status_dots_requested = 0;

+      }

+   }

+   if (!multiple && argc == 3+verbose)

+     outname = argv[2+verbose];

+   if ((!multiple && argc > 3+verbose) || (multiple && argc < 2))

+   {

+     fprintf(STDERR,

+       "usage: %s [infile.png] [outfile.png]\n\t%s -m {infile.png}\n",

+        argv[0], argv[0]);

+     fprintf(STDERR,

+       "  reads/writes one PNG file (without -m) or multiple files (-m)\n");

+     fprintf(STDERR,

+       "  with -m %s is used as a temporary file\n", outname);

+     exit(1);

+   }

+   if (multiple)

+   {

+      int i;

+#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

+      int allocation_now = current_allocation;

+#endif

+      for (i=2; i<argc; ++i)

+      {

+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)

+         int k;

+#endif

+         int kerror;

+         fprintf(STDERR, "Testing %s:",argv[i]);

+         kerror = test_one_file(argv[i], outname);

+         if (kerror == 0)

+         {

+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

+            fprintf(STDERR, "\n PASS (%lu zero samples)\n",zero_samples);

+#else

+            fprintf(STDERR, " PASS\n");

+#endif

+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)

+            for (k=0; k<256; k++)

+               if(filters_used[k])

+                  fprintf(STDERR, " Filter %d was used %lu times\n",

+                     k,filters_used[k]);

+#endif

+#if defined(PNG_TIME_RFC1123_SUPPORTED)

+         if(tIME_chunk_present != 0)

+            fprintf(STDERR, " tIME = %s\n",tIME_string);

+         tIME_chunk_present = 0;

+#endif /* PNG_TIME_RFC1123_SUPPORTED */

+         }

+         else

+         {

+            fprintf(STDERR, " FAIL\n");

+            ierror += kerror;

+         }

+#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

+         if (allocation_now != current_allocation)

+            fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",

+               current_allocation-allocation_now);

+         if (current_allocation != 0)

+         {

+            memory_infop pinfo = pinformation;

+            fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n",

+               current_allocation);

+            while (pinfo != NULL)

+            {

+               fprintf(STDERR, " %lu bytes at %x\n", pinfo->size,

+                 (unsigned int) pinfo->pointer);

+               pinfo = pinfo->next;

+            }

+         }

+#endif

+      }

+#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

+         fprintf(STDERR, " Current memory allocation: %10d bytes\n",

+            current_allocation);

+         fprintf(STDERR, " Maximum memory allocation: %10d bytes\n",

+            maximum_allocation);

+         fprintf(STDERR, " Total   memory allocation: %10d bytes\n",

+            total_allocation);

+         fprintf(STDERR, "     Number of allocations: %10d\n",

+            num_allocations);

+#endif

+   }

+   else

+   {

+      int i;

+      for (i=0; i<3; ++i)

+      {

+         int kerror;

+#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

+         int allocation_now = current_allocation;

+#endif

+         if (i == 1) status_dots_requested = 1;

+         else if(verbose == 0)status_dots_requested = 0;

+         if (i == 0 || verbose == 1 || ierror != 0)

+            fprintf(STDERR, "Testing %s:",inname);

+         kerror = test_one_file(inname, outname);

+         if(kerror == 0)

+         {

+            if(verbose == 1 || i == 2)

+            {

+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)

+                int k;

+#endif

+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

+                fprintf(STDERR, "\n PASS (%lu zero samples)\n",zero_samples);

+#else

+                fprintf(STDERR, " PASS\n");

+#endif

+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)

+                for (k=0; k<256; k++)

+                   if(filters_used[k])

+                      fprintf(STDERR, " Filter %d was used %lu times\n",

+                         k,filters_used[k]);

+#endif

+#if defined(PNG_TIME_RFC1123_SUPPORTED)

+             if(tIME_chunk_present != 0)

+                fprintf(STDERR, " tIME = %s\n",tIME_string);

+#endif /* PNG_TIME_RFC1123_SUPPORTED */

+            }

+         }

+         else

+         {

+            if(verbose == 0 && i != 2)

+               fprintf(STDERR, "Testing %s:",inname);

+            fprintf(STDERR, " FAIL\n");

+            ierror += kerror;

+         }

+#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

+         if (allocation_now != current_allocation)

+             fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n",

+               current_allocation-allocation_now);

+         if (current_allocation != 0)

+         {

+             memory_infop pinfo = pinformation;

+             fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n",

+                current_allocation);

+             while (pinfo != NULL)

+             {

+                fprintf(STDERR," %lu bytes at %x\n",

+                   pinfo->size, (unsigned int)pinfo->pointer);

+                pinfo = pinfo->next;

+             }

+          }

+#endif

+       }

+#if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG

+       fprintf(STDERR, " Current memory allocation: %10d bytes\n",

+          current_allocation);

+       fprintf(STDERR, " Maximum memory allocation: %10d bytes\n",

+          maximum_allocation);

+       fprintf(STDERR, " Total   memory allocation: %10d bytes\n",

+          total_allocation);

+       fprintf(STDERR, "     Number of allocations: %10d\n",

+            num_allocations);

+#endif

+   }

+#ifdef PNGTEST_TIMING

+   t_stop = (float)clock();

+   t_misc += (t_stop - t_start);

+   t_start = t_stop;

+   fprintf(STDERR," CPU time used = %.3f seconds",

+      (t_misc+t_decode+t_encode)/(float)CLOCKS_PER_SEC);

+   fprintf(STDERR," (decoding %.3f,\n",

+      t_decode/(float)CLOCKS_PER_SEC);

+   fprintf(STDERR,"        encoding %.3f ,",

+      t_encode/(float)CLOCKS_PER_SEC);

+   fprintf(STDERR," other %.3f seconds)\n\n",

+      t_misc/(float)CLOCKS_PER_SEC);

+#endif

+   if (ierror == 0)

+      fprintf(STDERR, "libpng passes test\n");

+   else

+      fprintf(STDERR, "libpng FAILS test\n");

+   return (int)(ierror != 0);

+}

+/* Generate a compiler error if there is an old png.h in the search path. */

+typedef version_1_2_8 your_png_h_is_not_version_1_2_8;

binary files /dev/null b/src/gfx/libpng/pngtest.png differ

--- /dev/null

+++ b/src/gfx/libpng/pngtrans.c

@@ -1,0 +1,650 @@

+/* pngtrans.c - transforms the data in a row (used by both readers and writers)

+ *

+ * libpng  1.2.8 - December 3, 2004

+ * For conditions of distribution and use, see copyright notice in png.h

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

+ */

+#define PNG_INTERNAL

+#include "png.h"

+#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)

+/* turn on BGR-to-RGB mapping */

+void PNGAPI

+png_set_bgr(png_structp png_ptr)

+{

+   png_debug(1, "in png_set_bgr\n");

+   png_ptr->transformations |= PNG_BGR;

+}

+#endif

+#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)

+/* turn on 16 bit byte swapping */

+void PNGAPI

+png_set_swap(png_structp png_ptr)

+{

+   png_debug(1, "in png_set_swap\n");

+   if (png_ptr->bit_depth == 16)

+      png_ptr->transformations |= PNG_SWAP_BYTES;

+}

+#endif

+#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)

+/* turn on pixel packing */

+void PNGAPI

+png_set_packing(png_structp png_ptr)

+{

+   png_debug(1, "in png_set_packing\n");

+   if (png_ptr->bit_depth < 8)

+   {

+      png_ptr->transformations |= PNG_PACK;

+      png_ptr->usr_bit_depth = 8;

+   }

+}

+#endif

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)

+/* turn on packed pixel swapping */

+void PNGAPI

+png_set_packswap(png_structp png_ptr)

+{

+   png_debug(1, "in png_set_packswap\n");

+   if (png_ptr->bit_depth < 8)

+      png_ptr->transformations |= PNG_PACKSWAP;

+}

+#endif

+#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)

+void PNGAPI

+png_set_shift(png_structp png_ptr, png_color_8p true_bits)

+{

+   png_debug(1, "in png_set_shift\n");

+   png_ptr->transformations |= PNG_SHIFT;

+   png_ptr->shift = *true_bits;

+}

+#endif

+#if defined(PNG_READ_INTERLACING_SUPPORTED) || \

+    defined(PNG_WRITE_INTERLACING_SUPPORTED)

+int PNGAPI

+png_set_interlace_handling(png_structp png_ptr)

+{

+   png_debug(1, "in png_set_interlace handling\n");

+   if (png_ptr->interlaced)

+   {

+      png_ptr->transformations |= PNG_INTERLACE;

+      return (7);

+   }

+   return (1);

+}

+#endif

+#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)

+/* Add a filler byte on read, or remove a filler or alpha byte on write.

+ * The filler type has changed in v0.95 to allow future 2-byte fillers

+ * for 48-bit input data, as well as to avoid problems with some compilers

+ * that don't like bytes as parameters.

+ */

+void PNGAPI

+png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)

+{

+   png_debug(1, "in png_set_filler\n");

+   png_ptr->transformations |= PNG_FILLER;

+   png_ptr->filler = (png_byte)filler;

+   if (filler_loc == PNG_FILLER_AFTER)

+      png_ptr->flags |= PNG_FLAG_FILLER_AFTER;

+   else

+      png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;

+   /* This should probably go in the "do_read_filler" routine.

+    * I attempted to do that in libpng-1.0.1a but that caused problems

+    * so I restored it in libpng-1.0.2a

+   */

+   if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)

+   {

+      png_ptr->usr_channels = 4;

+   }

+   /* Also I added this in libpng-1.0.2a (what happens when we expand

+    * a less-than-8-bit grayscale to GA? */

+   if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8)

+   {

+      png_ptr->usr_channels = 2;

+   }

+}

+#if !defined(PNG_1_0_X)

+/* Added to libpng-1.2.7 */

+void PNGAPI

+png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc)

+{

+   png_debug(1, "in png_set_add_alpha\n");

+   png_set_filler(png_ptr, filler, filler_loc);

+   png_ptr->transformations |= PNG_ADD_ALPHA;

+}

+#endif

+#endif

+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \

+    defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)

+void PNGAPI

+png_set_swap_alpha(png_structp png_ptr)

+{

+   png_debug(1, "in png_set_swap_alpha\n");

+   png_ptr->transformations |= PNG_SWAP_ALPHA;

+}

+#endif

+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \

+    defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)

+void PNGAPI

+png_set_invert_alpha(png_structp png_ptr)

+{

+   png_debug(1, "in png_set_invert_alpha\n");

+   png_ptr->transformations |= PNG_INVERT_ALPHA;

+}

+#endif

+#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)

+void PNGAPI

+png_set_invert_mono(png_structp png_ptr)

+{

+   png_debug(1, "in png_set_invert_mono\n");

+   png_ptr->transformations |= PNG_INVERT_MONO;

+}

+/* invert monochrome grayscale data */

+void /* PRIVATE */

+png_do_invert(png_row_infop row_info, png_bytep row)

+{

+   png_debug(1, "in png_do_invert\n");

+  /* This test removed from libpng version 1.0.13 and 1.2.0:

+   *   if (row_info->bit_depth == 1 &&

+   */

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+   if (row == NULL || row_info == NULL)

+     return;

+#endif

+   if (row_info->color_type == PNG_COLOR_TYPE_GRAY)

+   {

+      png_bytep rp = row;

+      png_uint_32 i;

+      png_uint_32 istop = row_info->rowbytes;

+      for (i = 0; i < istop; i++)

+      {

+         *rp = (png_byte)(~(*rp));

+         rp++;

+      }

+   }

+   else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&

+      row_info->bit_depth == 8)

+   {

+      png_bytep rp = row;

+      png_uint_32 i;

+      png_uint_32 istop = row_info->rowbytes;

+      for (i = 0; i < istop; i+=2)

+      {

+         *rp = (png_byte)(~(*rp));

+         rp+=2;

+      }

+   }

+   else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&

+      row_info->bit_depth == 16)

+   {

+      png_bytep rp = row;

+      png_uint_32 i;

+      png_uint_32 istop = row_info->rowbytes;

+      for (i = 0; i < istop; i+=4)

+      {

+         *rp = (png_byte)(~(*rp));

+         *(rp+1) = (png_byte)(~(*(rp+1)));

+         rp+=4;

+      }

+   }

+}

+#endif

+#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)

+/* swaps byte order on 16 bit depth images */

+void /* PRIVATE */

+png_do_swap(png_row_infop row_info, png_bytep row)

+{

+   png_debug(1, "in png_do_swap\n");

+   if (

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+       row != NULL && row_info != NULL &&

+#endif

+       row_info->bit_depth == 16)

+   {

+      png_bytep rp = row;

+      png_uint_32 i;

+      png_uint_32 istop= row_info->width * row_info->channels;

+      for (i = 0; i < istop; i++, rp += 2)

+      {

+         png_byte t = *rp;

+         *rp = *(rp + 1);

+         *(rp + 1) = t;

+      }

+   }

+}

+#endif

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)

+static png_byte onebppswaptable[256] = {

+   0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,

+   0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,

+   0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,

+   0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,

+   0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,

+   0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,

+   0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,

+   0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,

+   0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,

+   0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,

+   0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,

+   0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,

+   0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,

+   0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,

+   0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,

+   0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,

+   0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,

+   0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,

+   0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,

+   0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,

+   0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,

+   0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,

+   0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,

+   0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,

+   0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,

+   0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,

+   0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,

+   0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,

+   0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,

+   0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,

+   0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,

+   0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF

+};

+static png_byte twobppswaptable[256] = {

+   0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,

+   0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,

+   0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,

+   0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,

+   0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,

+   0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,

+   0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,

+   0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,

+   0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,

+   0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,

+   0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,

+   0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,

+   0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,

+   0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,

+   0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,

+   0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,

+   0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,

+   0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,

+   0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,

+   0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,

+   0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,

+   0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,

+   0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,

+   0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,

+   0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,

+   0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,

+   0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,

+   0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,

+   0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,

+   0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,

+   0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,

+   0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF

+};

+static png_byte fourbppswaptable[256] = {

+   0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,

+   0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,

+   0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,

+   0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,

+   0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,

+   0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,

+   0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,

+   0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,

+   0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,

+   0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,

+   0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,

+   0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,

+   0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,

+   0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,

+   0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,

+   0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,

+   0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,

+   0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,

+   0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,

+   0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,

+   0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,

+   0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,

+   0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,

+   0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,

+   0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,

+   0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,

+   0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,

+   0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,

+   0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,

+   0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,

+   0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,

+   0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF

+};

+/* swaps pixel packing order within bytes */

+void /* PRIVATE */

+png_do_packswap(png_row_infop row_info, png_bytep row)

+{

+   png_debug(1, "in png_do_packswap\n");

+   if (

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+       row != NULL && row_info != NULL &&

+#endif

+       row_info->bit_depth < 8)

+   {

+      png_bytep rp, end, table;

+      end = row + row_info->rowbytes;

+      if (row_info->bit_depth == 1)

+         table = onebppswaptable;

+      else if (row_info->bit_depth == 2)

+         table = twobppswaptable;

+      else if (row_info->bit_depth == 4)

+         table = fourbppswaptable;

+      else

+         return;

+      for (rp = row; rp < end; rp++)

+         *rp = table[*rp];

+   }

+}

+#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */

+#if defined(PNG_WRITE_FILLER_SUPPORTED) || \

+    defined(PNG_READ_STRIP_ALPHA_SUPPORTED)

+/* remove filler or alpha byte(s) */

+void /* PRIVATE */

+png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)

+{

+   png_debug(1, "in png_do_strip_filler\n");

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+   if (row != NULL && row_info != NULL)

+#endif

+   {

+      png_bytep sp=row;

+      png_bytep dp=row;

+      png_uint_32 row_width=row_info->width;

+      png_uint_32 i;

+      if ((row_info->color_type == PNG_COLOR_TYPE_RGB ||

+         (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&

+         (flags & PNG_FLAG_STRIP_ALPHA))) &&

+         row_info->channels == 4)

+      {

+         if (row_info->bit_depth == 8)

+         {

+            /* This converts from RGBX or RGBA to RGB */

+            if (flags & PNG_FLAG_FILLER_AFTER)

+            {

+               dp+=3; sp+=4;

+               for (i = 1; i < row_width; i++)

+               {

+                  *dp++ = *sp++;

+                  *dp++ = *sp++;

+                  *dp++ = *sp++;

+                  sp++;

+               }

+            }

+            /* This converts from XRGB or ARGB to RGB */

+            else

+            {

+               for (i = 0; i < row_width; i++)

+               {

+                  sp++;

+                  *dp++ = *sp++;

+                  *dp++ = *sp++;

+                  *dp++ = *sp++;

+               }

+            }

+            row_info->pixel_depth = 24;

+            row_info->rowbytes = row_width * 3;

+         }

+         else /* if (row_info->bit_depth == 16) */

+         {

+            if (flags & PNG_FLAG_FILLER_AFTER)

+            {

+               /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */

+               sp += 8; dp += 6;

+               for (i = 1; i < row_width; i++)

+               {

+                  /* This could be (although png_memcpy is probably slower):

+                  png_memcpy(dp, sp, 6);

+                  sp += 8;

+                  dp += 6;

+                  */

+                  *dp++ = *sp++;

+                  *dp++ = *sp++;

+                  *dp++ = *sp++;

+                  *dp++ = *sp++;

+                  *dp++ = *sp++;

+                  *dp++ = *sp++;

+                  sp += 2;

+               }

+            }

+            else

+            {

+               /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */

+               for (i = 0; i < row_width; i++)

+               {

+                  /* This could be (although png_memcpy is probably slower):

+                  png_memcpy(dp, sp, 6);

+                  sp += 8;

+                  dp += 6;

+                  */

+                  sp+=2;

+                  *dp++ = *sp++;

+                  *dp++ = *sp++;

+                  *dp++ = *sp++;

+                  *dp++ = *sp++;

+                  *dp++ = *sp++;

+                  *dp++ = *sp++;

+               }

+            }

+            row_info->pixel_depth = 48;

+            row_info->rowbytes = row_width * 6;

+         }

+         row_info->channels = 3;

+      }

+      else if ((row_info->color_type == PNG_COLOR_TYPE_GRAY ||

+         (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&

+         (flags & PNG_FLAG_STRIP_ALPHA))) &&

+          row_info->channels == 2)

+      {

+         if (row_info->bit_depth == 8)

+         {

+            /* This converts from GX or GA to G */

+            if (flags & PNG_FLAG_FILLER_AFTER)

+            {

+               for (i = 0; i < row_width; i++)

+               {

+                  *dp++ = *sp++;

+                  sp++;

+               }

+            }

+            /* This converts from XG or AG to G */

+            else

+            {

+               for (i = 0; i < row_width; i++)

+               {

+                  sp++;

+                  *dp++ = *sp++;

+               }

+            }

+            row_info->pixel_depth = 8;

+            row_info->rowbytes = row_width;

+         }

+         else /* if (row_info->bit_depth == 16) */

+         {

+            if (flags & PNG_FLAG_FILLER_AFTER)

+            {

+               /* This converts from GGXX or GGAA to GG */

+               sp += 4; dp += 2;

+               for (i = 1; i < row_width; i++)

+               {

+                  *dp++ = *sp++;

+                  *dp++ = *sp++;

+                  sp += 2;

+               }

+            }

+            else

+            {

+               /* This converts from XXGG or AAGG to GG */

+               for (i = 0; i < row_width; i++)

+               {

+                  sp += 2;

+                  *dp++ = *sp++;

+                  *dp++ = *sp++;

+               }

+            }

+            row_info->pixel_depth = 16;

+            row_info->rowbytes = row_width * 2;

+         }

+         row_info->channels = 1;

+      }

+      if (flags & PNG_FLAG_STRIP_ALPHA)

+        row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;

+   }

+}

+#endif

+#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)

+/* swaps red and blue bytes within a pixel */

+void /* PRIVATE */

+png_do_bgr(png_row_infop row_info, png_bytep row)

+{

+   png_debug(1, "in png_do_bgr\n");

+   if (

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+       row != NULL && row_info != NULL &&

+#endif

+       (row_info->color_type & PNG_COLOR_MASK_COLOR))

+   {

+      png_uint_32 row_width = row_info->width;

+      if (row_info->bit_depth == 8)

+      {

+         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

+         {

+            png_bytep rp;

+            png_uint_32 i;

+            for (i = 0, rp = row; i < row_width; i++, rp += 3)

+            {

+               png_byte save = *rp;

+               *rp = *(rp + 2);

+               *(rp + 2) = save;

+            }

+         }

+         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+         {

+            png_bytep rp;

+            png_uint_32 i;

+            for (i = 0, rp = row; i < row_width; i++, rp += 4)

+            {

+               png_byte save = *rp;

+               *rp = *(rp + 2);

+               *(rp + 2) = save;

+            }

+         }

+      }

+      else if (row_info->bit_depth == 16)

+      {

+         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

+         {

+            png_bytep rp;

+            png_uint_32 i;

+            for (i = 0, rp = row; i < row_width; i++, rp += 6)

+            {

+               png_byte save = *rp;

+               *rp = *(rp + 4);

+               *(rp + 4) = save;

+               save = *(rp + 1);

+               *(rp + 1) = *(rp + 5);

+               *(rp + 5) = save;

+            }

+         }

+         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+         {

+            png_bytep rp;

+            png_uint_32 i;

+            for (i = 0, rp = row; i < row_width; i++, rp += 8)

+            {

+               png_byte save = *rp;

+               *rp = *(rp + 4);

+               *(rp + 4) = save;

+               save = *(rp + 1);

+               *(rp + 1) = *(rp + 5);

+               *(rp + 5) = save;

+            }

+         }

+      }

+   }

+}

+#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */

+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \

+    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \

+    defined(PNG_LEGACY_SUPPORTED)

+void PNGAPI

+png_set_user_transform_info(png_structp png_ptr, png_voidp

+   user_transform_ptr, int user_transform_depth, int user_transform_channels)

+{

+   png_debug(1, "in png_set_user_transform_info\n");

+#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)

+   png_ptr->user_transform_ptr = user_transform_ptr;

+   png_ptr->user_transform_depth = (png_byte)user_transform_depth;

+   png_ptr->user_transform_channels = (png_byte)user_transform_channels;

+#else

+   if(user_transform_ptr || user_transform_depth || user_transform_channels)

+      png_warning(png_ptr,

+        "This version of libpng does not support user transform info");

+#endif

+}

+#endif

+/* This function returns a pointer to the user_transform_ptr associated with

+ * the user transform functions.  The application should free any memory

+ * associated with this pointer before png_write_destroy and png_read_destroy

+ * are called.

+ */

+png_voidp PNGAPI

+png_get_user_transform_ptr(png_structp png_ptr)

+{

+#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)

+   return ((png_voidp)png_ptr->user_transform_ptr);

+#else

+   if(png_ptr)

+     return (NULL);

+   return (NULL);

+#endif

+}

--- /dev/null

+++ b/src/gfx/libpng/pngvcrd.c

@@ -1,0 +1,3903 @@

+/* pngvcrd.c - mixed C/assembler version of utilities to read a PNG file

+ *

+ * For Intel x86 CPU and Microsoft Visual C++ compiler

+ *

+ * libpng version 1.2.8 - December 3, 2004

+ * For conditions of distribution and use, see copyright notice in png.h

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * Copyright (c) 1998, Intel Corporation

+ *

+ * Contributed by Nirav Chhatrapati, Intel Corporation, 1998

+ * Interface to libpng contributed by Gilles Vollant, 1999

+ *

+ *

+ * In png_do_read_interlace() in libpng versions 1.0.3a through 1.0.4d,

+ * a sign error in the post-MMX cleanup code for each pixel_depth resulted

+ * in bad pixels at the beginning of some rows of some images, and also

+ * (due to out-of-range memory reads and writes) caused heap corruption

+ * when compiled with MSVC 6.0.  The error was fixed in version 1.0.4e.

+ *

+ * [png_read_filter_row_mmx_avg() bpp == 2 bugfix, GRR 20000916]

+ *

+ * [runtime MMX configuration, GRR 20010102]

+ *

+ */

+#define PNG_INTERNAL

+#include "png.h"

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD)

+static int mmx_supported=2;

+int PNGAPI

+png_mmx_support(void)

+{

+  int mmx_supported_local = 0;

+  _asm {

+    push ebx          //CPUID will trash these

+    push ecx

+    push edx

+    pushfd            //Save Eflag to stack

+    pop eax           //Get Eflag from stack into eax

+    mov ecx, eax      //Make another copy of Eflag in ecx

+    xor eax, 0x200000 //Toggle ID bit in Eflag [i.e. bit(21)]

+    push eax          //Save modified Eflag back to stack

+    popfd             //Restored modified value back to Eflag reg

+    pushfd            //Save Eflag to stack

+    pop eax           //Get Eflag from stack

+    push ecx          // save original Eflag to stack

+    popfd             // restore original Eflag

+    xor eax, ecx      //Compare the new Eflag with the original Eflag

+    jz NOT_SUPPORTED  //If the same, CPUID instruction is not supported,

+                      //skip following instructions and jump to

+                      //NOT_SUPPORTED label

+    xor eax, eax      //Set eax to zero

+    _asm _emit 0x0f   //CPUID instruction  (two bytes opcode)

+    _asm _emit 0xa2

+    cmp eax, 1        //make sure eax return non-zero value

+    jl NOT_SUPPORTED  //If eax is zero, mmx not supported

+    xor eax, eax      //set eax to zero

+    inc eax           //Now increment eax to 1.  This instruction is

+                      //faster than the instruction "mov eax, 1"

+    _asm _emit 0x0f   //CPUID instruction

+    _asm _emit 0xa2

+    and edx, 0x00800000  //mask out all bits but mmx bit(24)

+    cmp edx, 0        // 0 = mmx not supported

+    jz  NOT_SUPPORTED // non-zero = Yes, mmx IS supported

+    mov  mmx_supported_local, 1  //set return value to 1

+NOT_SUPPORTED:

+    mov  eax, mmx_supported_local  //move return value to eax

+    pop edx          //CPUID trashed these

+    pop ecx

+    pop ebx

+  }

+  //mmx_supported_local=0; // test code for force don't support MMX

+  //printf("MMX : %u (1=MMX supported)\n",mmx_supported_local);

+  mmx_supported = mmx_supported_local;

+  return mmx_supported_local;

+}

+/* Combines the row recently read in with the previous row.

+   This routine takes care of alpha and transparency if requested.

+   This routine also handles the two methods of progressive display

+   of interlaced images, depending on the mask value.

+   The mask value describes which pixels are to be combined with

+   the row.  The pattern always repeats every 8 pixels, so just 8

+   bits are needed.  A one indicates the pixel is to be combined; a

+   zero indicates the pixel is to be skipped.  This is in addition

+   to any alpha or transparency value associated with the pixel.  If

+   you want all pixels to be combined, pass 0xff (255) in mask.  */

+/* Use this routine for x86 platform - uses faster MMX routine if machine

+   supports MMX */

+void /* PRIVATE */

+png_combine_row(png_structp png_ptr, png_bytep row, int mask)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

+#endif

+   png_debug(1,"in png_combine_row_asm\n");

+   if (mmx_supported == 2) {

+#if !defined(PNG_1_0_X)

+       /* this should have happened in png_init_mmx_flags() already */

+       png_warning(png_ptr, "asm_flags may not have been initialized");

+#endif

+       png_mmx_support();

+   }

+   if (mask == 0xff)

+   {

+      png_memcpy(row, png_ptr->row_buf + 1,

+       (png_size_t)PNG_ROWBYTES(png_ptr->row_info.pixel_depth,

+       png_ptr->width));

+   }

+   /* GRR:  add "else if (mask == 0)" case?

+    *       or does png_combine_row() not even get called in that case? */

+   else

+   {

+      switch (png_ptr->row_info.pixel_depth)

+      {

+         case 1:

+         {

+            png_bytep sp;

+            png_bytep dp;

+            int s_inc, s_start, s_end;

+            int m;

+            int shift;

+            png_uint_32 i;

+            sp = png_ptr->row_buf + 1;

+            dp = row;

+            m = 0x80;

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+            if (png_ptr->transformations & PNG_PACKSWAP)

+            {

+                s_start = 0;

+                s_end = 7;

+                s_inc = 1;

+            }

+            else

+#endif

+            {

+                s_start = 7;

+                s_end = 0;

+                s_inc = -1;

+            }

+            shift = s_start;

+            for (i = 0; i < png_ptr->width; i++)

+            {

+               if (m & mask)

+               {

+                  int value;

+                  value = (*sp >> shift) & 0x1;

+                  *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);

+                  *dp |= (png_byte)(value << shift);

+               }

+               if (shift == s_end)

+               {

+                  shift = s_start;

+                  sp++;

+                  dp++;

+               }

+               else

+                  shift += s_inc;

+               if (m == 1)

+                  m = 0x80;

+               else

+                  m >>= 1;

+            }

+            break;

+         }

+         case 2:

+         {

+            png_bytep sp;

+            png_bytep dp;

+            int s_start, s_end, s_inc;

+            int m;

+            int shift;

+            png_uint_32 i;

+            int value;

+            sp = png_ptr->row_buf + 1;

+            dp = row;

+            m = 0x80;

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+            if (png_ptr->transformations & PNG_PACKSWAP)

+            {

+               s_start = 0;

+               s_end = 6;

+               s_inc = 2;

+            }

+            else

+#endif

+            {

+               s_start = 6;

+               s_end = 0;

+               s_inc = -2;

+            }

+            shift = s_start;

+            for (i = 0; i < png_ptr->width; i++)

+            {

+               if (m & mask)

+               {

+                  value = (*sp >> shift) & 0x3;

+                  *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);

+                  *dp |= (png_byte)(value << shift);

+               }

+               if (shift == s_end)

+               {

+                  shift = s_start;

+                  sp++;

+                  dp++;

+               }

+               else

+                  shift += s_inc;

+               if (m == 1)

+                  m = 0x80;

+               else

+                  m >>= 1;

+            }

+            break;

+         }

+         case 4:

+         {

+            png_bytep sp;

+            png_bytep dp;

+            int s_start, s_end, s_inc;

+            int m;

+            int shift;

+            png_uint_32 i;

+            int value;

+            sp = png_ptr->row_buf + 1;

+            dp = row;

+            m = 0x80;

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+            if (png_ptr->transformations & PNG_PACKSWAP)

+            {

+               s_start = 0;

+               s_end = 4;

+               s_inc = 4;

+            }

+            else

+#endif

+            {

+               s_start = 4;

+               s_end = 0;

+               s_inc = -4;

+            }

+            shift = s_start;

+            for (i = 0; i < png_ptr->width; i++)

+            {

+               if (m & mask)

+               {

+                  value = (*sp >> shift) & 0xf;

+                  *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);

+                  *dp |= (png_byte)(value << shift);

+               }

+               if (shift == s_end)

+               {

+                  shift = s_start;

+                  sp++;

+                  dp++;

+               }

+               else

+                  shift += s_inc;

+               if (m == 1)

+                  m = 0x80;

+               else

+                  m >>= 1;

+            }

+            break;

+         }

+         case 8:

+         {

+            png_bytep srcptr;

+            png_bytep dstptr;

+            png_uint_32 len;

+            int m;

+            int diff, unmask;

+            __int64 mask0=0x0102040810204080;

+#if !defined(PNG_1_0_X)

+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)

+                /* && mmx_supported */ )

+#else

+            if (mmx_supported)

+#endif

+            {

+               srcptr = png_ptr->row_buf + 1;

+               dstptr = row;

+               m = 0x80;

+               unmask = ~mask;

+               len  = png_ptr->width &~7;  //reduce to multiple of 8

+               diff = png_ptr->width & 7;  //amount lost

+               _asm

+               {

+                  movd       mm7, unmask   //load bit pattern

+                  psubb      mm6,mm6       //zero mm6

+                  punpcklbw  mm7,mm7

+                  punpcklwd  mm7,mm7

+                  punpckldq  mm7,mm7       //fill register with 8 masks

+                  movq       mm0,mask0

+                  pand       mm0,mm7       //nonzero if keep byte

+                  pcmpeqb    mm0,mm6       //zeros->1s, v versa

+                  mov        ecx,len       //load length of line (pixels)

+                  mov        esi,srcptr    //load source

+                  mov        ebx,dstptr    //load dest

+                  cmp        ecx,0         //lcr

+                  je         mainloop8end

+mainloop8:

+                  movq       mm4,[esi]

+                  pand       mm4,mm0

+                  movq       mm6,mm0

+                  pandn      mm6,[ebx]

+                  por        mm4,mm6

+                  movq       [ebx],mm4

+                  add        esi,8         //inc by 8 bytes processed

+                  add        ebx,8

+                  sub        ecx,8         //dec by 8 pixels processed

+                  ja         mainloop8

+mainloop8end:

+                  mov        ecx,diff

+                  cmp        ecx,0

+                  jz         end8

+                  mov        edx,mask

+                  sal        edx,24        //make low byte the high byte

+secondloop8:

+                  sal        edx,1         //move high bit to CF

+                  jnc        skip8         //if CF = 0

+                  mov        al,[esi]

+                  mov        [ebx],al

+skip8:

+                  inc        esi

+                  inc        ebx

+                  dec        ecx

+                  jnz        secondloop8

+end8:

+                  emms

+               }

+            }

+            else /* mmx not supported - use modified C routine */

+            {

+               register unsigned int incr1, initial_val, final_val;

+               png_size_t pixel_bytes;

+               png_uint_32 i;

+               register int disp = png_pass_inc[png_ptr->pass];

+               int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};

+               pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);

+               srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*

+                  pixel_bytes;

+               dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;

+               initial_val = offset_table[png_ptr->pass]*pixel_bytes;

+               final_val = png_ptr->width*pixel_bytes;

+               incr1 = (disp)*pixel_bytes;

+               for (i = initial_val; i < final_val; i += incr1)

+               {

+                  png_memcpy(dstptr, srcptr, pixel_bytes);

+                  srcptr += incr1;

+                  dstptr += incr1;

+               }

+            } /* end of else */

+            break;

+         }       // end 8 bpp

+         case 16:

+         {

+            png_bytep srcptr;

+            png_bytep dstptr;

+            png_uint_32 len;

+            int unmask, diff;

+            __int64 mask1=0x0101020204040808,

+                    mask0=0x1010202040408080;

+#if !defined(PNG_1_0_X)

+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)

+                /* && mmx_supported */ )

+#else

+            if (mmx_supported)

+#endif

+            {

+               srcptr = png_ptr->row_buf + 1;

+               dstptr = row;

+               unmask = ~mask;

+               len     = (png_ptr->width)&~7;

+               diff = (png_ptr->width)&7;

+               _asm

+               {

+                  movd       mm7, unmask       //load bit pattern

+                  psubb      mm6,mm6           //zero mm6

+                  punpcklbw  mm7,mm7

+                  punpcklwd  mm7,mm7

+                  punpckldq  mm7,mm7           //fill register with 8 masks

+                  movq       mm0,mask0

+                  movq       mm1,mask1

+                  pand       mm0,mm7

+                  pand       mm1,mm7

+                  pcmpeqb    mm0,mm6

+                  pcmpeqb    mm1,mm6

+                  mov        ecx,len           //load length of line

+                  mov        esi,srcptr        //load source

+                  mov        ebx,dstptr        //load dest

+                  cmp        ecx,0             //lcr

+                  jz         mainloop16end

+mainloop16:

+                  movq       mm4,[esi]

+                  pand       mm4,mm0

+                  movq       mm6,mm0

+                  movq       mm7,[ebx]

+                  pandn      mm6,mm7

+                  por        mm4,mm6

+                  movq       [ebx],mm4

+                  movq       mm5,[esi+8]

+                  pand       mm5,mm1

+                  movq       mm7,mm1

+                  movq       mm6,[ebx+8]

+                  pandn      mm7,mm6

+                  por        mm5,mm7

+                  movq       [ebx+8],mm5

+                  add        esi,16            //inc by 16 bytes processed

+                  add        ebx,16

+                  sub        ecx,8             //dec by 8 pixels processed

+                  ja         mainloop16

+mainloop16end:

+                  mov        ecx,diff

+                  cmp        ecx,0

+                  jz         end16

+                  mov        edx,mask

+                  sal        edx,24            //make low byte the high byte

+secondloop16:

+                  sal        edx,1             //move high bit to CF

+                  jnc        skip16            //if CF = 0

+                  mov        ax,[esi]

+                  mov        [ebx],ax

+skip16:

+                  add        esi,2

+                  add        ebx,2

+                  dec        ecx

+                  jnz        secondloop16

+end16:

+                  emms

+               }

+            }

+            else /* mmx not supported - use modified C routine */

+            {

+               register unsigned int incr1, initial_val, final_val;

+               png_size_t pixel_bytes;

+               png_uint_32 i;

+               register int disp = png_pass_inc[png_ptr->pass];

+               int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};

+               pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);

+               srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*

+                  pixel_bytes;

+               dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;

+               initial_val = offset_table[png_ptr->pass]*pixel_bytes;

+               final_val = png_ptr->width*pixel_bytes;

+               incr1 = (disp)*pixel_bytes;

+               for (i = initial_val; i < final_val; i += incr1)

+               {

+                  png_memcpy(dstptr, srcptr, pixel_bytes);

+                  srcptr += incr1;

+                  dstptr += incr1;

+               }

+            } /* end of else */

+            break;

+         }       // end 16 bpp

+         case 24:

+         {

+            png_bytep srcptr;

+            png_bytep dstptr;

+            png_uint_32 len;

+            int unmask, diff;

+            __int64 mask2=0x0101010202020404,  //24bpp

+                    mask1=0x0408080810101020,

+                    mask0=0x2020404040808080;

+            srcptr = png_ptr->row_buf + 1;

+            dstptr = row;

+            unmask = ~mask;

+            len     = (png_ptr->width)&~7;

+            diff = (png_ptr->width)&7;

+#if !defined(PNG_1_0_X)

+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)

+                /* && mmx_supported */ )

+#else

+            if (mmx_supported)

+#endif

+            {

+               _asm

+               {

+                  movd       mm7, unmask       //load bit pattern

+                  psubb      mm6,mm6           //zero mm6

+                  punpcklbw  mm7,mm7

+                  punpcklwd  mm7,mm7

+                  punpckldq  mm7,mm7           //fill register with 8 masks

+                  movq       mm0,mask0

+                  movq       mm1,mask1

+                  movq       mm2,mask2

+                  pand       mm0,mm7

+                  pand       mm1,mm7

+                  pand       mm2,mm7

+                  pcmpeqb    mm0,mm6

+                  pcmpeqb    mm1,mm6

+                  pcmpeqb    mm2,mm6

+                  mov        ecx,len           //load length of line

+                  mov        esi,srcptr        //load source

+                  mov        ebx,dstptr        //load dest

+                  cmp        ecx,0

+                  jz         mainloop24end

+mainloop24:

+                  movq       mm4,[esi]

+                  pand       mm4,mm0

+                  movq       mm6,mm0

+                  movq       mm7,[ebx]

+                  pandn      mm6,mm7

+                  por        mm4,mm6

+                  movq       [ebx],mm4

+                  movq       mm5,[esi+8]

+                  pand       mm5,mm1

+                  movq       mm7,mm1

+                  movq       mm6,[ebx+8]

+                  pandn      mm7,mm6

+                  por        mm5,mm7

+                  movq       [ebx+8],mm5

+                  movq       mm6,[esi+16]

+                  pand       mm6,mm2

+                  movq       mm4,mm2

+                  movq       mm7,[ebx+16]

+                  pandn      mm4,mm7

+                  por        mm6,mm4

+                  movq       [ebx+16],mm6

+                  add        esi,24            //inc by 24 bytes processed

+                  add        ebx,24

+                  sub        ecx,8             //dec by 8 pixels processed

+                  ja         mainloop24

+mainloop24end:

+                  mov        ecx,diff

+                  cmp        ecx,0

+                  jz         end24

+                  mov        edx,mask

+                  sal        edx,24            //make low byte the high byte

+secondloop24:

+                  sal        edx,1             //move high bit to CF

+                  jnc        skip24            //if CF = 0

+                  mov        ax,[esi]

+                  mov        [ebx],ax

+                  xor        eax,eax

+                  mov        al,[esi+2]

+                  mov        [ebx+2],al

+skip24:

+                  add        esi,3

+                  add        ebx,3

+                  dec        ecx

+                  jnz        secondloop24

+end24:

+                  emms

+               }

+            }

+            else /* mmx not supported - use modified C routine */

+            {

+               register unsigned int incr1, initial_val, final_val;

+               png_size_t pixel_bytes;

+               png_uint_32 i;

+               register int disp = png_pass_inc[png_ptr->pass];

+               int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};

+               pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);

+               srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*

+                  pixel_bytes;

+               dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;

+               initial_val = offset_table[png_ptr->pass]*pixel_bytes;

+               final_val = png_ptr->width*pixel_bytes;

+               incr1 = (disp)*pixel_bytes;

+               for (i = initial_val; i < final_val; i += incr1)

+               {

+                  png_memcpy(dstptr, srcptr, pixel_bytes);

+                  srcptr += incr1;

+                  dstptr += incr1;

+               }

+            } /* end of else */

+            break;

+         }       // end 24 bpp

+         case 32:

+         {

+            png_bytep srcptr;

+            png_bytep dstptr;

+            png_uint_32 len;

+            int unmask, diff;

+            __int64 mask3=0x0101010102020202,  //32bpp

+                    mask2=0x0404040408080808,

+                    mask1=0x1010101020202020,

+                    mask0=0x4040404080808080;

+            srcptr = png_ptr->row_buf + 1;

+            dstptr = row;

+            unmask = ~mask;

+            len     = (png_ptr->width)&~7;

+            diff = (png_ptr->width)&7;

+#if !defined(PNG_1_0_X)

+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)

+                /* && mmx_supported */ )

+#else

+            if (mmx_supported)

+#endif

+            {

+               _asm

+               {

+                  movd       mm7, unmask       //load bit pattern

+                  psubb      mm6,mm6           //zero mm6

+                  punpcklbw  mm7,mm7

+                  punpcklwd  mm7,mm7

+                  punpckldq  mm7,mm7           //fill register with 8 masks

+                  movq       mm0,mask0

+                  movq       mm1,mask1

+                  movq       mm2,mask2

+                  movq       mm3,mask3

+                  pand       mm0,mm7

+                  pand       mm1,mm7

+                  pand       mm2,mm7

+                  pand       mm3,mm7

+                  pcmpeqb    mm0,mm6

+                  pcmpeqb    mm1,mm6

+                  pcmpeqb    mm2,mm6

+                  pcmpeqb    mm3,mm6

+                  mov        ecx,len           //load length of line

+                  mov        esi,srcptr        //load source

+                  mov        ebx,dstptr        //load dest

+                  cmp        ecx,0             //lcr

+                  jz         mainloop32end

+mainloop32:

+                  movq       mm4,[esi]

+                  pand       mm4,mm0

+                  movq       mm6,mm0

+                  movq       mm7,[ebx]

+                  pandn      mm6,mm7

+                  por        mm4,mm6

+                  movq       [ebx],mm4

+                  movq       mm5,[esi+8]

+                  pand       mm5,mm1

+                  movq       mm7,mm1

+                  movq       mm6,[ebx+8]

+                  pandn      mm7,mm6

+                  por        mm5,mm7

+                  movq       [ebx+8],mm5

+                  movq       mm6,[esi+16]

+                  pand       mm6,mm2

+                  movq       mm4,mm2

+                  movq       mm7,[ebx+16]

+                  pandn      mm4,mm7

+                  por        mm6,mm4

+                  movq       [ebx+16],mm6

+                  movq       mm7,[esi+24]

+                  pand       mm7,mm3

+                  movq       mm5,mm3

+                  movq       mm4,[ebx+24]

+                  pandn      mm5,mm4

+                  por        mm7,mm5

+                  movq       [ebx+24],mm7

+                  add        esi,32            //inc by 32 bytes processed

+                  add        ebx,32

+                  sub        ecx,8             //dec by 8 pixels processed

+                  ja         mainloop32

+mainloop32end:

+                  mov        ecx,diff

+                  cmp        ecx,0

+                  jz         end32

+                  mov        edx,mask

+                  sal        edx,24            //make low byte the high byte

+secondloop32:

+                  sal        edx,1             //move high bit to CF

+                  jnc        skip32            //if CF = 0

+                  mov        eax,[esi]

+                  mov        [ebx],eax

+skip32:

+                  add        esi,4

+                  add        ebx,4

+                  dec        ecx

+                  jnz        secondloop32

+end32:

+                  emms

+               }

+            }

+            else /* mmx _not supported - Use modified C routine */

+            {

+               register unsigned int incr1, initial_val, final_val;

+               png_size_t pixel_bytes;

+               png_uint_32 i;

+               register int disp = png_pass_inc[png_ptr->pass];

+               int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};

+               pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);

+               srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*

+                  pixel_bytes;

+               dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;

+               initial_val = offset_table[png_ptr->pass]*pixel_bytes;

+               final_val = png_ptr->width*pixel_bytes;

+               incr1 = (disp)*pixel_bytes;

+               for (i = initial_val; i < final_val; i += incr1)

+               {

+                  png_memcpy(dstptr, srcptr, pixel_bytes);

+                  srcptr += incr1;

+                  dstptr += incr1;

+               }

+            } /* end of else */

+            break;

+         }       // end 32 bpp

+         case 48:

+         {

+            png_bytep srcptr;

+            png_bytep dstptr;

+            png_uint_32 len;

+            int unmask, diff;

+            __int64 mask5=0x0101010101010202,

+                    mask4=0x0202020204040404,

+                    mask3=0x0404080808080808,

+                    mask2=0x1010101010102020,

+                    mask1=0x2020202040404040,

+                    mask0=0x4040808080808080;

+#if !defined(PNG_1_0_X)

+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)

+                /* && mmx_supported */ )

+#else

+            if (mmx_supported)

+#endif

+            {

+               srcptr = png_ptr->row_buf + 1;

+               dstptr = row;

+               unmask = ~mask;

+               len     = (png_ptr->width)&~7;

+               diff = (png_ptr->width)&7;

+               _asm

+               {

+                  movd       mm7, unmask       //load bit pattern

+                  psubb      mm6,mm6           //zero mm6

+                  punpcklbw  mm7,mm7

+                  punpcklwd  mm7,mm7

+                  punpckldq  mm7,mm7           //fill register with 8 masks

+                  movq       mm0,mask0

+                  movq       mm1,mask1

+                  movq       mm2,mask2

+                  movq       mm3,mask3

+                  movq       mm4,mask4

+                  movq       mm5,mask5

+                  pand       mm0,mm7

+                  pand       mm1,mm7

+                  pand       mm2,mm7

+                  pand       mm3,mm7

+                  pand       mm4,mm7

+                  pand       mm5,mm7

+                  pcmpeqb    mm0,mm6

+                  pcmpeqb    mm1,mm6

+                  pcmpeqb    mm2,mm6

+                  pcmpeqb    mm3,mm6

+                  pcmpeqb    mm4,mm6

+                  pcmpeqb    mm5,mm6

+                  mov        ecx,len           //load length of line

+                  mov        esi,srcptr        //load source

+                  mov        ebx,dstptr        //load dest

+                  cmp        ecx,0

+                  jz         mainloop48end

+mainloop48:

+                  movq       mm7,[esi]

+                  pand       mm7,mm0

+                  movq       mm6,mm0

+                  pandn      mm6,[ebx]

+                  por        mm7,mm6

+                  movq       [ebx],mm7

+                  movq       mm6,[esi+8]

+                  pand       mm6,mm1

+                  movq       mm7,mm1

+                  pandn      mm7,[ebx+8]

+                  por        mm6,mm7

+                  movq       [ebx+8],mm6

+                  movq       mm6,[esi+16]

+                  pand       mm6,mm2

+                  movq       mm7,mm2

+                  pandn      mm7,[ebx+16]

+                  por        mm6,mm7

+                  movq       [ebx+16],mm6

+                  movq       mm7,[esi+24]

+                  pand       mm7,mm3

+                  movq       mm6,mm3

+                  pandn      mm6,[ebx+24]

+                  por        mm7,mm6

+                  movq       [ebx+24],mm7

+                  movq       mm6,[esi+32]

+                  pand       mm6,mm4

+                  movq       mm7,mm4

+                  pandn      mm7,[ebx+32]

+                  por        mm6,mm7

+                  movq       [ebx+32],mm6

+                  movq       mm7,[esi+40]

+                  pand       mm7,mm5

+                  movq       mm6,mm5

+                  pandn      mm6,[ebx+40]

+                  por        mm7,mm6

+                  movq       [ebx+40],mm7

+                  add        esi,48            //inc by 32 bytes processed

+                  add        ebx,48

+                  sub        ecx,8             //dec by 8 pixels processed

+                  ja         mainloop48

+mainloop48end:

+                  mov        ecx,diff

+                  cmp        ecx,0

+                  jz         end48

+                  mov        edx,mask

+                  sal        edx,24            //make low byte the high byte

+secondloop48:

+                  sal        edx,1             //move high bit to CF

+                  jnc        skip48            //if CF = 0

+                  mov        eax,[esi]

+                  mov        [ebx],eax

+skip48:

+                  add        esi,4

+                  add        ebx,4

+                  dec        ecx

+                  jnz        secondloop48

+end48:

+                  emms

+               }

+            }

+            else /* mmx _not supported - Use modified C routine */

+            {

+               register unsigned int incr1, initial_val, final_val;

+               png_size_t pixel_bytes;

+               png_uint_32 i;

+               register int disp = png_pass_inc[png_ptr->pass];

+               int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};

+               pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);

+               srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*

+                  pixel_bytes;

+               dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;

+               initial_val = offset_table[png_ptr->pass]*pixel_bytes;

+               final_val = png_ptr->width*pixel_bytes;

+               incr1 = (disp)*pixel_bytes;

+               for (i = initial_val; i < final_val; i += incr1)

+               {

+                  png_memcpy(dstptr, srcptr, pixel_bytes);

+                  srcptr += incr1;

+                  dstptr += incr1;

+               }

+            } /* end of else */

+            break;

+         }       // end 48 bpp

+         default:

+         {

+            png_bytep sptr;

+            png_bytep dp;

+            png_size_t pixel_bytes;

+            int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};

+            unsigned int i;

+            register int disp = png_pass_inc[png_ptr->pass];  // get the offset

+            register unsigned int incr1, initial_val, final_val;

+            pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);

+            sptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*

+               pixel_bytes;

+            dp = row + offset_table[png_ptr->pass]*pixel_bytes;

+            initial_val = offset_table[png_ptr->pass]*pixel_bytes;

+            final_val = png_ptr->width*pixel_bytes;

+            incr1 = (disp)*pixel_bytes;

+            for (i = initial_val; i < final_val; i += incr1)

+            {

+               png_memcpy(dp, sptr, pixel_bytes);

+               sptr += incr1;

+               dp += incr1;

+            }

+            break;

+         }

+      } /* end switch (png_ptr->row_info.pixel_depth) */

+   } /* end if (non-trivial mask) */

+} /* end png_combine_row() */

+#if defined(PNG_READ_INTERLACING_SUPPORTED)

+void /* PRIVATE */

+png_do_read_interlace(png_structp png_ptr)

+{

+   png_row_infop row_info = &(png_ptr->row_info);

+   png_bytep row = png_ptr->row_buf + 1;

+   int pass = png_ptr->pass;

+   png_uint_32 transformations = png_ptr->transformations;

+#ifdef PNG_USE_LOCAL_ARRAYS

+   const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

+#endif

+   png_debug(1,"in png_do_read_interlace\n");

+   if (mmx_supported == 2) {

+#if !defined(PNG_1_0_X)

+       /* this should have happened in png_init_mmx_flags() already */

+       png_warning(png_ptr, "asm_flags may not have been initialized");

+#endif

+       png_mmx_support();

+   }

+   if (row != NULL && row_info != NULL)

+   {

+      png_uint_32 final_width;

+      final_width = row_info->width * png_pass_inc[pass];

+      switch (row_info->pixel_depth)

+      {

+         case 1:

+         {

+            png_bytep sp, dp;

+            int sshift, dshift;

+            int s_start, s_end, s_inc;

+            png_byte v;

+            png_uint_32 i;

+            int j;

+            sp = row + (png_size_t)((row_info->width - 1) >> 3);

+            dp = row + (png_size_t)((final_width - 1) >> 3);

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+            if (transformations & PNG_PACKSWAP)

+            {

+               sshift = (int)((row_info->width + 7) & 7);

+               dshift = (int)((final_width + 7) & 7);

+               s_start = 7;

+               s_end = 0;

+               s_inc = -1;

+            }

+            else

+#endif

+            {

+               sshift = 7 - (int)((row_info->width + 7) & 7);

+               dshift = 7 - (int)((final_width + 7) & 7);

+               s_start = 0;

+               s_end = 7;

+               s_inc = 1;

+            }

+            for (i = row_info->width; i; i--)

+            {

+               v = (png_byte)((*sp >> sshift) & 0x1);

+               for (j = 0; j < png_pass_inc[pass]; j++)

+               {

+                  *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff);

+                  *dp |= (png_byte)(v << dshift);

+                  if (dshift == s_end)

+                  {

+                     dshift = s_start;

+                     dp--;

+                  }

+                  else

+                     dshift += s_inc;

+               }

+               if (sshift == s_end)

+               {

+                  sshift = s_start;

+                  sp--;

+               }

+               else

+                  sshift += s_inc;

+            }

+            break;

+         }

+         case 2:

+         {

+            png_bytep sp, dp;

+            int sshift, dshift;

+            int s_start, s_end, s_inc;

+            png_uint_32 i;

+            sp = row + (png_size_t)((row_info->width - 1) >> 2);

+            dp = row + (png_size_t)((final_width - 1) >> 2);

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+            if (transformations & PNG_PACKSWAP)

+            {

+               sshift = (png_size_t)(((row_info->width + 3) & 3) << 1);

+               dshift = (png_size_t)(((final_width + 3) & 3) << 1);

+               s_start = 6;

+               s_end = 0;

+               s_inc = -2;

+            }

+            else

+#endif

+            {

+               sshift = (png_size_t)((3 - ((row_info->width + 3) & 3)) << 1);

+               dshift = (png_size_t)((3 - ((final_width + 3) & 3)) << 1);

+               s_start = 0;

+               s_end = 6;

+               s_inc = 2;

+            }

+            for (i = row_info->width; i; i--)

+            {

+               png_byte v;

+               int j;

+               v = (png_byte)((*sp >> sshift) & 0x3);

+               for (j = 0; j < png_pass_inc[pass]; j++)

+               {

+                  *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff);

+                  *dp |= (png_byte)(v << dshift);

+                  if (dshift == s_end)

+                  {

+                     dshift = s_start;

+                     dp--;

+                  }

+                  else

+                     dshift += s_inc;

+               }

+               if (sshift == s_end)

+               {

+                  sshift = s_start;

+                  sp--;

+               }

+               else

+                  sshift += s_inc;

+            }

+            break;

+         }

+         case 4:

+         {

+            png_bytep sp, dp;

+            int sshift, dshift;

+            int s_start, s_end, s_inc;

+            png_uint_32 i;

+            sp = row + (png_size_t)((row_info->width - 1) >> 1);

+            dp = row + (png_size_t)((final_width - 1) >> 1);

+#if defined(PNG_READ_PACKSWAP_SUPPORTED)

+            if (transformations & PNG_PACKSWAP)

+            {

+               sshift = (png_size_t)(((row_info->width + 1) & 1) << 2);

+               dshift = (png_size_t)(((final_width + 1) & 1) << 2);

+               s_start = 4;

+               s_end = 0;

+               s_inc = -4;

+            }

+            else

+#endif

+            {

+               sshift = (png_size_t)((1 - ((row_info->width + 1) & 1)) << 2);

+               dshift = (png_size_t)((1 - ((final_width + 1) & 1)) << 2);

+               s_start = 0;

+               s_end = 4;

+               s_inc = 4;

+            }

+            for (i = row_info->width; i; i--)

+            {

+               png_byte v;

+               int j;

+               v = (png_byte)((*sp >> sshift) & 0xf);

+               for (j = 0; j < png_pass_inc[pass]; j++)

+               {

+                  *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff);

+                  *dp |= (png_byte)(v << dshift);

+                  if (dshift == s_end)

+                  {

+                     dshift = s_start;

+                     dp--;

+                  }

+                  else

+                     dshift += s_inc;

+               }

+               if (sshift == s_end)

+               {

+                  sshift = s_start;

+                  sp--;

+               }

+               else

+                  sshift += s_inc;

+            }

+            break;

+         }

+         default:         // This is the place where the routine is modified

+         {

+            __int64 const4 = 0x0000000000FFFFFF;

+            // __int64 const5 = 0x000000FFFFFF0000;  // unused...

+            __int64 const6 = 0x00000000000000FF;

+            png_bytep sptr, dp;

+            png_uint_32 i;

+            png_size_t pixel_bytes;

+            int width = row_info->width;

+            pixel_bytes = (row_info->pixel_depth >> 3);

+            sptr = row + (width - 1) * pixel_bytes;

+            dp = row + (final_width - 1) * pixel_bytes;

+            // New code by Nirav Chhatrapati - Intel Corporation

+            // sign fix by GRR

+            // NOTE:  there is NO MMX code for 48-bit and 64-bit images

+            // use MMX routine if machine supports it

+#if !defined(PNG_1_0_X)

+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_INTERLACE)

+                /* && mmx_supported */ )

+#else

+            if (mmx_supported)

+#endif

+            {

+               if (pixel_bytes == 3)

+               {

+                  if (((pass == 0) || (pass == 1)) && width)

+                  {

+                     _asm

+                     {

+                        mov esi, sptr

+                        mov edi, dp

+                        mov ecx, width

+                        sub edi, 21   // (png_pass_inc[pass] - 1)*pixel_bytes

+loop_pass0:

+                        movd mm0, [esi]     ; X X X X X v2 v1 v0

+                        pand mm0, const4    ; 0 0 0 0 0 v2 v1 v0

+                        movq mm1, mm0       ; 0 0 0 0 0 v2 v1 v0

+                        psllq mm0, 16       ; 0 0 0 v2 v1 v0 0 0

+                        movq mm2, mm0       ; 0 0 0 v2 v1 v0 0 0

+                        psllq mm0, 24       ; v2 v1 v0 0 0 0 0 0

+                        psrlq mm1, 8        ; 0 0 0 0 0 0 v2 v1

+                        por mm0, mm2        ; v2 v1 v0 v2 v1 v0 0 0

+                        por mm0, mm1        ; v2 v1 v0 v2 v1 v0 v2 v1

+                        movq mm3, mm0       ; v2 v1 v0 v2 v1 v0 v2 v1

+                        psllq mm0, 16       ; v0 v2 v1 v0 v2 v1 0 0

+                        movq mm4, mm3       ; v2 v1 v0 v2 v1 v0 v2 v1

+                        punpckhdq mm3, mm0  ; v0 v2 v1 v0 v2 v1 v0 v2

+                        movq [edi+16] , mm4

+                        psrlq mm0, 32       ; 0 0 0 0 v0 v2 v1 v0

+                        movq [edi+8] , mm3

+                        punpckldq mm0, mm4  ; v1 v0 v2 v1 v0 v2 v1 v0

+                        sub esi, 3

+                        movq [edi], mm0

+                        sub edi, 24

+                        //sub esi, 3

+                        dec ecx

+                        jnz loop_pass0

+                        EMMS

+                     }

+                  }

+                  else if (((pass == 2) || (pass == 3)) && width)

+                  {

+                     _asm

+                     {

+                        mov esi, sptr

+                        mov edi, dp

+                        mov ecx, width

+                        sub edi, 9   // (png_pass_inc[pass] - 1)*pixel_bytes

+loop_pass2:

+                        movd mm0, [esi]     ; X X X X X v2 v1 v0

+                        pand mm0, const4    ; 0 0 0 0 0 v2 v1 v0

+                        movq mm1, mm0       ; 0 0 0 0 0 v2 v1 v0

+                        psllq mm0, 16       ; 0 0 0 v2 v1 v0 0 0

+                        movq mm2, mm0       ; 0 0 0 v2 v1 v0 0 0

+                        psllq mm0, 24       ; v2 v1 v0 0 0 0 0 0

+                        psrlq mm1, 8        ; 0 0 0 0 0 0 v2 v1

+                        por mm0, mm2        ; v2 v1 v0 v2 v1 v0 0 0

+                        por mm0, mm1        ; v2 v1 v0 v2 v1 v0 v2 v1

+                        movq [edi+4], mm0   ; move to memory

+                        psrlq mm0, 16       ; 0 0 v2 v1 v0 v2 v1 v0

+                        movd [edi], mm0     ; move to memory

+                        sub esi, 3

+                        sub edi, 12

+                        dec ecx

+                        jnz loop_pass2

+                        EMMS

+                     }

+                  }

+                  else if (width) /* && ((pass == 4) || (pass == 5)) */

+                  {

+                     int width_mmx = ((width >> 1) << 1) - 8;

+                     if (width_mmx < 0)

+                         width_mmx = 0;

+                     width -= width_mmx;        // 8 or 9 pix, 24 or 27 bytes

+                     if (width_mmx)

+                     {

+                        _asm

+                        {

+                           mov esi, sptr

+                           mov edi, dp

+                           mov ecx, width_mmx

+                           sub esi, 3

+                           sub edi, 9

+loop_pass4:

+                           movq mm0, [esi]     ; X X v2 v1 v0 v5 v4 v3

+                           movq mm7, mm0       ; X X v2 v1 v0 v5 v4 v3

+                           movq mm6, mm0       ; X X v2 v1 v0 v5 v4 v3

+                           psllq mm0, 24       ; v1 v0 v5 v4 v3 0 0 0

+                           pand mm7, const4    ; 0 0 0 0 0 v5 v4 v3

+                           psrlq mm6, 24       ; 0 0 0 X X v2 v1 v0

+                           por mm0, mm7        ; v1 v0 v5 v4 v3 v5 v4 v3

+                           movq mm5, mm6       ; 0 0 0 X X v2 v1 v0

+                           psllq mm6, 8        ; 0 0 X X v2 v1 v0 0

+                           movq [edi], mm0     ; move quad to memory

+                           psrlq mm5, 16       ; 0 0 0 0 0 X X v2

+                           pand mm5, const6    ; 0 0 0 0 0 0 0 v2

+                           por mm6, mm5        ; 0 0 X X v2 v1 v0 v2

+                           movd [edi+8], mm6   ; move double to memory

+                           sub esi, 6

+                           sub edi, 12

+                           sub ecx, 2

+                           jnz loop_pass4

+                           EMMS

+                        }

+                     }

+                     sptr -= width_mmx*3;

+                     dp -= width_mmx*6;

+                     for (i = width; i; i--)

+                     {

+                        png_byte v[8];

+                        int j;

+                        png_memcpy(v, sptr, 3);

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                        {

+                           png_memcpy(dp, v, 3);

+                           dp -= 3;

+                        }

+                        sptr -= 3;

+                     }

+                  }

+               } /* end of pixel_bytes == 3 */

+               else if (pixel_bytes == 1)

+               {

+                  if (((pass == 0) || (pass == 1)) && width)

+                  {

+                     int width_mmx = ((width >> 2) << 2);

+                     width -= width_mmx;

+                     if (width_mmx)

+                     {

+                        _asm

+                        {

+                           mov esi, sptr

+                           mov edi, dp

+                           mov ecx, width_mmx

+                           sub edi, 31

+                           sub esi, 3

+loop1_pass0:

+                           movd mm0, [esi]     ; X X X X v0 v1 v2 v3

+                           movq mm1, mm0       ; X X X X v0 v1 v2 v3

+                           punpcklbw mm0, mm0  ; v0 v0 v1 v1 v2 v2 v3 v3

+                           movq mm2, mm0       ; v0 v0 v1 v1 v2 v2 v3 v3

+                           punpcklwd mm0, mm0  ; v2 v2 v2 v2 v3 v3 v3 v3

+                           movq mm3, mm0       ; v2 v2 v2 v2 v3 v3 v3 v3

+                           punpckldq mm0, mm0  ; v3 v3 v3 v3 v3 v3 v3 v3

+                           punpckhdq mm3, mm3  ; v2 v2 v2 v2 v2 v2 v2 v2

+                           movq [edi], mm0     ; move to memory v3

+                           punpckhwd mm2, mm2  ; v0 v0 v0 v0 v1 v1 v1 v1

+                           movq [edi+8], mm3   ; move to memory v2

+                           movq mm4, mm2       ; v0 v0 v0 v0 v1 v1 v1 v1

+                           punpckldq mm2, mm2  ; v1 v1 v1 v1 v1 v1 v1 v1

+                           punpckhdq mm4, mm4  ; v0 v0 v0 v0 v0 v0 v0 v0

+                           movq [edi+16], mm2  ; move to memory v1

+                           movq [edi+24], mm4  ; move to memory v0

+                           sub esi, 4

+                           sub edi, 32

+                           sub ecx, 4

+                           jnz loop1_pass0

+                           EMMS

+                        }

+                     }

+                     sptr -= width_mmx;

+                     dp -= width_mmx*8;

+                     for (i = width; i; i--)

+                     {

+                        int j;

+                       /* I simplified this part in version 1.0.4e

+                        * here and in several other instances where

+                        * pixel_bytes == 1  -- GR-P

+                        *

+                        * Original code:

+                        *

+                        * png_byte v[8];

+                        * png_memcpy(v, sptr, pixel_bytes);

+                        * for (j = 0; j < png_pass_inc[pass]; j++)

+                        * {

+                        *    png_memcpy(dp, v, pixel_bytes);

+                        *    dp -= pixel_bytes;

+                        * }

+                        * sptr -= pixel_bytes;

+                        *

+                        * Replacement code is in the next three lines:

+                        */

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                           *dp-- = *sptr;

+                        sptr--;

+                     }

+                  }

+                  else if (((pass == 2) || (pass == 3)) && width)

+                  {

+                     int width_mmx = ((width >> 2) << 2);

+                     width -= width_mmx;

+                     if (width_mmx)

+                     {

+                        _asm

+                        {

+                           mov esi, sptr

+                           mov edi, dp

+                           mov ecx, width_mmx

+                           sub edi, 15

+                           sub esi, 3

+loop1_pass2:

+                           movd mm0, [esi]     ; X X X X v0 v1 v2 v3

+                           punpcklbw mm0, mm0  ; v0 v0 v1 v1 v2 v2 v3 v3

+                           movq mm1, mm0       ; v0 v0 v1 v1 v2 v2 v3 v3

+                           punpcklwd mm0, mm0  ; v2 v2 v2 v2 v3 v3 v3 v3

+                           punpckhwd mm1, mm1  ; v0 v0 v0 v0 v1 v1 v1 v1

+                           movq [edi], mm0     ; move to memory v2 and v3

+                           sub esi, 4

+                           movq [edi+8], mm1   ; move to memory v1     and v0

+                           sub edi, 16

+                           sub ecx, 4

+                           jnz loop1_pass2

+                           EMMS

+                        }

+                     }

+                     sptr -= width_mmx;

+                     dp -= width_mmx*4;

+                     for (i = width; i; i--)

+                     {

+                        int j;

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                        {

+                           *dp-- = *sptr;

+                        }

+                        sptr --;

+                     }

+                  }

+                  else if (width) /* && ((pass == 4) || (pass == 5))) */

+                  {

+                     int width_mmx = ((width >> 3) << 3);

+                     width -= width_mmx;

+                     if (width_mmx)

+                     {

+                        _asm

+                        {

+                           mov esi, sptr

+                           mov edi, dp

+                           mov ecx, width_mmx

+                           sub edi, 15

+                           sub esi, 7

+loop1_pass4:

+                           movq mm0, [esi]     ; v0 v1 v2 v3 v4 v5 v6 v7

+                           movq mm1, mm0       ; v0 v1 v2 v3 v4 v5 v6 v7

+                           punpcklbw mm0, mm0  ; v4 v4 v5 v5 v6 v6 v7 v7

+                           //movq mm1, mm0     ; v0 v0 v1 v1 v2 v2 v3 v3

+                           punpckhbw mm1, mm1  ;v0 v0 v1 v1 v2 v2 v3 v3

+                           movq [edi+8], mm1   ; move to memory v0 v1 v2 and v3

+                           sub esi, 8

+                           movq [edi], mm0     ; move to memory v4 v5 v6 and v7

+                           //sub esi, 4

+                           sub edi, 16

+                           sub ecx, 8

+                           jnz loop1_pass4

+                           EMMS

+                        }

+                     }

+                     sptr -= width_mmx;

+                     dp -= width_mmx*2;

+                     for (i = width; i; i--)

+                     {

+                        int j;

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                        {

+                           *dp-- = *sptr;

+                        }

+                        sptr --;

+                     }

+                  }

+               } /* end of pixel_bytes == 1 */

+               else if (pixel_bytes == 2)

+               {

+                  if (((pass == 0) || (pass == 1)) && width)

+                  {

+                     int width_mmx = ((width >> 1) << 1);

+                     width -= width_mmx;

+                     if (width_mmx)

+                     {

+                        _asm

+                        {

+                           mov esi, sptr

+                           mov edi, dp

+                           mov ecx, width_mmx

+                           sub esi, 2

+                           sub edi, 30

+loop2_pass0:

+                           movd mm0, [esi]        ; X X X X v1 v0 v3 v2

+                           punpcklwd mm0, mm0     ; v1 v0 v1 v0 v3 v2 v3 v2

+                           movq mm1, mm0          ; v1 v0 v1 v0 v3 v2 v3 v2

+                           punpckldq mm0, mm0     ; v3 v2 v3 v2 v3 v2 v3 v2

+                           punpckhdq mm1, mm1     ; v1 v0 v1 v0 v1 v0 v1 v0

+                           movq [edi], mm0

+                           movq [edi + 8], mm0

+                           movq [edi + 16], mm1

+                           movq [edi + 24], mm1

+                           sub esi, 4

+                           sub edi, 32

+                           sub ecx, 2

+                           jnz loop2_pass0

+                           EMMS

+                        }

+                     }

+                     sptr -= (width_mmx*2 - 2);            // sign fixed

+                     dp -= (width_mmx*16 - 2);            // sign fixed

+                     for (i = width; i; i--)

+                     {

+                        png_byte v[8];

+                        int j;

+                        sptr -= 2;

+                        png_memcpy(v, sptr, 2);

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                        {

+                           dp -= 2;

+                           png_memcpy(dp, v, 2);

+                        }

+                     }

+                  }

+                  else if (((pass == 2) || (pass == 3)) && width)

+                  {

+                     int width_mmx = ((width >> 1) << 1) ;

+                     width -= width_mmx;

+                     if (width_mmx)

+                     {

+                        _asm

+                        {

+                           mov esi, sptr

+                           mov edi, dp

+                           mov ecx, width_mmx

+                           sub esi, 2

+                           sub edi, 14

+loop2_pass2:

+                           movd mm0, [esi]        ; X X X X v1 v0 v3 v2

+                           punpcklwd mm0, mm0     ; v1 v0 v1 v0 v3 v2 v3 v2

+                           movq mm1, mm0          ; v1 v0 v1 v0 v3 v2 v3 v2

+                           punpckldq mm0, mm0     ; v3 v2 v3 v2 v3 v2 v3 v2

+                           punpckhdq mm1, mm1     ; v1 v0 v1 v0 v1 v0 v1 v0

+                           movq [edi], mm0

+                           sub esi, 4

+                           movq [edi + 8], mm1

+                           //sub esi, 4

+                           sub edi, 16

+                           sub ecx, 2

+                           jnz loop2_pass2

+                           EMMS

+                        }

+                     }

+                     sptr -= (width_mmx*2 - 2);            // sign fixed

+                     dp -= (width_mmx*8 - 2);            // sign fixed

+                     for (i = width; i; i--)

+                     {

+                        png_byte v[8];

+                        int j;

+                        sptr -= 2;

+                        png_memcpy(v, sptr, 2);

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                        {

+                           dp -= 2;

+                           png_memcpy(dp, v, 2);

+                        }

+                     }

+                  }

+                  else if (width)  // pass == 4 or 5

+                  {

+                     int width_mmx = ((width >> 1) << 1) ;

+                     width -= width_mmx;

+                     if (width_mmx)

+                     {

+                        _asm

+                        {

+                           mov esi, sptr

+                           mov edi, dp

+                           mov ecx, width_mmx

+                           sub esi, 2

+                           sub edi, 6

+loop2_pass4:

+                           movd mm0, [esi]        ; X X X X v1 v0 v3 v2

+                           punpcklwd mm0, mm0     ; v1 v0 v1 v0 v3 v2 v3 v2

+                           sub esi, 4

+                           movq [edi], mm0

+                           sub edi, 8

+                           sub ecx, 2

+                           jnz loop2_pass4

+                           EMMS

+                        }

+                     }

+                     sptr -= (width_mmx*2 - 2);            // sign fixed

+                     dp -= (width_mmx*4 - 2);            // sign fixed

+                     for (i = width; i; i--)

+                     {

+                        png_byte v[8];

+                        int j;

+                        sptr -= 2;

+                        png_memcpy(v, sptr, 2);

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                        {

+                           dp -= 2;

+                           png_memcpy(dp, v, 2);

+                        }

+                     }

+                  }

+               } /* end of pixel_bytes == 2 */

+               else if (pixel_bytes == 4)

+               {

+                  if (((pass == 0) || (pass == 1)) && width)

+                  {

+                     int width_mmx = ((width >> 1) << 1) ;

+                     width -= width_mmx;

+                     if (width_mmx)

+                     {

+                        _asm

+                        {

+                           mov esi, sptr

+                           mov edi, dp

+                           mov ecx, width_mmx

+                           sub esi, 4

+                           sub edi, 60

+loop4_pass0:

+                           movq mm0, [esi]        ; v3 v2 v1 v0 v7 v6 v5 v4

+                           movq mm1, mm0          ; v3 v2 v1 v0 v7 v6 v5 v4

+                           punpckldq mm0, mm0     ; v7 v6 v5 v4 v7 v6 v5 v4

+                           punpckhdq mm1, mm1     ; v3 v2 v1 v0 v3 v2 v1 v0

+                           movq [edi], mm0

+                           movq [edi + 8], mm0

+                           movq [edi + 16], mm0

+                           movq [edi + 24], mm0

+                           movq [edi+32], mm1

+                           movq [edi + 40], mm1

+                           movq [edi+ 48], mm1

+                           sub esi, 8

+                           movq [edi + 56], mm1

+                           sub edi, 64

+                           sub ecx, 2

+                           jnz loop4_pass0

+                           EMMS

+                        }

+                     }

+                     sptr -= (width_mmx*4 - 4);            // sign fixed

+                     dp -= (width_mmx*32 - 4);            // sign fixed

+                     for (i = width; i; i--)

+                     {

+                        png_byte v[8];

+                        int j;

+                        sptr -= 4;

+                        png_memcpy(v, sptr, 4);

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                        {

+                           dp -= 4;

+                           png_memcpy(dp, v, 4);

+                        }

+                     }

+                  }

+                  else if (((pass == 2) || (pass == 3)) && width)

+                  {

+                     int width_mmx = ((width >> 1) << 1) ;

+                     width -= width_mmx;

+                     if (width_mmx)

+                     {

+                        _asm

+                        {

+                           mov esi, sptr

+                           mov edi, dp

+                           mov ecx, width_mmx

+                           sub esi, 4

+                           sub edi, 28

+loop4_pass2:

+                           movq mm0, [esi]      ; v3 v2 v1 v0 v7 v6 v5 v4

+                           movq mm1, mm0        ; v3 v2 v1 v0 v7 v6 v5 v4

+                           punpckldq mm0, mm0   ; v7 v6 v5 v4 v7 v6 v5 v4

+                           punpckhdq mm1, mm1   ; v3 v2 v1 v0 v3 v2 v1 v0

+                           movq [edi], mm0

+                           movq [edi + 8], mm0

+                           movq [edi+16], mm1

+                           movq [edi + 24], mm1

+                           sub esi, 8

+                           sub edi, 32

+                           sub ecx, 2

+                           jnz loop4_pass2

+                           EMMS

+                        }

+                     }

+                     sptr -= (width_mmx*4 - 4);            // sign fixed

+                     dp -= (width_mmx*16 - 4);            // sign fixed

+                     for (i = width; i; i--)

+                     {

+                        png_byte v[8];

+                        int j;

+                        sptr -= 4;

+                        png_memcpy(v, sptr, 4);

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                        {

+                           dp -= 4;

+                           png_memcpy(dp, v, 4);

+                        }

+                     }

+                  }

+                  else if (width)  // pass == 4 or 5

+                  {

+                     int width_mmx = ((width >> 1) << 1) ;

+                     width -= width_mmx;

+                     if (width_mmx)

+                     {

+                        _asm

+                        {

+                           mov esi, sptr

+                           mov edi, dp

+                           mov ecx, width_mmx

+                           sub esi, 4

+                           sub edi, 12

+loop4_pass4:

+                           movq mm0, [esi]      ; v3 v2 v1 v0 v7 v6 v5 v4

+                           movq mm1, mm0        ; v3 v2 v1 v0 v7 v6 v5 v4

+                           punpckldq mm0, mm0   ; v7 v6 v5 v4 v7 v6 v5 v4

+                           punpckhdq mm1, mm1   ; v3 v2 v1 v0 v3 v2 v1 v0

+                           movq [edi], mm0

+                           sub esi, 8

+                           movq [edi + 8], mm1

+                           sub edi, 16

+                           sub ecx, 2

+                           jnz loop4_pass4

+                           EMMS

+                        }

+                     }

+                     sptr -= (width_mmx*4 - 4);          // sign fixed

+                     dp -= (width_mmx*8 - 4);            // sign fixed

+                     for (i = width; i; i--)

+                     {

+                        png_byte v[8];

+                        int j;

+                        sptr -= 4;

+                        png_memcpy(v, sptr, 4);

+                        for (j = 0; j < png_pass_inc[pass]; j++)

+                        {

+                           dp -= 4;

+                           png_memcpy(dp, v, 4);

+                        }

+                     }

+                  }

+               } /* end of pixel_bytes == 4 */

+               else if (pixel_bytes == 6)

+               {

+                  for (i = width; i; i--)

+                  {

+                     png_byte v[8];

+                     int j;

+                     png_memcpy(v, sptr, 6);

+                     for (j = 0; j < png_pass_inc[pass]; j++)

+                     {

+                        png_memcpy(dp, v, 6);

+                        dp -= 6;

+                     }

+                     sptr -= 6;

+                  }

+               } /* end of pixel_bytes == 6 */

+               else

+               {

+                  for (i = width; i; i--)

+                  {

+                     png_byte v[8];

+                     int j;

+                     png_memcpy(v, sptr, pixel_bytes);

+                     for (j = 0; j < png_pass_inc[pass]; j++)

+                     {

+                        png_memcpy(dp, v, pixel_bytes);

+                        dp -= pixel_bytes;

+                     }

+                     sptr-= pixel_bytes;

+                  }

+               }

+            } /* end of mmx_supported */

+            else /* MMX not supported:  use modified C code - takes advantage

+                  * of inlining of memcpy for a constant */

+            {

+               if (pixel_bytes == 1)

+               {

+                  for (i = width; i; i--)

+                  {

+                     int j;

+                     for (j = 0; j < png_pass_inc[pass]; j++)

+                        *dp-- = *sptr;

+                     sptr--;

+                  }

+               }

+               else if (pixel_bytes == 3)

+               {

+                  for (i = width; i; i--)

+                  {

+                     png_byte v[8];

+                     int j;

+                     png_memcpy(v, sptr, pixel_bytes);

+                     for (j = 0; j < png_pass_inc[pass]; j++)

+                     {

+                        png_memcpy(dp, v, pixel_bytes);

+                        dp -= pixel_bytes;

+                     }

+                     sptr -= pixel_bytes;

+                  }

+               }

+               else if (pixel_bytes == 2)

+               {

+                  for (i = width; i; i--)

+                  {

+                     png_byte v[8];

+                     int j;

+                     png_memcpy(v, sptr, pixel_bytes);

+                     for (j = 0; j < png_pass_inc[pass]; j++)

+                     {

+                        png_memcpy(dp, v, pixel_bytes);

+                        dp -= pixel_bytes;

+                     }

+                     sptr -= pixel_bytes;

+                  }

+               }

+               else if (pixel_bytes == 4)

+               {

+                  for (i = width; i; i--)

+                  {

+                     png_byte v[8];

+                     int j;

+                     png_memcpy(v, sptr, pixel_bytes);

+                     for (j = 0; j < png_pass_inc[pass]; j++)

+                     {

+                        png_memcpy(dp, v, pixel_bytes);

+                        dp -= pixel_bytes;

+                     }

+                     sptr -= pixel_bytes;

+                  }

+               }

+               else if (pixel_bytes == 6)

+               {

+                  for (i = width; i; i--)

+                  {

+                     png_byte v[8];

+                     int j;

+                     png_memcpy(v, sptr, pixel_bytes);

+                     for (j = 0; j < png_pass_inc[pass]; j++)

+                     {

+                        png_memcpy(dp, v, pixel_bytes);

+                        dp -= pixel_bytes;

+                     }

+                     sptr -= pixel_bytes;

+                  }

+               }

+               else

+               {

+                  for (i = width; i; i--)

+                  {

+                     png_byte v[8];

+                     int j;

+                     png_memcpy(v, sptr, pixel_bytes);

+                     for (j = 0; j < png_pass_inc[pass]; j++)

+                     {

+                        png_memcpy(dp, v, pixel_bytes);

+                        dp -= pixel_bytes;

+                     }

+                     sptr -= pixel_bytes;

+                  }

+               }

+            } /* end of MMX not supported */

+            break;

+         }

+      } /* end switch (row_info->pixel_depth) */

+      row_info->width = final_width;

+      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,final_width);

+   }

+}

+#endif /* PNG_READ_INTERLACING_SUPPORTED */

+// These variables are utilized in the functions below.  They are declared

+// globally here to ensure alignment on 8-byte boundaries.

+union uAll {

+   __int64 use;

+   double  align;

+} LBCarryMask = {0x0101010101010101},

+  HBClearMask = {0x7f7f7f7f7f7f7f7f},

+  ActiveMask, ActiveMask2, ActiveMaskEnd, ShiftBpp, ShiftRem;

+// Optimized code for PNG Average filter decoder

+void /* PRIVATE */

+png_read_filter_row_mmx_avg(png_row_infop row_info, png_bytep row

+                            , png_bytep prev_row)

+{

+   int bpp;

+   png_uint_32 FullLength;

+   png_uint_32 MMXLength;

+   //png_uint_32 len;

+   int diff;

+   bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel

+   FullLength  = row_info->rowbytes; // # of bytes to filter

+   _asm {

+         // Init address pointers and offset

+         mov edi, row          // edi ==> Avg(x)

+         xor ebx, ebx          // ebx ==> x

+         mov edx, edi

+         mov esi, prev_row           // esi ==> Prior(x)

+         sub edx, bpp          // edx ==> Raw(x-bpp)

+         xor eax, eax

+         // Compute the Raw value for the first bpp bytes

+         //    Raw(x) = Avg(x) + (Prior(x)/2)

+davgrlp:

+         mov al, [esi + ebx]   // Load al with Prior(x)

+         inc ebx

+         shr al, 1             // divide by 2

+         add al, [edi+ebx-1]   // Add Avg(x); -1 to offset inc ebx

+         cmp ebx, bpp

+         mov [edi+ebx-1], al    // Write back Raw(x);

+                            // mov does not affect flags; -1 to offset inc ebx

+         jb davgrlp

+         // get # of bytes to alignment

+         mov diff, edi         // take start of row

+         add diff, ebx         // add bpp

+         add diff, 0xf         // add 7 + 8 to incr past alignment boundary

+         and diff, 0xfffffff8  // mask to alignment boundary

+         sub diff, edi         // subtract from start ==> value ebx at alignment

+         jz davggo

+         // fix alignment

+         // Compute the Raw value for the bytes upto the alignment boundary

+         //    Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2)

+         xor ecx, ecx

+davglp1:

+         xor eax, eax

+         mov cl, [esi + ebx]        // load cl with Prior(x)

+         mov al, [edx + ebx]  // load al with Raw(x-bpp)

+         add ax, cx

+         inc ebx

+         shr ax, 1            // divide by 2

+         add al, [edi+ebx-1]  // Add Avg(x); -1 to offset inc ebx

+         cmp ebx, diff              // Check if at alignment boundary

+         mov [edi+ebx-1], al        // Write back Raw(x);

+                            // mov does not affect flags; -1 to offset inc ebx

+         jb davglp1               // Repeat until at alignment boundary

+davggo:

+         mov eax, FullLength

+         mov ecx, eax

+         sub eax, ebx          // subtract alignment fix

+         and eax, 0x00000007   // calc bytes over mult of 8

+         sub ecx, eax          // drop over bytes from original length

+         mov MMXLength, ecx

+   } // end _asm block

+   // Now do the math for the rest of the row

+   switch ( bpp )

+   {

+      case 3:

+      {

+         ActiveMask.use  = 0x0000000000ffffff;

+         ShiftBpp.use = 24;    // == 3 * 8

+         ShiftRem.use = 40;    // == 64 - 24

+         _asm {

+            // Re-init address pointers and offset

+            movq mm7, ActiveMask

+            mov ebx, diff      // ebx ==> x = offset to alignment boundary

+            movq mm5, LBCarryMask

+            mov edi, row       // edi ==> Avg(x)

+            movq mm4, HBClearMask

+            mov esi, prev_row        // esi ==> Prior(x)

+            // PRIME the pump (load the first Raw(x-bpp) data set

+            movq mm2, [edi + ebx - 8]  // Load previous aligned 8 bytes

+                               // (we correct position in loop below)

+davg3lp:

+            movq mm0, [edi + ebx]      // Load mm0 with Avg(x)

+            // Add (Prev_row/2) to Average

+            movq mm3, mm5

+            psrlq mm2, ShiftRem      // Correct position Raw(x-bpp) data

+            movq mm1, [esi + ebx]    // Load mm1 with Prior(x)

+            movq mm6, mm7

+            pand mm3, mm1      // get lsb for each prev_row byte

+            psrlq mm1, 1       // divide prev_row bytes by 2

+            pand  mm1, mm4     // clear invalid bit 7 of each byte

+            paddb mm0, mm1     // add (Prev_row/2) to Avg for each byte

+            // Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry

+            movq mm1, mm3      // now use mm1 for getting LBCarrys

+            pand mm1, mm2      // get LBCarrys for each byte where both

+                               // lsb's were == 1 (Only valid for active group)

+            psrlq mm2, 1       // divide raw bytes by 2

+            pand  mm2, mm4     // clear invalid bit 7 of each byte

+            paddb mm2, mm1     // add LBCarrys to (Raw(x-bpp)/2) for each byte

+            pand mm2, mm6      // Leave only Active Group 1 bytes to add to Avg

+            paddb mm0, mm2     // add (Raw/2) + LBCarrys to Avg for each Active

+                               //  byte

+            // Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry

+            psllq mm6, ShiftBpp  // shift the mm6 mask to cover bytes 3-5

+            movq mm2, mm0        // mov updated Raws to mm2

+            psllq mm2, ShiftBpp  // shift data to position correctly

+            movq mm1, mm3        // now use mm1 for getting LBCarrys

+            pand mm1, mm2      // get LBCarrys for each byte where both

+                               // lsb's were == 1 (Only valid for active group)

+            psrlq mm2, 1       // divide raw bytes by 2

+            pand  mm2, mm4     // clear invalid bit 7 of each byte

+            paddb mm2, mm1     // add LBCarrys to (Raw(x-bpp)/2) for each byte

+            pand mm2, mm6      // Leave only Active Group 2 bytes to add to Avg

+            paddb mm0, mm2     // add (Raw/2) + LBCarrys to Avg for each Active

+                               //  byte

+            // Add 3rd active group (Raw(x-bpp)/2) to Average with LBCarry

+            psllq mm6, ShiftBpp  // shift the mm6 mask to cover the last two

+                                 // bytes

+            movq mm2, mm0        // mov updated Raws to mm2

+            psllq mm2, ShiftBpp  // shift data to position correctly

+                              // Data only needs to be shifted once here to

+                              // get the correct x-bpp offset.

+            movq mm1, mm3     // now use mm1 for getting LBCarrys

+            pand mm1, mm2     // get LBCarrys for each byte where both

+                              // lsb's were == 1 (Only valid for active group)

+            psrlq mm2, 1      // divide raw bytes by 2

+            pand  mm2, mm4    // clear invalid bit 7 of each byte

+            paddb mm2, mm1    // add LBCarrys to (Raw(x-bpp)/2) for each byte

+            pand mm2, mm6     // Leave only Active Group 2 bytes to add to Avg

+            add ebx, 8

+            paddb mm0, mm2    // add (Raw/2) + LBCarrys to Avg for each Active

+                              // byte

+            // Now ready to write back to memory

+            movq [edi + ebx - 8], mm0

+            // Move updated Raw(x) to use as Raw(x-bpp) for next loop

+            cmp ebx, MMXLength

+            movq mm2, mm0     // mov updated Raw(x) to mm2

+            jb davg3lp

+         } // end _asm block

+      }

+      break;

+      case 6:

+      case 4:

+      case 7:

+      case 5:

+      {

+         ActiveMask.use  = 0xffffffffffffffff;  // use shift below to clear

+                                                // appropriate inactive bytes

+         ShiftBpp.use = bpp << 3;

+         ShiftRem.use = 64 - ShiftBpp.use;

+         _asm {

+            movq mm4, HBClearMask

+            // Re-init address pointers and offset

+            mov ebx, diff       // ebx ==> x = offset to alignment boundary

+            // Load ActiveMask and clear all bytes except for 1st active group

+            movq mm7, ActiveMask

+            mov edi, row         // edi ==> Avg(x)

+            psrlq mm7, ShiftRem

+            mov esi, prev_row    // esi ==> Prior(x)

+            movq mm6, mm7

+            movq mm5, LBCarryMask

+            psllq mm6, ShiftBpp  // Create mask for 2nd active group

+            // PRIME the pump (load the first Raw(x-bpp) data set

+            movq mm2, [edi + ebx - 8]  // Load previous aligned 8 bytes

+                                 // (we correct position in loop below)

+davg4lp:

+            movq mm0, [edi + ebx]

+            psrlq mm2, ShiftRem  // shift data to position correctly

+            movq mm1, [esi + ebx]

+            // Add (Prev_row/2) to Average

+            movq mm3, mm5

+            pand mm3, mm1     // get lsb for each prev_row byte

+            psrlq mm1, 1      // divide prev_row bytes by 2

+            pand  mm1, mm4    // clear invalid bit 7 of each byte

+            paddb mm0, mm1    // add (Prev_row/2) to Avg for each byte

+            // Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry

+            movq mm1, mm3     // now use mm1 for getting LBCarrys

+            pand mm1, mm2     // get LBCarrys for each byte where both

+                              // lsb's were == 1 (Only valid for active group)

+            psrlq mm2, 1      // divide raw bytes by 2

+            pand  mm2, mm4    // clear invalid bit 7 of each byte

+            paddb mm2, mm1    // add LBCarrys to (Raw(x-bpp)/2) for each byte

+            pand mm2, mm7     // Leave only Active Group 1 bytes to add to Avg

+            paddb mm0, mm2    // add (Raw/2) + LBCarrys to Avg for each Active

+                              // byte

+            // Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry

+            movq mm2, mm0     // mov updated Raws to mm2

+            psllq mm2, ShiftBpp // shift data to position correctly

+            add ebx, 8

+            movq mm1, mm3     // now use mm1 for getting LBCarrys

+            pand mm1, mm2     // get LBCarrys for each byte where both

+                              // lsb's were == 1 (Only valid for active group)

+            psrlq mm2, 1      // divide raw bytes by 2

+            pand  mm2, mm4    // clear invalid bit 7 of each byte

+            paddb mm2, mm1    // add LBCarrys to (Raw(x-bpp)/2) for each byte

+            pand mm2, mm6     // Leave only Active Group 2 bytes to add to Avg

+            paddb mm0, mm2    // add (Raw/2) + LBCarrys to Avg for each Active

+                              // byte

+            cmp ebx, MMXLength

+            // Now ready to write back to memory

+            movq [edi + ebx - 8], mm0

+            // Prep Raw(x-bpp) for next loop

+            movq mm2, mm0     // mov updated Raws to mm2

+            jb davg4lp

+         } // end _asm block

+      }

+      break;

+      case 2:

+      {

+         ActiveMask.use  = 0x000000000000ffff;

+         ShiftBpp.use = 16;   // == 2 * 8     [BUGFIX]

+         ShiftRem.use = 48;   // == 64 - 16   [BUGFIX]

+         _asm {

+            // Load ActiveMask

+            movq mm7, ActiveMask

+            // Re-init address pointers and offset

+            mov ebx, diff     // ebx ==> x = offset to alignment boundary

+            movq mm5, LBCarryMask

+            mov edi, row      // edi ==> Avg(x)

+            movq mm4, HBClearMask

+            mov esi, prev_row  // esi ==> Prior(x)

+            // PRIME the pump (load the first Raw(x-bpp) data set

+            movq mm2, [edi + ebx - 8]  // Load previous aligned 8 bytes

+                              // (we correct position in loop below)

+davg2lp:

+            movq mm0, [edi + ebx]

+            psrlq mm2, ShiftRem  // shift data to position correctly   [BUGFIX]

+            movq mm1, [esi + ebx]

+            // Add (Prev_row/2) to Average

+            movq mm3, mm5

+            pand mm3, mm1     // get lsb for each prev_row byte

+            psrlq mm1, 1      // divide prev_row bytes by 2

+            pand  mm1, mm4    // clear invalid bit 7 of each byte

+            movq mm6, mm7

+            paddb mm0, mm1    // add (Prev_row/2) to Avg for each byte

+            // Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry

+            movq mm1, mm3     // now use mm1 for getting LBCarrys

+            pand mm1, mm2     // get LBCarrys for each byte where both

+                              // lsb's were == 1 (Only valid for active group)

+            psrlq mm2, 1      // divide raw bytes by 2

+            pand  mm2, mm4    // clear invalid bit 7 of each byte

+            paddb mm2, mm1    // add LBCarrys to (Raw(x-bpp)/2) for each byte

+            pand mm2, mm6     // Leave only Active Group 1 bytes to add to Avg

+            paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte

+            // Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry

+            psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 2 & 3

+            movq mm2, mm0       // mov updated Raws to mm2

+            psllq mm2, ShiftBpp // shift data to position correctly

+            movq mm1, mm3       // now use mm1 for getting LBCarrys

+            pand mm1, mm2       // get LBCarrys for each byte where both

+                                // lsb's were == 1 (Only valid for active group)

+            psrlq mm2, 1        // divide raw bytes by 2

+            pand  mm2, mm4      // clear invalid bit 7 of each byte

+            paddb mm2, mm1      // add LBCarrys to (Raw(x-bpp)/2) for each byte

+            pand mm2, mm6       // Leave only Active Group 2 bytes to add to Avg

+            paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte

+            // Add rdd active group (Raw(x-bpp)/2) to Average with LBCarry

+            psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 4 & 5

+            movq mm2, mm0       // mov updated Raws to mm2

+            psllq mm2, ShiftBpp // shift data to position correctly

+                                // Data only needs to be shifted once here to

+                                // get the correct x-bpp offset.

+            movq mm1, mm3       // now use mm1 for getting LBCarrys

+            pand mm1, mm2       // get LBCarrys for each byte where both

+                                // lsb's were == 1 (Only valid for active group)

+            psrlq mm2, 1        // divide raw bytes by 2

+            pand  mm2, mm4      // clear invalid bit 7 of each byte

+            paddb mm2, mm1      // add LBCarrys to (Raw(x-bpp)/2) for each byte

+            pand mm2, mm6       // Leave only Active Group 2 bytes to add to Avg

+            paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte

+            // Add 4th active group (Raw(x-bpp)/2) to Average with LBCarry

+            psllq mm6, ShiftBpp  // shift the mm6 mask to cover bytes 6 & 7

+            movq mm2, mm0        // mov updated Raws to mm2

+            psllq mm2, ShiftBpp  // shift data to position correctly

+                                 // Data only needs to be shifted once here to

+                                 // get the correct x-bpp offset.

+            add ebx, 8

+            movq mm1, mm3    // now use mm1 for getting LBCarrys

+            pand mm1, mm2    // get LBCarrys for each byte where both

+                             // lsb's were == 1 (Only valid for active group)

+            psrlq mm2, 1     // divide raw bytes by 2

+            pand  mm2, mm4   // clear invalid bit 7 of each byte

+            paddb mm2, mm1   // add LBCarrys to (Raw(x-bpp)/2) for each byte

+            pand mm2, mm6    // Leave only Active Group 2 bytes to add to Avg

+            paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte

+            cmp ebx, MMXLength

+            // Now ready to write back to memory

+            movq [edi + ebx - 8], mm0

+            // Prep Raw(x-bpp) for next loop

+            movq mm2, mm0    // mov updated Raws to mm2

+            jb davg2lp

+        } // end _asm block

+      }

+      break;

+      case 1:                 // bpp == 1

+      {

+         _asm {

+            // Re-init address pointers and offset

+            mov ebx, diff     // ebx ==> x = offset to alignment boundary

+            mov edi, row      // edi ==> Avg(x)

+            cmp ebx, FullLength  // Test if offset at end of array

+            jnb davg1end

+            // Do Paeth decode for remaining bytes

+            mov esi, prev_row    // esi ==> Prior(x)

+            mov edx, edi

+            xor ecx, ecx         // zero ecx before using cl & cx in loop below

+            sub edx, bpp         // edx ==> Raw(x-bpp)

+davg1lp:

+            // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2)

+            xor eax, eax

+            mov cl, [esi + ebx]  // load cl with Prior(x)

+            mov al, [edx + ebx]  // load al with Raw(x-bpp)

+            add ax, cx

+            inc ebx

+            shr ax, 1            // divide by 2

+            add al, [edi+ebx-1]  // Add Avg(x); -1 to offset inc ebx

+            cmp ebx, FullLength  // Check if at end of array

+            mov [edi+ebx-1], al  // Write back Raw(x);

+                         // mov does not affect flags; -1 to offset inc ebx

+            jb davg1lp

+davg1end:

+         } // end _asm block

+      }

+      return;

+      case 8:             // bpp == 8

+      {

+         _asm {

+            // Re-init address pointers and offset

+            mov ebx, diff           // ebx ==> x = offset to alignment boundary

+            movq mm5, LBCarryMask

+            mov edi, row            // edi ==> Avg(x)

+            movq mm4, HBClearMask

+            mov esi, prev_row       // esi ==> Prior(x)

+            // PRIME the pump (load the first Raw(x-bpp) data set

+            movq mm2, [edi + ebx - 8]  // Load previous aligned 8 bytes

+                                // (NO NEED to correct position in loop below)

+davg8lp:

+            movq mm0, [edi + ebx]

+            movq mm3, mm5

+            movq mm1, [esi + ebx]

+            add ebx, 8

+            pand mm3, mm1       // get lsb for each prev_row byte

+            psrlq mm1, 1        // divide prev_row bytes by 2

+            pand mm3, mm2       // get LBCarrys for each byte where both

+                                // lsb's were == 1

+            psrlq mm2, 1        // divide raw bytes by 2

+            pand  mm1, mm4      // clear invalid bit 7 of each byte

+            paddb mm0, mm3      // add LBCarrys to Avg for each byte

+            pand  mm2, mm4      // clear invalid bit 7 of each byte

+            paddb mm0, mm1      // add (Prev_row/2) to Avg for each byte

+            paddb mm0, mm2      // add (Raw/2) to Avg for each byte

+            cmp ebx, MMXLength

+            movq [edi + ebx - 8], mm0

+            movq mm2, mm0       // reuse as Raw(x-bpp)

+            jb davg8lp

+        } // end _asm block

+      }

+      break;

+      default:                  // bpp greater than 8

+      {

+        _asm {

+            movq mm5, LBCarryMask

+            // Re-init address pointers and offset

+            mov ebx, diff       // ebx ==> x = offset to alignment boundary

+            mov edi, row        // edi ==> Avg(x)

+            movq mm4, HBClearMask

+            mov edx, edi

+            mov esi, prev_row   // esi ==> Prior(x)

+            sub edx, bpp        // edx ==> Raw(x-bpp)

+davgAlp:

+            movq mm0, [edi + ebx]

+            movq mm3, mm5

+            movq mm1, [esi + ebx]

+            pand mm3, mm1       // get lsb for each prev_row byte

+            movq mm2, [edx + ebx]

+            psrlq mm1, 1        // divide prev_row bytes by 2

+            pand mm3, mm2       // get LBCarrys for each byte where both

+                                // lsb's were == 1

+            psrlq mm2, 1        // divide raw bytes by 2

+            pand  mm1, mm4      // clear invalid bit 7 of each byte

+            paddb mm0, mm3      // add LBCarrys to Avg for each byte

+            pand  mm2, mm4      // clear invalid bit 7 of each byte

+            paddb mm0, mm1      // add (Prev_row/2) to Avg for each byte

+            add ebx, 8

+            paddb mm0, mm2      // add (Raw/2) to Avg for each byte

+            cmp ebx, MMXLength

+            movq [edi + ebx - 8], mm0

+            jb davgAlp

+        } // end _asm block

+      }

+      break;

+   }                         // end switch ( bpp )

+   _asm {

+         // MMX acceleration complete now do clean-up

+         // Check if any remaining bytes left to decode

+         mov ebx, MMXLength    // ebx ==> x = offset bytes remaining after MMX

+         mov edi, row          // edi ==> Avg(x)

+         cmp ebx, FullLength   // Test if offset at end of array

+         jnb davgend

+         // Do Paeth decode for remaining bytes

+         mov esi, prev_row     // esi ==> Prior(x)

+         mov edx, edi

+         xor ecx, ecx          // zero ecx before using cl & cx in loop below

+         sub edx, bpp          // edx ==> Raw(x-bpp)

+davglp2:

+         // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2)

+         xor eax, eax

+         mov cl, [esi + ebx]   // load cl with Prior(x)

+         mov al, [edx + ebx]   // load al with Raw(x-bpp)

+         add ax, cx

+         inc ebx

+         shr ax, 1              // divide by 2

+         add al, [edi+ebx-1]    // Add Avg(x); -1 to offset inc ebx

+         cmp ebx, FullLength    // Check if at end of array

+         mov [edi+ebx-1], al    // Write back Raw(x);

+                          // mov does not affect flags; -1 to offset inc ebx

+         jb davglp2

+davgend:

+         emms             // End MMX instructions; prep for possible FP instrs.

+   } // end _asm block

+}

+// Optimized code for PNG Paeth filter decoder

+void /* PRIVATE */

+png_read_filter_row_mmx_paeth(png_row_infop row_info, png_bytep row,

+                              png_bytep prev_row)

+{

+   png_uint_32 FullLength;

+   png_uint_32 MMXLength;

+   //png_uint_32 len;

+   int bpp;

+   int diff;

+   //int ptemp;

+   int patemp, pbtemp, pctemp;

+   bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel

+   FullLength  = row_info->rowbytes; // # of bytes to filter

+   _asm

+   {

+         xor ebx, ebx        // ebx ==> x offset

+         mov edi, row

+         xor edx, edx        // edx ==> x-bpp offset

+         mov esi, prev_row

+         xor eax, eax

+         // Compute the Raw value for the first bpp bytes

+         // Note: the formula works out to be always

+         //   Paeth(x) = Raw(x) + Prior(x)      where x < bpp

+dpthrlp:

+         mov al, [edi + ebx]

+         add al, [esi + ebx]

+         inc ebx

+         cmp ebx, bpp

+         mov [edi + ebx - 1], al

+         jb dpthrlp

+         // get # of bytes to alignment

+         mov diff, edi         // take start of row

+         add diff, ebx         // add bpp

+         xor ecx, ecx

+         add diff, 0xf         // add 7 + 8 to incr past alignment boundary

+         and diff, 0xfffffff8  // mask to alignment boundary

+         sub diff, edi         // subtract from start ==> value ebx at alignment

+         jz dpthgo

+         // fix alignment

+dpthlp1:

+         xor eax, eax

+         // pav = p - a = (a + b - c) - a = b - c

+         mov al, [esi + ebx]   // load Prior(x) into al

+         mov cl, [esi + edx]   // load Prior(x-bpp) into cl

+         sub eax, ecx          // subtract Prior(x-bpp)

+         mov patemp, eax       // Save pav for later use

+         xor eax, eax

+         // pbv = p - b = (a + b - c) - b = a - c

+         mov al, [edi + edx]   // load Raw(x-bpp) into al

+         sub eax, ecx          // subtract Prior(x-bpp)

+         mov ecx, eax

+         // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+         add eax, patemp       // pcv = pav + pbv

+         // pc = abs(pcv)

+         test eax, 0x80000000

+         jz dpthpca

+         neg eax               // reverse sign of neg values

+dpthpca:

+         mov pctemp, eax       // save pc for later use

+         // pb = abs(pbv)

+         test ecx, 0x80000000

+         jz dpthpba

+         neg ecx               // reverse sign of neg values

+dpthpba:

+         mov pbtemp, ecx       // save pb for later use

+         // pa = abs(pav)

+         mov eax, patemp

+         test eax, 0x80000000

+         jz dpthpaa

+         neg eax               // reverse sign of neg values

+dpthpaa:

+         mov patemp, eax       // save pa for later use

+         // test if pa <= pb

+         cmp eax, ecx

+         jna dpthabb

+         // pa > pb; now test if pb <= pc

+         cmp ecx, pctemp

+         jna dpthbbc

+         // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp)

+         mov cl, [esi + edx]  // load Prior(x-bpp) into cl

+         jmp dpthpaeth

+dpthbbc:

+         // pb <= pc; Raw(x) = Paeth(x) + Prior(x)

+         mov cl, [esi + ebx]   // load Prior(x) into cl

+         jmp dpthpaeth

+dpthabb:

+         // pa <= pb; now test if pa <= pc

+         cmp eax, pctemp

+         jna dpthabc

+         // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp)

+         mov cl, [esi + edx]  // load Prior(x-bpp) into cl

+         jmp dpthpaeth

+dpthabc:

+         // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp)

+         mov cl, [edi + edx]  // load Raw(x-bpp) into cl

+dpthpaeth:

+         inc ebx

+         inc edx

+         // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256

+         add [edi + ebx - 1], cl

+         cmp ebx, diff

+         jb dpthlp1

+dpthgo:

+         mov ecx, FullLength

+         mov eax, ecx

+         sub eax, ebx          // subtract alignment fix

+         and eax, 0x00000007   // calc bytes over mult of 8

+         sub ecx, eax          // drop over bytes from original length

+         mov MMXLength, ecx

+   } // end _asm block

+   // Now do the math for the rest of the row

+   switch ( bpp )

+   {

+      case 3:

+      {

+         ActiveMask.use = 0x0000000000ffffff;

+         ActiveMaskEnd.use = 0xffff000000000000;

+         ShiftBpp.use = 24;    // == bpp(3) * 8

+         ShiftRem.use = 40;    // == 64 - 24

+         _asm

+         {

+            mov ebx, diff

+            mov edi, row

+            mov esi, prev_row

+            pxor mm0, mm0

+            // PRIME the pump (load the first Raw(x-bpp) data set

+            movq mm1, [edi+ebx-8]

+dpth3lp:

+            psrlq mm1, ShiftRem     // shift last 3 bytes to 1st 3 bytes

+            movq mm2, [esi + ebx]   // load b=Prior(x)

+            punpcklbw mm1, mm0      // Unpack High bytes of a

+            movq mm3, [esi+ebx-8]   // Prep c=Prior(x-bpp) bytes

+            punpcklbw mm2, mm0      // Unpack High bytes of b

+            psrlq mm3, ShiftRem     // shift last 3 bytes to 1st 3 bytes

+            // pav = p - a = (a + b - c) - a = b - c

+            movq mm4, mm2

+            punpcklbw mm3, mm0      // Unpack High bytes of c

+            // pbv = p - b = (a + b - c) - b = a - c

+            movq mm5, mm1

+            psubw mm4, mm3

+            pxor mm7, mm7

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+            movq mm6, mm4

+            psubw mm5, mm3

+            // pa = abs(p-a) = abs(pav)

+            // pb = abs(p-b) = abs(pbv)

+            // pc = abs(p-c) = abs(pcv)

+            pcmpgtw mm0, mm4    // Create mask pav bytes < 0

+            paddw mm6, mm5

+            pand mm0, mm4       // Only pav bytes < 0 in mm7

+            pcmpgtw mm7, mm5    // Create mask pbv bytes < 0

+            psubw mm4, mm0

+            pand mm7, mm5       // Only pbv bytes < 0 in mm0

+            psubw mm4, mm0

+            psubw mm5, mm7

+            pxor mm0, mm0

+            pcmpgtw mm0, mm6    // Create mask pcv bytes < 0

+            pand mm0, mm6       // Only pav bytes < 0 in mm7

+            psubw mm5, mm7

+            psubw mm6, mm0

+            //  test pa <= pb

+            movq mm7, mm4

+            psubw mm6, mm0

+            pcmpgtw mm7, mm5    // pa > pb?

+            movq mm0, mm7

+            // use mm7 mask to merge pa & pb

+            pand mm5, mm7

+            // use mm0 mask copy to merge a & b

+            pand mm2, mm0

+            pandn mm7, mm4

+            pandn mm0, mm1

+            paddw mm7, mm5

+            paddw mm0, mm2

+            //  test  ((pa <= pb)? pa:pb) <= pc

+            pcmpgtw mm7, mm6       // pab > pc?

+            pxor mm1, mm1

+            pand mm3, mm7

+            pandn mm7, mm0

+            paddw mm7, mm3

+            pxor mm0, mm0

+            packuswb mm7, mm1

+            movq mm3, [esi + ebx]   // load c=Prior(x-bpp)

+            pand mm7, ActiveMask

+            movq mm2, mm3           // load b=Prior(x) step 1

+            paddb mm7, [edi + ebx]  // add Paeth predictor with Raw(x)

+            punpcklbw mm3, mm0      // Unpack High bytes of c

+            movq [edi + ebx], mm7   // write back updated value

+            movq mm1, mm7           // Now mm1 will be used as Raw(x-bpp)

+            // Now do Paeth for 2nd set of bytes (3-5)

+            psrlq mm2, ShiftBpp     // load b=Prior(x) step 2

+            punpcklbw mm1, mm0      // Unpack High bytes of a

+            pxor mm7, mm7

+            punpcklbw mm2, mm0      // Unpack High bytes of b

+            // pbv = p - b = (a + b - c) - b = a - c

+            movq mm5, mm1

+            // pav = p - a = (a + b - c) - a = b - c

+            movq mm4, mm2

+            psubw mm5, mm3

+            psubw mm4, mm3

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) =

+            //       pav + pbv = pbv + pav

+            movq mm6, mm5

+            paddw mm6, mm4

+            // pa = abs(p-a) = abs(pav)

+            // pb = abs(p-b) = abs(pbv)

+            // pc = abs(p-c) = abs(pcv)

+            pcmpgtw mm0, mm5       // Create mask pbv bytes < 0

+            pcmpgtw mm7, mm4       // Create mask pav bytes < 0

+            pand mm0, mm5          // Only pbv bytes < 0 in mm0

+            pand mm7, mm4          // Only pav bytes < 0 in mm7

+            psubw mm5, mm0

+            psubw mm4, mm7

+            psubw mm5, mm0

+            psubw mm4, mm7

+            pxor mm0, mm0

+            pcmpgtw mm0, mm6       // Create mask pcv bytes < 0

+            pand mm0, mm6          // Only pav bytes < 0 in mm7

+            psubw mm6, mm0

+            //  test pa <= pb

+            movq mm7, mm4

+            psubw mm6, mm0

+            pcmpgtw mm7, mm5       // pa > pb?

+            movq mm0, mm7

+            // use mm7 mask to merge pa & pb

+            pand mm5, mm7

+            // use mm0 mask copy to merge a & b

+            pand mm2, mm0

+            pandn mm7, mm4

+            pandn mm0, mm1

+            paddw mm7, mm5

+            paddw mm0, mm2

+            //  test  ((pa <= pb)? pa:pb) <= pc

+            pcmpgtw mm7, mm6       // pab > pc?

+            movq mm2, [esi + ebx]  // load b=Prior(x)

+            pand mm3, mm7

+            pandn mm7, mm0

+            pxor mm1, mm1

+            paddw mm7, mm3

+            pxor mm0, mm0

+            packuswb mm7, mm1

+            movq mm3, mm2           // load c=Prior(x-bpp) step 1

+            pand mm7, ActiveMask

+            punpckhbw mm2, mm0      // Unpack High bytes of b

+            psllq mm7, ShiftBpp     // Shift bytes to 2nd group of 3 bytes

+             // pav = p - a = (a + b - c) - a = b - c

+            movq mm4, mm2

+            paddb mm7, [edi + ebx]  // add Paeth predictor with Raw(x)

+            psllq mm3, ShiftBpp     // load c=Prior(x-bpp) step 2

+            movq [edi + ebx], mm7   // write back updated value

+            movq mm1, mm7

+            punpckhbw mm3, mm0      // Unpack High bytes of c

+            psllq mm1, ShiftBpp     // Shift bytes

+                                    // Now mm1 will be used as Raw(x-bpp)

+            // Now do Paeth for 3rd, and final, set of bytes (6-7)

+            pxor mm7, mm7

+            punpckhbw mm1, mm0      // Unpack High bytes of a

+            psubw mm4, mm3

+            // pbv = p - b = (a + b - c) - b = a - c

+            movq mm5, mm1

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+            movq mm6, mm4

+            psubw mm5, mm3

+            pxor mm0, mm0

+            paddw mm6, mm5

+            // pa = abs(p-a) = abs(pav)

+            // pb = abs(p-b) = abs(pbv)

+            // pc = abs(p-c) = abs(pcv)

+            pcmpgtw mm0, mm4    // Create mask pav bytes < 0

+            pcmpgtw mm7, mm5    // Create mask pbv bytes < 0

+            pand mm0, mm4       // Only pav bytes < 0 in mm7

+            pand mm7, mm5       // Only pbv bytes < 0 in mm0

+            psubw mm4, mm0

+            psubw mm5, mm7

+            psubw mm4, mm0

+            psubw mm5, mm7

+            pxor mm0, mm0

+            pcmpgtw mm0, mm6    // Create mask pcv bytes < 0

+            pand mm0, mm6       // Only pav bytes < 0 in mm7

+            psubw mm6, mm0

+            //  test pa <= pb

+            movq mm7, mm4

+            psubw mm6, mm0

+            pcmpgtw mm7, mm5    // pa > pb?

+            movq mm0, mm7

+            // use mm0 mask copy to merge a & b

+            pand mm2, mm0

+            // use mm7 mask to merge pa & pb

+            pand mm5, mm7

+            pandn mm0, mm1

+            pandn mm7, mm4

+            paddw mm0, mm2

+            paddw mm7, mm5

+            //  test  ((pa <= pb)? pa:pb) <= pc

+            pcmpgtw mm7, mm6    // pab > pc?

+            pand mm3, mm7

+            pandn mm7, mm0

+            paddw mm7, mm3

+            pxor mm1, mm1

+            packuswb mm1, mm7

+            // Step ebx to next set of 8 bytes and repeat loop til done

+            add ebx, 8

+            pand mm1, ActiveMaskEnd

+            paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x)

+            cmp ebx, MMXLength

+            pxor mm0, mm0              // pxor does not affect flags

+            movq [edi + ebx - 8], mm1  // write back updated value

+                                 // mm1 will be used as Raw(x-bpp) next loop

+                           // mm3 ready to be used as Prior(x-bpp) next loop

+            jb dpth3lp

+         } // end _asm block

+      }

+      break;

+      case 6:

+      case 7:

+      case 5:

+      {

+         ActiveMask.use  = 0x00000000ffffffff;

+         ActiveMask2.use = 0xffffffff00000000;

+         ShiftBpp.use = bpp << 3;    // == bpp * 8

+         ShiftRem.use = 64 - ShiftBpp.use;

+         _asm

+         {

+            mov ebx, diff

+            mov edi, row

+            mov esi, prev_row

+            // PRIME the pump (load the first Raw(x-bpp) data set

+            movq mm1, [edi+ebx-8]

+            pxor mm0, mm0

+dpth6lp:

+            // Must shift to position Raw(x-bpp) data

+            psrlq mm1, ShiftRem

+            // Do first set of 4 bytes

+            movq mm3, [esi+ebx-8]      // read c=Prior(x-bpp) bytes

+            punpcklbw mm1, mm0      // Unpack Low bytes of a

+            movq mm2, [esi + ebx]   // load b=Prior(x)

+            punpcklbw mm2, mm0      // Unpack Low bytes of b

+            // Must shift to position Prior(x-bpp) data

+            psrlq mm3, ShiftRem

+            // pav = p - a = (a + b - c) - a = b - c

+            movq mm4, mm2

+            punpcklbw mm3, mm0      // Unpack Low bytes of c

+            // pbv = p - b = (a + b - c) - b = a - c

+            movq mm5, mm1

+            psubw mm4, mm3

+            pxor mm7, mm7

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+            movq mm6, mm4

+            psubw mm5, mm3

+            // pa = abs(p-a) = abs(pav)

+            // pb = abs(p-b) = abs(pbv)

+            // pc = abs(p-c) = abs(pcv)

+            pcmpgtw mm0, mm4    // Create mask pav bytes < 0

+            paddw mm6, mm5

+            pand mm0, mm4       // Only pav bytes < 0 in mm7

+            pcmpgtw mm7, mm5    // Create mask pbv bytes < 0

+            psubw mm4, mm0

+            pand mm7, mm5       // Only pbv bytes < 0 in mm0

+            psubw mm4, mm0

+            psubw mm5, mm7

+            pxor mm0, mm0

+            pcmpgtw mm0, mm6    // Create mask pcv bytes < 0

+            pand mm0, mm6       // Only pav bytes < 0 in mm7

+            psubw mm5, mm7

+            psubw mm6, mm0

+            //  test pa <= pb

+            movq mm7, mm4

+            psubw mm6, mm0

+            pcmpgtw mm7, mm5    // pa > pb?

+            movq mm0, mm7

+            // use mm7 mask to merge pa & pb

+            pand mm5, mm7

+            // use mm0 mask copy to merge a & b

+            pand mm2, mm0

+            pandn mm7, mm4

+            pandn mm0, mm1

+            paddw mm7, mm5

+            paddw mm0, mm2

+            //  test  ((pa <= pb)? pa:pb) <= pc

+            pcmpgtw mm7, mm6    // pab > pc?

+            pxor mm1, mm1

+            pand mm3, mm7

+            pandn mm7, mm0

+            paddw mm7, mm3

+            pxor mm0, mm0

+            packuswb mm7, mm1

+            movq mm3, [esi + ebx - 8]  // load c=Prior(x-bpp)

+            pand mm7, ActiveMask

+            psrlq mm3, ShiftRem

+            movq mm2, [esi + ebx]      // load b=Prior(x) step 1

+            paddb mm7, [edi + ebx]     // add Paeth predictor with Raw(x)

+            movq mm6, mm2

+            movq [edi + ebx], mm7      // write back updated value

+            movq mm1, [edi+ebx-8]

+            psllq mm6, ShiftBpp

+            movq mm5, mm7

+            psrlq mm1, ShiftRem

+            por mm3, mm6

+            psllq mm5, ShiftBpp

+            punpckhbw mm3, mm0         // Unpack High bytes of c

+            por mm1, mm5

+            // Do second set of 4 bytes

+            punpckhbw mm2, mm0         // Unpack High bytes of b

+            punpckhbw mm1, mm0         // Unpack High bytes of a

+            // pav = p - a = (a + b - c) - a = b - c

+            movq mm4, mm2

+            // pbv = p - b = (a + b - c) - b = a - c

+            movq mm5, mm1

+            psubw mm4, mm3

+            pxor mm7, mm7

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+            movq mm6, mm4

+            psubw mm5, mm3

+            // pa = abs(p-a) = abs(pav)

+            // pb = abs(p-b) = abs(pbv)

+            // pc = abs(p-c) = abs(pcv)

+            pcmpgtw mm0, mm4       // Create mask pav bytes < 0

+            paddw mm6, mm5

+            pand mm0, mm4          // Only pav bytes < 0 in mm7

+            pcmpgtw mm7, mm5       // Create mask pbv bytes < 0

+            psubw mm4, mm0

+            pand mm7, mm5          // Only pbv bytes < 0 in mm0

+            psubw mm4, mm0

+            psubw mm5, mm7

+            pxor mm0, mm0

+            pcmpgtw mm0, mm6       // Create mask pcv bytes < 0

+            pand mm0, mm6          // Only pav bytes < 0 in mm7

+            psubw mm5, mm7

+            psubw mm6, mm0

+            //  test pa <= pb

+            movq mm7, mm4

+            psubw mm6, mm0

+            pcmpgtw mm7, mm5       // pa > pb?

+            movq mm0, mm7

+            // use mm7 mask to merge pa & pb

+            pand mm5, mm7

+            // use mm0 mask copy to merge a & b

+            pand mm2, mm0

+            pandn mm7, mm4

+            pandn mm0, mm1

+            paddw mm7, mm5

+            paddw mm0, mm2

+            //  test  ((pa <= pb)? pa:pb) <= pc

+            pcmpgtw mm7, mm6           // pab > pc?

+            pxor mm1, mm1

+            pand mm3, mm7

+            pandn mm7, mm0

+            pxor mm1, mm1

+            paddw mm7, mm3

+            pxor mm0, mm0

+            // Step ex to next set of 8 bytes and repeat loop til done

+            add ebx, 8

+            packuswb mm1, mm7

+            paddb mm1, [edi + ebx - 8]     // add Paeth predictor with Raw(x)

+            cmp ebx, MMXLength

+            movq [edi + ebx - 8], mm1      // write back updated value

+                                // mm1 will be used as Raw(x-bpp) next loop

+            jb dpth6lp

+         } // end _asm block

+      }

+      break;

+      case 4:

+      {

+         ActiveMask.use  = 0x00000000ffffffff;

+         _asm {

+            mov ebx, diff

+            mov edi, row

+            mov esi, prev_row

+            pxor mm0, mm0

+            // PRIME the pump (load the first Raw(x-bpp) data set

+            movq mm1, [edi+ebx-8]    // Only time should need to read

+                                     //  a=Raw(x-bpp) bytes

+dpth4lp:

+            // Do first set of 4 bytes

+            movq mm3, [esi+ebx-8]    // read c=Prior(x-bpp) bytes

+            punpckhbw mm1, mm0       // Unpack Low bytes of a

+            movq mm2, [esi + ebx]    // load b=Prior(x)

+            punpcklbw mm2, mm0       // Unpack High bytes of b

+            // pav = p - a = (a + b - c) - a = b - c

+            movq mm4, mm2

+            punpckhbw mm3, mm0       // Unpack High bytes of c

+            // pbv = p - b = (a + b - c) - b = a - c

+            movq mm5, mm1

+            psubw mm4, mm3

+            pxor mm7, mm7

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+            movq mm6, mm4

+            psubw mm5, mm3

+            // pa = abs(p-a) = abs(pav)

+            // pb = abs(p-b) = abs(pbv)

+            // pc = abs(p-c) = abs(pcv)

+            pcmpgtw mm0, mm4       // Create mask pav bytes < 0

+            paddw mm6, mm5

+            pand mm0, mm4          // Only pav bytes < 0 in mm7

+            pcmpgtw mm7, mm5       // Create mask pbv bytes < 0

+            psubw mm4, mm0

+            pand mm7, mm5          // Only pbv bytes < 0 in mm0

+            psubw mm4, mm0

+            psubw mm5, mm7

+            pxor mm0, mm0

+            pcmpgtw mm0, mm6       // Create mask pcv bytes < 0

+            pand mm0, mm6          // Only pav bytes < 0 in mm7

+            psubw mm5, mm7

+            psubw mm6, mm0

+            //  test pa <= pb

+            movq mm7, mm4

+            psubw mm6, mm0

+            pcmpgtw mm7, mm5       // pa > pb?

+            movq mm0, mm7

+            // use mm7 mask to merge pa & pb

+            pand mm5, mm7

+            // use mm0 mask copy to merge a & b

+            pand mm2, mm0

+            pandn mm7, mm4

+            pandn mm0, mm1

+            paddw mm7, mm5

+            paddw mm0, mm2

+            //  test  ((pa <= pb)? pa:pb) <= pc

+            pcmpgtw mm7, mm6       // pab > pc?

+            pxor mm1, mm1

+            pand mm3, mm7

+            pandn mm7, mm0

+            paddw mm7, mm3

+            pxor mm0, mm0

+            packuswb mm7, mm1

+            movq mm3, [esi + ebx]      // load c=Prior(x-bpp)

+            pand mm7, ActiveMask

+            movq mm2, mm3              // load b=Prior(x) step 1

+            paddb mm7, [edi + ebx]     // add Paeth predictor with Raw(x)

+            punpcklbw mm3, mm0         // Unpack High bytes of c

+            movq [edi + ebx], mm7      // write back updated value

+            movq mm1, mm7              // Now mm1 will be used as Raw(x-bpp)

+            // Do second set of 4 bytes

+            punpckhbw mm2, mm0         // Unpack Low bytes of b

+            punpcklbw mm1, mm0         // Unpack Low bytes of a

+            // pav = p - a = (a + b - c) - a = b - c

+            movq mm4, mm2

+            // pbv = p - b = (a + b - c) - b = a - c

+            movq mm5, mm1

+            psubw mm4, mm3

+            pxor mm7, mm7

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+            movq mm6, mm4

+            psubw mm5, mm3

+            // pa = abs(p-a) = abs(pav)

+            // pb = abs(p-b) = abs(pbv)

+            // pc = abs(p-c) = abs(pcv)

+            pcmpgtw mm0, mm4       // Create mask pav bytes < 0

+            paddw mm6, mm5

+            pand mm0, mm4          // Only pav bytes < 0 in mm7

+            pcmpgtw mm7, mm5       // Create mask pbv bytes < 0

+            psubw mm4, mm0

+            pand mm7, mm5          // Only pbv bytes < 0 in mm0

+            psubw mm4, mm0

+            psubw mm5, mm7

+            pxor mm0, mm0

+            pcmpgtw mm0, mm6       // Create mask pcv bytes < 0

+            pand mm0, mm6          // Only pav bytes < 0 in mm7

+            psubw mm5, mm7

+            psubw mm6, mm0

+            //  test pa <= pb

+            movq mm7, mm4

+            psubw mm6, mm0

+            pcmpgtw mm7, mm5       // pa > pb?

+            movq mm0, mm7

+            // use mm7 mask to merge pa & pb

+            pand mm5, mm7

+            // use mm0 mask copy to merge a & b

+            pand mm2, mm0

+            pandn mm7, mm4

+            pandn mm0, mm1

+            paddw mm7, mm5

+            paddw mm0, mm2

+            //  test  ((pa <= pb)? pa:pb) <= pc

+            pcmpgtw mm7, mm6       // pab > pc?

+            pxor mm1, mm1

+            pand mm3, mm7

+            pandn mm7, mm0

+            pxor mm1, mm1

+            paddw mm7, mm3

+            pxor mm0, mm0

+            // Step ex to next set of 8 bytes and repeat loop til done

+            add ebx, 8

+            packuswb mm1, mm7

+            paddb mm1, [edi + ebx - 8]     // add Paeth predictor with Raw(x)

+            cmp ebx, MMXLength

+            movq [edi + ebx - 8], mm1      // write back updated value

+                                // mm1 will be used as Raw(x-bpp) next loop

+            jb dpth4lp

+         } // end _asm block

+      }

+      break;

+      case 8:                          // bpp == 8

+      {

+         ActiveMask.use  = 0x00000000ffffffff;

+         _asm {

+            mov ebx, diff

+            mov edi, row

+            mov esi, prev_row

+            pxor mm0, mm0

+            // PRIME the pump (load the first Raw(x-bpp) data set

+            movq mm1, [edi+ebx-8]      // Only time should need to read

+                                       //  a=Raw(x-bpp) bytes

+dpth8lp:

+            // Do first set of 4 bytes

+            movq mm3, [esi+ebx-8]      // read c=Prior(x-bpp) bytes

+            punpcklbw mm1, mm0         // Unpack Low bytes of a

+            movq mm2, [esi + ebx]      // load b=Prior(x)

+            punpcklbw mm2, mm0         // Unpack Low bytes of b

+            // pav = p - a = (a + b - c) - a = b - c

+            movq mm4, mm2

+            punpcklbw mm3, mm0         // Unpack Low bytes of c

+            // pbv = p - b = (a + b - c) - b = a - c

+            movq mm5, mm1

+            psubw mm4, mm3

+            pxor mm7, mm7

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+            movq mm6, mm4

+            psubw mm5, mm3

+            // pa = abs(p-a) = abs(pav)

+            // pb = abs(p-b) = abs(pbv)

+            // pc = abs(p-c) = abs(pcv)

+            pcmpgtw mm0, mm4       // Create mask pav bytes < 0

+            paddw mm6, mm5

+            pand mm0, mm4          // Only pav bytes < 0 in mm7

+            pcmpgtw mm7, mm5       // Create mask pbv bytes < 0

+            psubw mm4, mm0

+            pand mm7, mm5          // Only pbv bytes < 0 in mm0

+            psubw mm4, mm0

+            psubw mm5, mm7

+            pxor mm0, mm0

+            pcmpgtw mm0, mm6       // Create mask pcv bytes < 0

+            pand mm0, mm6          // Only pav bytes < 0 in mm7

+            psubw mm5, mm7

+            psubw mm6, mm0

+            //  test pa <= pb

+            movq mm7, mm4

+            psubw mm6, mm0

+            pcmpgtw mm7, mm5       // pa > pb?

+            movq mm0, mm7

+            // use mm7 mask to merge pa & pb

+            pand mm5, mm7

+            // use mm0 mask copy to merge a & b

+            pand mm2, mm0

+            pandn mm7, mm4

+            pandn mm0, mm1

+            paddw mm7, mm5

+            paddw mm0, mm2

+            //  test  ((pa <= pb)? pa:pb) <= pc

+            pcmpgtw mm7, mm6       // pab > pc?

+            pxor mm1, mm1

+            pand mm3, mm7

+            pandn mm7, mm0

+            paddw mm7, mm3

+            pxor mm0, mm0

+            packuswb mm7, mm1

+            movq mm3, [esi+ebx-8]    // read c=Prior(x-bpp) bytes

+            pand mm7, ActiveMask

+            movq mm2, [esi + ebx]    // load b=Prior(x)

+            paddb mm7, [edi + ebx]   // add Paeth predictor with Raw(x)

+            punpckhbw mm3, mm0       // Unpack High bytes of c

+            movq [edi + ebx], mm7    // write back updated value

+            movq mm1, [edi+ebx-8]    // read a=Raw(x-bpp) bytes

+            // Do second set of 4 bytes

+            punpckhbw mm2, mm0       // Unpack High bytes of b

+            punpckhbw mm1, mm0       // Unpack High bytes of a

+            // pav = p - a = (a + b - c) - a = b - c

+            movq mm4, mm2

+            // pbv = p - b = (a + b - c) - b = a - c

+            movq mm5, mm1

+            psubw mm4, mm3

+            pxor mm7, mm7

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+            movq mm6, mm4

+            psubw mm5, mm3

+            // pa = abs(p-a) = abs(pav)

+            // pb = abs(p-b) = abs(pbv)

+            // pc = abs(p-c) = abs(pcv)

+            pcmpgtw mm0, mm4       // Create mask pav bytes < 0

+            paddw mm6, mm5

+            pand mm0, mm4          // Only pav bytes < 0 in mm7

+            pcmpgtw mm7, mm5       // Create mask pbv bytes < 0

+            psubw mm4, mm0

+            pand mm7, mm5          // Only pbv bytes < 0 in mm0

+            psubw mm4, mm0

+            psubw mm5, mm7

+            pxor mm0, mm0

+            pcmpgtw mm0, mm6       // Create mask pcv bytes < 0

+            pand mm0, mm6          // Only pav bytes < 0 in mm7

+            psubw mm5, mm7

+            psubw mm6, mm0

+            //  test pa <= pb

+            movq mm7, mm4

+            psubw mm6, mm0

+            pcmpgtw mm7, mm5       // pa > pb?

+            movq mm0, mm7

+            // use mm7 mask to merge pa & pb

+            pand mm5, mm7

+            // use mm0 mask copy to merge a & b

+            pand mm2, mm0

+            pandn mm7, mm4

+            pandn mm0, mm1

+            paddw mm7, mm5

+            paddw mm0, mm2

+            //  test  ((pa <= pb)? pa:pb) <= pc

+            pcmpgtw mm7, mm6       // pab > pc?

+            pxor mm1, mm1

+            pand mm3, mm7

+            pandn mm7, mm0

+            pxor mm1, mm1

+            paddw mm7, mm3

+            pxor mm0, mm0

+            // Step ex to next set of 8 bytes and repeat loop til done

+            add ebx, 8

+            packuswb mm1, mm7

+            paddb mm1, [edi + ebx - 8]     // add Paeth predictor with Raw(x)

+            cmp ebx, MMXLength

+            movq [edi + ebx - 8], mm1      // write back updated value

+                            // mm1 will be used as Raw(x-bpp) next loop

+            jb dpth8lp

+         } // end _asm block

+      }

+      break;

+      case 1:                // bpp = 1

+      case 2:                // bpp = 2

+      default:               // bpp > 8

+      {

+         _asm {

+            mov ebx, diff

+            cmp ebx, FullLength

+            jnb dpthdend

+            mov edi, row

+            mov esi, prev_row

+            // Do Paeth decode for remaining bytes

+            mov edx, ebx

+            xor ecx, ecx        // zero ecx before using cl & cx in loop below

+            sub edx, bpp        // Set edx = ebx - bpp

+dpthdlp:

+            xor eax, eax

+            // pav = p - a = (a + b - c) - a = b - c

+            mov al, [esi + ebx]        // load Prior(x) into al

+            mov cl, [esi + edx]        // load Prior(x-bpp) into cl

+            sub eax, ecx                 // subtract Prior(x-bpp)

+            mov patemp, eax                 // Save pav for later use

+            xor eax, eax

+            // pbv = p - b = (a + b - c) - b = a - c

+            mov al, [edi + edx]        // load Raw(x-bpp) into al

+            sub eax, ecx                 // subtract Prior(x-bpp)

+            mov ecx, eax

+            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+            add eax, patemp                 // pcv = pav + pbv

+            // pc = abs(pcv)

+            test eax, 0x80000000

+            jz dpthdpca

+            neg eax                     // reverse sign of neg values

+dpthdpca:

+            mov pctemp, eax             // save pc for later use

+            // pb = abs(pbv)

+            test ecx, 0x80000000

+            jz dpthdpba

+            neg ecx                     // reverse sign of neg values

+dpthdpba:

+            mov pbtemp, ecx             // save pb for later use

+            // pa = abs(pav)

+            mov eax, patemp

+            test eax, 0x80000000

+            jz dpthdpaa

+            neg eax                     // reverse sign of neg values

+dpthdpaa:

+            mov patemp, eax             // save pa for later use

+            // test if pa <= pb

+            cmp eax, ecx

+            jna dpthdabb

+            // pa > pb; now test if pb <= pc

+            cmp ecx, pctemp

+            jna dpthdbbc

+            // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp)

+            mov cl, [esi + edx]  // load Prior(x-bpp) into cl

+            jmp dpthdpaeth

+dpthdbbc:

+            // pb <= pc; Raw(x) = Paeth(x) + Prior(x)

+            mov cl, [esi + ebx]        // load Prior(x) into cl

+            jmp dpthdpaeth

+dpthdabb:

+            // pa <= pb; now test if pa <= pc

+            cmp eax, pctemp

+            jna dpthdabc

+            // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp)

+            mov cl, [esi + edx]  // load Prior(x-bpp) into cl

+            jmp dpthdpaeth

+dpthdabc:

+            // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp)

+            mov cl, [edi + edx]  // load Raw(x-bpp) into cl

+dpthdpaeth:

+            inc ebx

+            inc edx

+            // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256

+            add [edi + ebx - 1], cl

+            cmp ebx, FullLength

+            jb dpthdlp

+dpthdend:

+         } // end _asm block

+      }

+      return;                   // No need to go further with this one

+   }                         // end switch ( bpp )

+   _asm

+   {

+         // MMX acceleration complete now do clean-up

+         // Check if any remaining bytes left to decode

+         mov ebx, MMXLength

+         cmp ebx, FullLength

+         jnb dpthend

+         mov edi, row

+         mov esi, prev_row

+         // Do Paeth decode for remaining bytes

+         mov edx, ebx

+         xor ecx, ecx         // zero ecx before using cl & cx in loop below

+         sub edx, bpp         // Set edx = ebx - bpp

+dpthlp2:

+         xor eax, eax

+         // pav = p - a = (a + b - c) - a = b - c

+         mov al, [esi + ebx]  // load Prior(x) into al

+         mov cl, [esi + edx]  // load Prior(x-bpp) into cl

+         sub eax, ecx         // subtract Prior(x-bpp)

+         mov patemp, eax      // Save pav for later use

+         xor eax, eax

+         // pbv = p - b = (a + b - c) - b = a - c

+         mov al, [edi + edx]  // load Raw(x-bpp) into al

+         sub eax, ecx         // subtract Prior(x-bpp)

+         mov ecx, eax

+         // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv

+         add eax, patemp      // pcv = pav + pbv

+         // pc = abs(pcv)

+         test eax, 0x80000000

+         jz dpthpca2

+         neg eax              // reverse sign of neg values

+dpthpca2:

+         mov pctemp, eax      // save pc for later use

+         // pb = abs(pbv)

+         test ecx, 0x80000000

+         jz dpthpba2

+         neg ecx              // reverse sign of neg values

+dpthpba2:

+         mov pbtemp, ecx      // save pb for later use

+         // pa = abs(pav)

+         mov eax, patemp

+         test eax, 0x80000000

+         jz dpthpaa2

+         neg eax              // reverse sign of neg values

+dpthpaa2:

+         mov patemp, eax      // save pa for later use

+         // test if pa <= pb

+         cmp eax, ecx

+         jna dpthabb2

+         // pa > pb; now test if pb <= pc

+         cmp ecx, pctemp

+         jna dpthbbc2

+         // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp)

+         mov cl, [esi + edx]  // load Prior(x-bpp) into cl

+         jmp dpthpaeth2

+dpthbbc2:

+         // pb <= pc; Raw(x) = Paeth(x) + Prior(x)

+         mov cl, [esi + ebx]        // load Prior(x) into cl

+         jmp dpthpaeth2

+dpthabb2:

+         // pa <= pb; now test if pa <= pc

+         cmp eax, pctemp

+         jna dpthabc2

+         // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp)

+         mov cl, [esi + edx]  // load Prior(x-bpp) into cl

+         jmp dpthpaeth2

+dpthabc2:

+         // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp)

+         mov cl, [edi + edx]  // load Raw(x-bpp) into cl

+dpthpaeth2:

+         inc ebx

+         inc edx

+         // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256

+         add [edi + ebx - 1], cl

+         cmp ebx, FullLength

+         jb dpthlp2

+dpthend:

+         emms             // End MMX instructions; prep for possible FP instrs.

+   } // end _asm block

+}

+// Optimized code for PNG Sub filter decoder

+void /* PRIVATE */

+png_read_filter_row_mmx_sub(png_row_infop row_info, png_bytep row)

+{

+   //int test;

+   int bpp;

+   png_uint_32 FullLength;

+   png_uint_32 MMXLength;

+   int diff;

+   bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel

+   FullLength  = row_info->rowbytes - bpp; // # of bytes to filter

+   _asm {

+        mov edi, row

+        mov esi, edi               // lp = row

+        add edi, bpp               // rp = row + bpp

+        xor eax, eax

+        // get # of bytes to alignment

+        mov diff, edi               // take start of row

+        add diff, 0xf               // add 7 + 8 to incr past

+                                        // alignment boundary

+        xor ebx, ebx

+        and diff, 0xfffffff8        // mask to alignment boundary

+        sub diff, edi               // subtract from start ==> value

+                                        //  ebx at alignment

+        jz dsubgo

+        // fix alignment

+dsublp1:

+        mov al, [esi+ebx]

+        add [edi+ebx], al

+        inc ebx

+        cmp ebx, diff

+        jb dsublp1

+dsubgo:

+        mov ecx, FullLength

+        mov edx, ecx

+        sub edx, ebx                  // subtract alignment fix

+        and edx, 0x00000007           // calc bytes over mult of 8

+        sub ecx, edx                  // drop over bytes from length

+        mov MMXLength, ecx

+   } // end _asm block

+   // Now do the math for the rest of the row

+   switch ( bpp )

+   {

+        case 3:

+        {

+         ActiveMask.use  = 0x0000ffffff000000;

+         ShiftBpp.use = 24;       // == 3 * 8

+         ShiftRem.use  = 40;      // == 64 - 24

+         _asm {

+            mov edi, row

+            movq mm7, ActiveMask  // Load ActiveMask for 2nd active byte group

+            mov esi, edi              // lp = row

+            add edi, bpp          // rp = row + bpp

+            movq mm6, mm7

+            mov ebx, diff

+            psllq mm6, ShiftBpp   // Move mask in mm6 to cover 3rd active

+                                  // byte group

+            // PRIME the pump (load the first Raw(x-bpp) data set

+            movq mm1, [edi+ebx-8]

+dsub3lp:

+            psrlq mm1, ShiftRem   // Shift data for adding 1st bpp bytes

+                          // no need for mask; shift clears inactive bytes

+            // Add 1st active group

+            movq mm0, [edi+ebx]

+            paddb mm0, mm1

+            // Add 2nd active group

+            movq mm1, mm0         // mov updated Raws to mm1

+            psllq mm1, ShiftBpp   // shift data to position correctly

+            pand mm1, mm7         // mask to use only 2nd active group

+            paddb mm0, mm1

+            // Add 3rd active group

+            movq mm1, mm0         // mov updated Raws to mm1

+            psllq mm1, ShiftBpp   // shift data to position correctly

+            pand mm1, mm6         // mask to use only 3rd active group

+            add ebx, 8

+            paddb mm0, mm1

+            cmp ebx, MMXLength

+            movq [edi+ebx-8], mm0     // Write updated Raws back to array

+            // Prep for doing 1st add at top of loop

+            movq mm1, mm0

+            jb dsub3lp

+         } // end _asm block

+      }

+      break;

+      case 1:

+      {

+         // Placed here just in case this is a duplicate of the

+         // non-MMX code for the SUB filter in png_read_filter_row below

+         //

+         //         png_bytep rp;

+         //         png_bytep lp;

+         //         png_uint_32 i;

+         //         bpp = (row_info->pixel_depth + 7) >> 3;

+         //         for (i = (png_uint_32)bpp, rp = row + bpp, lp = row;

+         //            i < row_info->rowbytes; i++, rp++, lp++)

+         //      {

+         //            *rp = (png_byte)(((int)(*rp) + (int)(*lp)) & 0xff);

+         //      }

+         _asm {

+            mov ebx, diff

+            mov edi, row

+            cmp ebx, FullLength

+            jnb dsub1end

+            mov esi, edi          // lp = row

+            xor eax, eax

+            add edi, bpp      // rp = row + bpp

+dsub1lp:

+            mov al, [esi+ebx]

+            add [edi+ebx], al

+            inc ebx

+            cmp ebx, FullLength

+            jb dsub1lp

+dsub1end:

+         } // end _asm block

+      }

+      return;

+      case 6:

+      case 7:

+      case 4:

+      case 5:

+      {

+         ShiftBpp.use = bpp << 3;

+         ShiftRem.use = 64 - ShiftBpp.use;

+         _asm {

+            mov edi, row

+            mov ebx, diff

+            mov esi, edi               // lp = row

+            add edi, bpp           // rp = row + bpp

+            // PRIME the pump (load the first Raw(x-bpp) data set

+            movq mm1, [edi+ebx-8]

+dsub4lp:

+            psrlq mm1, ShiftRem // Shift data for adding 1st bpp bytes

+                          // no need for mask; shift clears inactive bytes

+            movq mm0, [edi+ebx]

+            paddb mm0, mm1

+            // Add 2nd active group

+            movq mm1, mm0          // mov updated Raws to mm1

+            psllq mm1, ShiftBpp    // shift data to position correctly

+                                   // there is no need for any mask

+                                   // since shift clears inactive bits/bytes

+            add ebx, 8

+            paddb mm0, mm1

+            cmp ebx, MMXLength

+            movq [edi+ebx-8], mm0

+            movq mm1, mm0          // Prep for doing 1st add at top of loop

+            jb dsub4lp

+         } // end _asm block

+      }

+      break;

+      case 2:

+      {

+         ActiveMask.use  = 0x00000000ffff0000;

+         ShiftBpp.use = 16;       // == 2 * 8

+         ShiftRem.use = 48;       // == 64 - 16

+         _asm {

+            movq mm7, ActiveMask  // Load ActiveMask for 2nd active byte group

+            mov ebx, diff

+            movq mm6, mm7

+            mov edi, row

+            psllq mm6, ShiftBpp     // Move mask in mm6 to cover 3rd active

+                                    //  byte group

+            mov esi, edi            // lp = row

+            movq mm5, mm6

+            add edi, bpp            // rp = row + bpp

+            psllq mm5, ShiftBpp     // Move mask in mm5 to cover 4th active

+                                    //  byte group

+            // PRIME the pump (load the first Raw(x-bpp) data set

+            movq mm1, [edi+ebx-8]

+dsub2lp:

+            // Add 1st active group

+            psrlq mm1, ShiftRem     // Shift data for adding 1st bpp bytes

+                                    // no need for mask; shift clears inactive

+                                    //  bytes

+            movq mm0, [edi+ebx]

+            paddb mm0, mm1

+            // Add 2nd active group

+            movq mm1, mm0           // mov updated Raws to mm1

+            psllq mm1, ShiftBpp     // shift data to position correctly

+            pand mm1, mm7           // mask to use only 2nd active group

+            paddb mm0, mm1

+            // Add 3rd active group

+            movq mm1, mm0           // mov updated Raws to mm1

+            psllq mm1, ShiftBpp     // shift data to position correctly

+            pand mm1, mm6           // mask to use only 3rd active group

+            paddb mm0, mm1

+            // Add 4th active group

+            movq mm1, mm0           // mov updated Raws to mm1

+            psllq mm1, ShiftBpp     // shift data to position correctly

+            pand mm1, mm5           // mask to use only 4th active group

+            add ebx, 8

+            paddb mm0, mm1

+            cmp ebx, MMXLength

+            movq [edi+ebx-8], mm0   // Write updated Raws back to array

+            movq mm1, mm0           // Prep for doing 1st add at top of loop

+            jb dsub2lp

+         } // end _asm block

+      }

+      break;

+      case 8:

+      {

+         _asm {

+            mov edi, row

+            mov ebx, diff

+            mov esi, edi            // lp = row

+            add edi, bpp            // rp = row + bpp

+            mov ecx, MMXLength

+            movq mm7, [edi+ebx-8]   // PRIME the pump (load the first

+                                    // Raw(x-bpp) data set

+            and ecx, 0x0000003f     // calc bytes over mult of 64

+dsub8lp:

+            movq mm0, [edi+ebx]     // Load Sub(x) for 1st 8 bytes

+            paddb mm0, mm7

+            movq mm1, [edi+ebx+8]   // Load Sub(x) for 2nd 8 bytes

+            movq [edi+ebx], mm0    // Write Raw(x) for 1st 8 bytes

+                                   // Now mm0 will be used as Raw(x-bpp) for

+                                   // the 2nd group of 8 bytes.  This will be

+                                   // repeated for each group of 8 bytes with

+                                   // the 8th group being used as the Raw(x-bpp)

+                                   // for the 1st group of the next loop.

+            paddb mm1, mm0

+            movq mm2, [edi+ebx+16]  // Load Sub(x) for 3rd 8 bytes

+            movq [edi+ebx+8], mm1   // Write Raw(x) for 2nd 8 bytes

+            paddb mm2, mm1

+            movq mm3, [edi+ebx+24]  // Load Sub(x) for 4th 8 bytes

+            movq [edi+ebx+16], mm2  // Write Raw(x) for 3rd 8 bytes

+            paddb mm3, mm2

+            movq mm4, [edi+ebx+32]  // Load Sub(x) for 5th 8 bytes

+            movq [edi+ebx+24], mm3  // Write Raw(x) for 4th 8 bytes

+            paddb mm4, mm3

+            movq mm5, [edi+ebx+40]  // Load Sub(x) for 6th 8 bytes

+            movq [edi+ebx+32], mm4  // Write Raw(x) for 5th 8 bytes

+            paddb mm5, mm4

+            movq mm6, [edi+ebx+48]  // Load Sub(x) for 7th 8 bytes

+            movq [edi+ebx+40], mm5  // Write Raw(x) for 6th 8 bytes

+            paddb mm6, mm5

+            movq mm7, [edi+ebx+56]  // Load Sub(x) for 8th 8 bytes

+            movq [edi+ebx+48], mm6  // Write Raw(x) for 7th 8 bytes

+            add ebx, 64

+            paddb mm7, mm6

+            cmp ebx, ecx

+            movq [edi+ebx-8], mm7   // Write Raw(x) for 8th 8 bytes

+            jb dsub8lp

+            cmp ebx, MMXLength

+            jnb dsub8lt8

+dsub8lpA:

+            movq mm0, [edi+ebx]

+            add ebx, 8

+            paddb mm0, mm7

+            cmp ebx, MMXLength

+            movq [edi+ebx-8], mm0   // use -8 to offset early add to ebx

+            movq mm7, mm0           // Move calculated Raw(x) data to mm1 to

+                                    // be the new Raw(x-bpp) for the next loop

+            jb dsub8lpA

+dsub8lt8:

+         } // end _asm block

+      }

+      break;

+      default:                // bpp greater than 8 bytes

+      {

+         _asm {

+            mov ebx, diff

+            mov edi, row

+            mov esi, edi           // lp = row

+            add edi, bpp           // rp = row + bpp

+dsubAlp:

+            movq mm0, [edi+ebx]

+            movq mm1, [esi+ebx]

+            add ebx, 8

+            paddb mm0, mm1

+            cmp ebx, MMXLength

+            movq [edi+ebx-8], mm0  // mov does not affect flags; -8 to offset

+                                   //  add ebx

+            jb dsubAlp

+         } // end _asm block

+      }

+      break;

+   } // end switch ( bpp )

+   _asm {

+        mov ebx, MMXLength

+        mov edi, row

+        cmp ebx, FullLength

+        jnb dsubend

+        mov esi, edi               // lp = row

+        xor eax, eax

+        add edi, bpp               // rp = row + bpp

+dsublp2:

+        mov al, [esi+ebx]

+        add [edi+ebx], al

+        inc ebx

+        cmp ebx, FullLength

+        jb dsublp2

+dsubend:

+        emms             // End MMX instructions; prep for possible FP instrs.

+   } // end _asm block

+}

+// Optimized code for PNG Up filter decoder

+void /* PRIVATE */

+png_read_filter_row_mmx_up(png_row_infop row_info, png_bytep row,

+   png_bytep prev_row)

+{

+   png_uint_32 len;

+   len  = row_info->rowbytes;       // # of bytes to filter

+   _asm {

+      mov edi, row

+      // get # of bytes to alignment

+      mov ecx, edi

+      xor ebx, ebx

+      add ecx, 0x7

+      xor eax, eax

+      and ecx, 0xfffffff8

+      mov esi, prev_row

+      sub ecx, edi

+      jz dupgo

+      // fix alignment

+duplp1:

+      mov al, [edi+ebx]

+      add al, [esi+ebx]

+      inc ebx

+      cmp ebx, ecx

+      mov [edi + ebx-1], al  // mov does not affect flags; -1 to offset inc ebx

+      jb duplp1

+dupgo:

+      mov ecx, len

+      mov edx, ecx

+      sub edx, ebx                  // subtract alignment fix

+      and edx, 0x0000003f           // calc bytes over mult of 64

+      sub ecx, edx                  // drop over bytes from length

+      // Unrolled loop - use all MMX registers and interleave to reduce

+      // number of branch instructions (loops) and reduce partial stalls

+duploop:

+      movq mm1, [esi+ebx]

+      movq mm0, [edi+ebx]

+      movq mm3, [esi+ebx+8]

+      paddb mm0, mm1

+      movq mm2, [edi+ebx+8]

+      movq [edi+ebx], mm0

+      paddb mm2, mm3

+      movq mm5, [esi+ebx+16]

+      movq [edi+ebx+8], mm2

+      movq mm4, [edi+ebx+16]

+      movq mm7, [esi+ebx+24]

+      paddb mm4, mm5

+      movq mm6, [edi+ebx+24]

+      movq [edi+ebx+16], mm4

+      paddb mm6, mm7

+      movq mm1, [esi+ebx+32]

+      movq [edi+ebx+24], mm6

+      movq mm0, [edi+ebx+32]

+      movq mm3, [esi+ebx+40]

+      paddb mm0, mm1

+      movq mm2, [edi+ebx+40]

+      movq [edi+ebx+32], mm0

+      paddb mm2, mm3

+      movq mm5, [esi+ebx+48]

+      movq [edi+ebx+40], mm2

+      movq mm4, [edi+ebx+48]

+      movq mm7, [esi+ebx+56]

+      paddb mm4, mm5

+      movq mm6, [edi+ebx+56]

+      movq [edi+ebx+48], mm4

+      add ebx, 64

+      paddb mm6, mm7

+      cmp ebx, ecx

+      movq [edi+ebx-8], mm6 // (+56)movq does not affect flags;

+                                     // -8 to offset add ebx

+      jb duploop

+      cmp edx, 0                     // Test for bytes over mult of 64

+      jz dupend

+      // 2 lines added by lcreeve at netins.net

+      // (mail 11 Jul 98 in png-implement list)

+      cmp edx, 8 //test for less than 8 bytes

+      jb duplt8

+      add ecx, edx

+      and edx, 0x00000007           // calc bytes over mult of 8

+      sub ecx, edx                  // drop over bytes from length

+      jz duplt8

+      // Loop using MMX registers mm0 & mm1 to update 8 bytes simultaneously

+duplpA:

+      movq mm1, [esi+ebx]

+      movq mm0, [edi+ebx]

+      add ebx, 8

+      paddb mm0, mm1

+      cmp ebx, ecx

+      movq [edi+ebx-8], mm0 // movq does not affect flags; -8 to offset add ebx

+      jb duplpA

+      cmp edx, 0            // Test for bytes over mult of 8

+      jz dupend

+duplt8:

+      xor eax, eax

+      add ecx, edx          // move over byte count into counter

+      // Loop using x86 registers to update remaining bytes

+duplp2:

+      mov al, [edi + ebx]

+      add al, [esi + ebx]

+      inc ebx

+      cmp ebx, ecx

+      mov [edi + ebx-1], al // mov does not affect flags; -1 to offset inc ebx

+      jb duplp2

+dupend:

+      // Conversion of filtered row completed

+      emms          // End MMX instructions; prep for possible FP instrs.

+   } // end _asm block

+}

+// Optimized png_read_filter_row routines

+void /* PRIVATE */

+png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep

+   row, png_bytep prev_row, int filter)

+{

+#ifdef PNG_DEBUG

+   char filnm[10];

+#endif

+   if (mmx_supported == 2) {

+#if !defined(PNG_1_0_X)

+       /* this should have happened in png_init_mmx_flags() already */

+       png_warning(png_ptr, "asm_flags may not have been initialized");

+#endif

+       png_mmx_support();

+   }

+#ifdef PNG_DEBUG

+   png_debug(1, "in png_read_filter_row\n");

+   switch (filter)

+   {

+      case 0: sprintf(filnm, "none");

+         break;

+#if !defined(PNG_1_0_X)

+      case 1: sprintf(filnm, "sub-%s",

+        (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)? "MMX" : "x86");

+         break;

+      case 2: sprintf(filnm, "up-%s",

+        (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP)? "MMX" : "x86");

+         break;

+      case 3: sprintf(filnm, "avg-%s",

+        (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)? "MMX" : "x86");

+         break;

+      case 4: sprintf(filnm, "Paeth-%s",

+        (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)? "MMX":"x86");

+         break;

+#else

+      case 1: sprintf(filnm, "sub");

+         break;

+      case 2: sprintf(filnm, "up");

+         break;

+      case 3: sprintf(filnm, "avg");

+         break;

+      case 4: sprintf(filnm, "Paeth");

+         break;

+#endif

+      default: sprintf(filnm, "unknw");

+         break;

+   }

+   png_debug2(0,"row=%5d, %s, ", png_ptr->row_number, filnm);

+   png_debug2(0, "pd=%2d, b=%d, ", (int)row_info->pixel_depth,

+      (int)((row_info->pixel_depth + 7) >> 3));

+   png_debug1(0,"len=%8d, ", row_info->rowbytes);

+#endif /* PNG_DEBUG */

+   switch (filter)

+   {

+      case PNG_FILTER_VALUE_NONE:

+         break;

+      case PNG_FILTER_VALUE_SUB:

+      {

+#if !defined(PNG_1_0_X)

+         if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB) &&

+             (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) &&

+             (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold))

+#else

+         if (mmx_supported)

+#endif

+         {

+            png_read_filter_row_mmx_sub(row_info, row);

+         }

+         else

+         {

+            png_uint_32 i;

+            png_uint_32 istop = row_info->rowbytes;

+            png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;

+            png_bytep rp = row + bpp;

+            png_bytep lp = row;

+            for (i = bpp; i < istop; i++)

+            {

+               *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff);

+               rp++;

+            }

+         }

+         break;

+      }

+      case PNG_FILTER_VALUE_UP:

+      {

+#if !defined(PNG_1_0_X)

+         if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP) &&

+             (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) &&

+             (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold))

+#else

+         if (mmx_supported)

+#endif

+         {

+            png_read_filter_row_mmx_up(row_info, row, prev_row);

+         }

+         else

+         {

+            png_uint_32 i;

+            png_uint_32 istop = row_info->rowbytes;

+            png_bytep rp = row;

+            png_bytep pp = prev_row;

+            for (i = 0; i < istop; ++i)

+            {

+               *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);

+               rp++;

+            }

+         }

+         break;

+      }

+      case PNG_FILTER_VALUE_AVG:

+      {

+#if !defined(PNG_1_0_X)

+         if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG) &&

+             (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) &&

+             (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold))

+#else

+         if (mmx_supported)

+#endif

+         {

+            png_read_filter_row_mmx_avg(row_info, row, prev_row);

+         }

+         else

+         {

+            png_uint_32 i;

+            png_bytep rp = row;

+            png_bytep pp = prev_row;

+            png_bytep lp = row;

+            png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;

+            png_uint_32 istop = row_info->rowbytes - bpp;

+            for (i = 0; i < bpp; i++)

+            {

+               *rp = (png_byte)(((int)(*rp) +

+                  ((int)(*pp++) >> 1)) & 0xff);

+               rp++;

+            }

+            for (i = 0; i < istop; i++)

+            {

+               *rp = (png_byte)(((int)(*rp) +

+                  ((int)(*pp++ + *lp++) >> 1)) & 0xff);

+               rp++;

+            }

+         }

+         break;

+      }

+      case PNG_FILTER_VALUE_PAETH:

+      {

+#if !defined(PNG_1_0_X)

+         if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH) &&

+             (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) &&

+             (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold))

+#else

+         if (mmx_supported)

+#endif

+         {

+            png_read_filter_row_mmx_paeth(row_info, row, prev_row);

+         }

+         else

+         {

+            png_uint_32 i;

+            png_bytep rp = row;

+            png_bytep pp = prev_row;

+            png_bytep lp = row;

+            png_bytep cp = prev_row;

+            png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;

+            png_uint_32 istop=row_info->rowbytes - bpp;

+            for (i = 0; i < bpp; i++)

+            {

+               *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);

+               rp++;

+            }

+            for (i = 0; i < istop; i++)   // use leftover rp,pp

+            {

+               int a, b, c, pa, pb, pc, p;

+               a = *lp++;

+               b = *pp++;

+               c = *cp++;

+               p = b - c;

+               pc = a - c;

+#ifdef PNG_USE_ABS

+               pa = abs(p);

+               pb = abs(pc);

+               pc = abs(p + pc);

+#else

+               pa = p < 0 ? -p : p;

+               pb = pc < 0 ? -pc : pc;

+               pc = (p + pc) < 0 ? -(p + pc) : p + pc;

+#endif

+               /*

+                  if (pa <= pb && pa <= pc)

+                     p = a;

+                  else if (pb <= pc)

+                     p = b;

+                  else

+                     p = c;

+                */

+               p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;

+               *rp = (png_byte)(((int)(*rp) + p) & 0xff);

+               rp++;

+            }

+         }

+         break;

+      }

+      default:

+         png_warning(png_ptr, "Ignoring bad row filter type");

+         *row=0;

+         break;

+   }

+}

+#endif /* PNG_ASSEMBLER_CODE_SUPPORTED && PNG_USE_PNGVCRD */

--- /dev/null

+++ b/src/gfx/libpng/pngwio.c

@@ -1,0 +1,228 @@

+/* pngwio.c - functions for data output

+ *

+ * libpng 1.2.8 - December 3, 2004

+ * For conditions of distribution and use, see copyright notice in png.h

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

+ *

+ * This file provides a location for all output.  Users who need

+ * special handling are expected to write functions that have the same

+ * arguments as these and perform similar functions, but that possibly

+ * use different output methods.  Note that you shouldn't change these

+ * functions, but rather write replacement functions and then change

+ * them at run time with png_set_write_fn(...).

+ */

+#define PNG_INTERNAL

+#include "png.h"

+#ifdef PNG_WRITE_SUPPORTED

+/* Write the data to whatever output you are using.  The default routine

+   writes to a file pointer.  Note that this routine sometimes gets called

+   with very small lengths, so you should implement some kind of simple

+   buffering if you are using unbuffered writes.  This should never be asked

+   to write more than 64K on a 16 bit machine.  */

+void /* PRIVATE */

+png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)

+{

+   if (png_ptr->write_data_fn != NULL )

+      (*(png_ptr->write_data_fn))(png_ptr, data, length);

+   else

+      png_error(png_ptr, "Call to NULL write function");

+}

+#if !defined(PNG_NO_STDIO)

+/* This is the function that does the actual writing of data.  If you are

+   not writing to a standard C stream, you should create a replacement

+   write_data function and use it at run time with png_set_write_fn(), rather

+   than changing the library. */

+#ifndef USE_FAR_KEYWORD

+void PNGAPI

+png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)

+{

+   png_uint_32 check;

+#if defined(_WIN32_WCE)

+   if ( !WriteFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )

+      check = 0;

+#else

+   check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr));

+#endif

+   if (check != length)

+      png_error(png_ptr, "Write Error");

+}

+#else

+/* this is the model-independent version. Since the standard I/O library

+   can't handle far buffers in the medium and small models, we have to copy

+   the data.

+*/

+#define NEAR_BUF_SIZE 1024

+#define MIN(a,b) (a <= b ? a : b)

+void PNGAPI

+png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)

+{

+   png_uint_32 check;

+   png_byte *near_data;  /* Needs to be "png_byte *" instead of "png_bytep" */

+   png_FILE_p io_ptr;

+   /* Check if data really is near. If so, use usual code. */

+   near_data = (png_byte *)CVT_PTR_NOCHECK(data);

+   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);

+   if ((png_bytep)near_data == data)

+   {

+#if defined(_WIN32_WCE)

+      if ( !WriteFile(io_ptr, near_data, length, &check, NULL) )

+         check = 0;

+#else

+      check = fwrite(near_data, 1, length, io_ptr);

+#endif

+   }

+   else

+   {

+      png_byte buf[NEAR_BUF_SIZE];

+      png_size_t written, remaining, err;

+      check = 0;

+      remaining = length;

+      do

+      {

+         written = MIN(NEAR_BUF_SIZE, remaining);

+         png_memcpy(buf, data, written); /* copy far buffer to near buffer */

+#if defined(_WIN32_WCE)

+         if ( !WriteFile(io_ptr, buf, written, &err, NULL) )

+            err = 0;

+#else

+         err = fwrite(buf, 1, written, io_ptr);

+#endif

+         if (err != written)

+            break;

+         else

+            check += err;

+         data += written;

+         remaining -= written;

+      }

+      while (remaining != 0);

+   }

+   if (check != length)

+      png_error(png_ptr, "Write Error");

+}

+#endif

+#endif

+/* This function is called to output any data pending writing (normally

+   to disk).  After png_flush is called, there should be no data pending

+   writing in any buffers. */

+#if defined(PNG_WRITE_FLUSH_SUPPORTED)

+void /* PRIVATE */

+png_flush(png_structp png_ptr)

+{

+   if (png_ptr->output_flush_fn != NULL)

+      (*(png_ptr->output_flush_fn))(png_ptr);

+}

+#if !defined(PNG_NO_STDIO)

+void PNGAPI

+png_default_flush(png_structp png_ptr)

+{

+#if !defined(_WIN32_WCE)

+   png_FILE_p io_ptr;

+   io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr));

+   if (io_ptr != NULL)

+      fflush(io_ptr);

+#endif

+}

+#endif

+#endif

+/* This function allows the application to supply new output functions for

+   libpng if standard C streams aren't being used.

+   This function takes as its arguments:

+   png_ptr       - pointer to a png output data structure

+   io_ptr        - pointer to user supplied structure containing info about

+                   the output functions.  May be NULL.

+   write_data_fn - pointer to a new output function that takes as its

+                   arguments a pointer to a png_struct, a pointer to

+                   data to be written, and a 32-bit unsigned int that is

+                   the number of bytes to be written.  The new write

+                   function should call png_error(png_ptr, "Error msg")

+                   to exit and output any fatal error messages.

+   flush_data_fn - pointer to a new flush function that takes as its

+                   arguments a pointer to a png_struct.  After a call to

+                   the flush function, there should be no data in any buffers

+                   or pending transmission.  If the output method doesn't do

+                   any buffering of ouput, a function prototype must still be

+                   supplied although it doesn't have to do anything.  If

+                   PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile

+                   time, output_flush_fn will be ignored, although it must be

+                   supplied for compatibility. */

+void PNGAPI

+png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,

+   png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)

+{

+   png_ptr->io_ptr = io_ptr;

+#if !defined(PNG_NO_STDIO)

+   if (write_data_fn != NULL)

+      png_ptr->write_data_fn = write_data_fn;

+   else

+      png_ptr->write_data_fn = png_default_write_data;

+#else

+   png_ptr->write_data_fn = write_data_fn;

+#endif

+#if defined(PNG_WRITE_FLUSH_SUPPORTED)

+#if !defined(PNG_NO_STDIO)

+   if (output_flush_fn != NULL)

+      png_ptr->output_flush_fn = output_flush_fn;

+   else

+      png_ptr->output_flush_fn = png_default_flush;

+#else

+   png_ptr->output_flush_fn = output_flush_fn;

+#endif

+#endif /* PNG_WRITE_FLUSH_SUPPORTED */

+   /* It is an error to read while writing a png file */

+   if (png_ptr->read_data_fn != NULL)

+   {

+      png_ptr->read_data_fn = NULL;

+      png_warning(png_ptr,

+         "Attempted to set both read_data_fn and write_data_fn in");

+      png_warning(png_ptr,

+         "the same structure.  Resetting read_data_fn to NULL.");

+   }

+}

+#if defined(USE_FAR_KEYWORD)

+#if defined(_MSC_VER)

+void *png_far_to_near(png_structp png_ptr,png_voidp ptr, int check)

+{

+   void *near_ptr;

+   void FAR *far_ptr;

+   FP_OFF(near_ptr) = FP_OFF(ptr);

+   far_ptr = (void FAR *)near_ptr;

+   if(check != 0)

+      if(FP_SEG(ptr) != FP_SEG(far_ptr))

+         png_error(png_ptr,"segment lost in conversion");

+   return(near_ptr);

+}

+#  else

+void *png_far_to_near(png_structp png_ptr,png_voidp ptr, int check)

+{

+   void *near_ptr;

+   void FAR *far_ptr;

+   near_ptr = (void FAR *)ptr;

+   far_ptr = (void FAR *)near_ptr;

+   if(check != 0)

+      if(far_ptr != ptr)

+         png_error(png_ptr,"segment lost in conversion");

+   return(near_ptr);

+}

+#   endif

+#   endif

+#endif /* PNG_WRITE_SUPPORTED */

--- /dev/null

+++ b/src/gfx/libpng/pngwrite.c

@@ -1,0 +1,1465 @@

+/* pngwrite.c - general routines to write a PNG file

+ *

+ * libpng 1.2.8 - December 3, 2004

+ * For conditions of distribution and use, see copyright notice in png.h

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

+ */

+/* get internal access to png.h */

+#define PNG_INTERNAL

+#include "png.h"

+#include "zlib.h"

+#ifdef PNG_WRITE_SUPPORTED

+/* Writes all the PNG information.  This is the suggested way to use the

+ * library.  If you have a new chunk to add, make a function to write it,

+ * and put it in the correct location here.  If you want the chunk written

+ * after the image data, put it in png_write_end().  I strongly encourage

+ * you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing

+ * the chunk, as that will keep the code from breaking if you want to just

+ * write a plain PNG file.  If you have long comments, I suggest writing

+ * them in png_write_end(), and compressing them.

+ */

+void PNGAPI

+png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)

+{

+   png_debug(1, "in png_write_info_before_PLTE\n");

+   if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))

+   {

+   png_write_sig(png_ptr); /* write PNG signature */

+#if defined(PNG_MNG_FEATURES_SUPPORTED)

+   if((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&(png_ptr->mng_features_permitted))

+   {

+      png_warning(png_ptr,"MNG features are not allowed in a PNG datastream\n");

+      png_ptr->mng_features_permitted=0;

+   }

+#endif

+   /* write IHDR information. */

+   png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height,

+      info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type,

+      info_ptr->filter_type,

+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)

+      info_ptr->interlace_type);

+#else

+      0);

+#endif

+   /* the rest of these check to see if the valid field has the appropriate

+      flag set, and if it does, writes the chunk. */

+#if defined(PNG_WRITE_gAMA_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_gAMA)

+   {

+#  ifdef PNG_FLOATING_POINT_SUPPORTED

+      png_write_gAMA(png_ptr, info_ptr->gamma);

+#else

+#ifdef PNG_FIXED_POINT_SUPPORTED

+      png_write_gAMA_fixed(png_ptr, info_ptr->int_gamma);

+#  endif

+#endif

+   }

+#endif

+#if defined(PNG_WRITE_sRGB_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_sRGB)

+      png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent);

+#endif

+#if defined(PNG_WRITE_iCCP_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_iCCP)

+      png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE,

+                     info_ptr->iccp_profile, (int)info_ptr->iccp_proflen);

+#endif

+#if defined(PNG_WRITE_sBIT_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_sBIT)

+      png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);

+#endif

+#if defined(PNG_WRITE_cHRM_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_cHRM)

+   {

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+      png_write_cHRM(png_ptr,

+         info_ptr->x_white, info_ptr->y_white,

+         info_ptr->x_red, info_ptr->y_red,

+         info_ptr->x_green, info_ptr->y_green,

+         info_ptr->x_blue, info_ptr->y_blue);

+#else

+#  ifdef PNG_FIXED_POINT_SUPPORTED

+      png_write_cHRM_fixed(png_ptr,

+         info_ptr->int_x_white, info_ptr->int_y_white,

+         info_ptr->int_x_red, info_ptr->int_y_red,

+         info_ptr->int_x_green, info_ptr->int_y_green,

+         info_ptr->int_x_blue, info_ptr->int_y_blue);

+#  endif

+#endif

+   }

+#endif

+#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)

+   if (info_ptr->unknown_chunks_num)

+   {

+       png_unknown_chunk *up;

+       png_debug(5, "writing extra chunks\n");

+       for (up = info_ptr->unknown_chunks;

+            up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;

+            up++)

+       {

+         int keep=png_handle_as_unknown(png_ptr, up->name);

+         if (keep != PNG_HANDLE_CHUNK_NEVER &&

+            up->location && !(up->location & PNG_HAVE_PLTE) &&

+            !(up->location & PNG_HAVE_IDAT) &&

+            ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||

+            (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))

+         {

+            png_write_chunk(png_ptr, up->name, up->data, up->size);

+         }

+       }

+   }

+#endif

+      png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE;

+   }

+}

+void PNGAPI

+png_write_info(png_structp png_ptr, png_infop info_ptr)

+{

+#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)

+   int i;

+#endif

+   png_debug(1, "in png_write_info\n");

+   png_write_info_before_PLTE(png_ptr, info_ptr);

+   if (info_ptr->valid & PNG_INFO_PLTE)

+      png_write_PLTE(png_ptr, info_ptr->palette,

+         (png_uint_32)info_ptr->num_palette);

+   else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+      png_error(png_ptr, "Valid palette required for paletted images\n");

+#if defined(PNG_WRITE_tRNS_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_tRNS)

+      {

+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)

+         /* invert the alpha channel (in tRNS) */

+         if ((png_ptr->transformations & PNG_INVERT_ALPHA) &&

+            info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+         {

+            int j;

+            for (j=0; j<(int)info_ptr->num_trans; j++)

+               info_ptr->trans[j] = (png_byte)(255 - info_ptr->trans[j]);

+         }

+#endif

+      png_write_tRNS(png_ptr, info_ptr->trans, &(info_ptr->trans_values),

+         info_ptr->num_trans, info_ptr->color_type);

+      }

+#endif

+#if defined(PNG_WRITE_bKGD_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_bKGD)

+      png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type);

+#endif

+#if defined(PNG_WRITE_hIST_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_hIST)

+      png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette);

+#endif

+#if defined(PNG_WRITE_oFFs_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_oFFs)

+      png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset,

+         info_ptr->offset_unit_type);

+#endif

+#if defined(PNG_WRITE_pCAL_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_pCAL)

+      png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0,

+         info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams,

+         info_ptr->pcal_units, info_ptr->pcal_params);

+#endif

+#if defined(PNG_WRITE_sCAL_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_sCAL)

+#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)

+      png_write_sCAL(png_ptr, (int)info_ptr->scal_unit,

+          info_ptr->scal_pixel_width, info_ptr->scal_pixel_height);

+#else

+#ifdef PNG_FIXED_POINT_SUPPORTED

+      png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit,

+          info_ptr->scal_s_width, info_ptr->scal_s_height);

+#else

+      png_warning(png_ptr,

+          "png_write_sCAL not supported; sCAL chunk not written.\n");

+#endif

+#endif

+#endif

+#if defined(PNG_WRITE_pHYs_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_pHYs)

+      png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit,

+         info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type);

+#endif

+#if defined(PNG_WRITE_tIME_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_tIME)

+   {

+      png_write_tIME(png_ptr, &(info_ptr->mod_time));

+      png_ptr->mode |= PNG_WROTE_tIME;

+   }

+#endif

+#if defined(PNG_WRITE_sPLT_SUPPORTED)

+   if (info_ptr->valid & PNG_INFO_sPLT)

+     for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)

+       png_write_sPLT(png_ptr, info_ptr->splt_palettes + i);

+#endif

+#if defined(PNG_WRITE_TEXT_SUPPORTED)

+   /* Check to see if we need to write text chunks */

+   for (i = 0; i < info_ptr->num_text; i++)

+   {

+      png_debug2(2, "Writing header text chunk %d, type %d\n", i,

+         info_ptr->text[i].compression);

+      /* an internationalized chunk? */

+      if (info_ptr->text[i].compression > 0)

+      {

+#if defined(PNG_WRITE_iTXt_SUPPORTED)

+          /* write international chunk */

+          png_write_iTXt(png_ptr,

+                         info_ptr->text[i].compression,

+                         info_ptr->text[i].key,

+                         info_ptr->text[i].lang,

+                         info_ptr->text[i].lang_key,

+                         info_ptr->text[i].text);

+#else

+          png_warning(png_ptr, "Unable to write international text\n");

+#endif

+          /* Mark this chunk as written */

+          info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;

+      }

+      /* If we want a compressed text chunk */

+      else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)

+      {

+#if defined(PNG_WRITE_zTXt_SUPPORTED)

+         /* write compressed chunk */

+         png_write_zTXt(png_ptr, info_ptr->text[i].key,

+            info_ptr->text[i].text, 0,

+            info_ptr->text[i].compression);

+#else

+         png_warning(png_ptr, "Unable to write compressed text\n");

+#endif

+         /* Mark this chunk as written */

+         info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;

+      }

+      else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)

+      {

+#if defined(PNG_WRITE_tEXt_SUPPORTED)

+         /* write uncompressed chunk */

+         png_write_tEXt(png_ptr, info_ptr->text[i].key,

+                         info_ptr->text[i].text,

+                         0);

+#else

+         png_warning(png_ptr, "Unable to write uncompressed text\n");

+#endif

+         /* Mark this chunk as written */

+         info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;

+      }

+   }

+#endif

+#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)

+   if (info_ptr->unknown_chunks_num)

+   {

+       png_unknown_chunk *up;

+       png_debug(5, "writing extra chunks\n");

+       for (up = info_ptr->unknown_chunks;

+            up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;

+            up++)

+       {

+         int keep=png_handle_as_unknown(png_ptr, up->name);

+         if (keep != PNG_HANDLE_CHUNK_NEVER &&

+            up->location && (up->location & PNG_HAVE_PLTE) &&

+            !(up->location & PNG_HAVE_IDAT) &&

+            ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||

+            (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))

+         {

+            png_write_chunk(png_ptr, up->name, up->data, up->size);

+         }

+       }

+   }

+#endif

+}

+/* Writes the end of the PNG file.  If you don't want to write comments or

+ * time information, you can pass NULL for info.  If you already wrote these

+ * in png_write_info(), do not write them again here.  If you have long

+ * comments, I suggest writing them here, and compressing them.

+ */

+void PNGAPI

+png_write_end(png_structp png_ptr, png_infop info_ptr)

+{

+   png_debug(1, "in png_write_end\n");

+   if (!(png_ptr->mode & PNG_HAVE_IDAT))

+      png_error(png_ptr, "No IDATs written into file");

+   /* see if user wants us to write information chunks */

+   if (info_ptr != NULL)

+   {

+#if defined(PNG_WRITE_TEXT_SUPPORTED)

+      int i; /* local index variable */

+#endif

+#if defined(PNG_WRITE_tIME_SUPPORTED)

+      /* check to see if user has supplied a time chunk */

+      if ((info_ptr->valid & PNG_INFO_tIME) &&

+         !(png_ptr->mode & PNG_WROTE_tIME))

+         png_write_tIME(png_ptr, &(info_ptr->mod_time));

+#endif

+#if defined(PNG_WRITE_TEXT_SUPPORTED)

+      /* loop through comment chunks */

+      for (i = 0; i < info_ptr->num_text; i++)

+      {

+         png_debug2(2, "Writing trailer text chunk %d, type %d\n", i,

+            info_ptr->text[i].compression);

+         /* an internationalized chunk? */

+         if (info_ptr->text[i].compression > 0)

+         {

+#if defined(PNG_WRITE_iTXt_SUPPORTED)

+             /* write international chunk */

+             png_write_iTXt(png_ptr,

+                         info_ptr->text[i].compression,

+                         info_ptr->text[i].key,

+                         info_ptr->text[i].lang,

+                         info_ptr->text[i].lang_key,

+                         info_ptr->text[i].text);

+#else

+             png_warning(png_ptr, "Unable to write international text\n");

+#endif

+             /* Mark this chunk as written */

+             info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;

+         }

+         else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt)

+         {

+#if defined(PNG_WRITE_zTXt_SUPPORTED)

+            /* write compressed chunk */

+            png_write_zTXt(png_ptr, info_ptr->text[i].key,

+               info_ptr->text[i].text, 0,

+               info_ptr->text[i].compression);

+#else

+            png_warning(png_ptr, "Unable to write compressed text\n");

+#endif

+            /* Mark this chunk as written */

+            info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;

+         }

+         else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)

+         {

+#if defined(PNG_WRITE_tEXt_SUPPORTED)

+            /* write uncompressed chunk */

+            png_write_tEXt(png_ptr, info_ptr->text[i].key,

+               info_ptr->text[i].text, 0);

+#else

+            png_warning(png_ptr, "Unable to write uncompressed text\n");

+#endif

+            /* Mark this chunk as written */

+            info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;

+         }

+      }

+#endif

+#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)

+   if (info_ptr->unknown_chunks_num)

+   {

+       png_unknown_chunk *up;

+       png_debug(5, "writing extra chunks\n");

+       for (up = info_ptr->unknown_chunks;

+            up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;

+            up++)

+       {

+         int keep=png_handle_as_unknown(png_ptr, up->name);

+         if (keep != PNG_HANDLE_CHUNK_NEVER &&

+            up->location && (up->location & PNG_AFTER_IDAT) &&

+            ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||

+            (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))

+         {

+            png_write_chunk(png_ptr, up->name, up->data, up->size);

+         }

+       }

+   }

+#endif

+   }

+   png_ptr->mode |= PNG_AFTER_IDAT;

+   /* write end of PNG file */

+   png_write_IEND(png_ptr);

+#if 0

+/* This flush, added in libpng-1.0.8,  causes some applications to crash

+   because they do not set png_ptr->output_flush_fn */

+   png_flush(png_ptr);

+#endif

+}

+#if defined(PNG_WRITE_tIME_SUPPORTED)

+#if !defined(_WIN32_WCE)

+/* "time.h" functions are not supported on WindowsCE */

+void PNGAPI

+png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime)

+{

+   png_debug(1, "in png_convert_from_struct_tm\n");

+   ptime->year = (png_uint_16)(1900 + ttime->tm_year);

+   ptime->month = (png_byte)(ttime->tm_mon + 1);

+   ptime->day = (png_byte)ttime->tm_mday;

+   ptime->hour = (png_byte)ttime->tm_hour;

+   ptime->minute = (png_byte)ttime->tm_min;

+   ptime->second = (png_byte)ttime->tm_sec;

+}

+void PNGAPI

+png_convert_from_time_t(png_timep ptime, time_t ttime)

+{

+   struct tm *tbuf;

+   png_debug(1, "in png_convert_from_time_t\n");

+   tbuf = gmtime(&ttime);

+   png_convert_from_struct_tm(ptime, tbuf);

+}

+#endif

+#endif

+/* Initialize png_ptr structure, and allocate any memory needed */

+png_structp PNGAPI

+png_create_write_struct(png_const_charp user_png_ver, png_voidp error_ptr,

+   png_error_ptr error_fn, png_error_ptr warn_fn)

+{

+#ifdef PNG_USER_MEM_SUPPORTED

+   return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn,

+      warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL));

+}

+/* Alternate initialize png_ptr structure, and allocate any memory needed */

+png_structp PNGAPI

+png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,

+   png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

+   png_malloc_ptr malloc_fn, png_free_ptr free_fn)

+{

+#endif /* PNG_USER_MEM_SUPPORTED */

+   png_structp png_ptr;

+#ifdef PNG_SETJMP_SUPPORTED

+#ifdef USE_FAR_KEYWORD

+   jmp_buf jmpbuf;

+#endif

+#endif

+   int i;

+   png_debug(1, "in png_create_write_struct\n");

+#ifdef PNG_USER_MEM_SUPPORTED

+   png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,

+      (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);

+#else

+   png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);

+#endif /* PNG_USER_MEM_SUPPORTED */

+   if (png_ptr == NULL)

+      return (NULL);

+#if !defined(PNG_1_0_X)

+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED

+   png_init_mmx_flags(png_ptr);   /* 1.2.0 addition */

+#endif

+#endif /* PNG_1_0_X */

+   /* added at libpng-1.2.6 */

+#ifdef PNG_SET_USER_LIMITS_SUPPORTED

+   png_ptr->user_width_max=PNG_USER_WIDTH_MAX;

+   png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;

+#endif

+#ifdef PNG_SETJMP_SUPPORTED

+#ifdef USE_FAR_KEYWORD

+   if (setjmp(jmpbuf))

+#else

+   if (setjmp(png_ptr->jmpbuf))

+#endif

+   {

+      png_free(png_ptr, png_ptr->zbuf);

+      png_ptr->zbuf=NULL;

+      png_destroy_struct(png_ptr);

+      return (NULL);

+   }

+#ifdef USE_FAR_KEYWORD

+   png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf));

+#endif

+#endif

+#ifdef PNG_USER_MEM_SUPPORTED

+   png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);

+#endif /* PNG_USER_MEM_SUPPORTED */

+   png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);

+   i=0;

+   do

+   {

+     if(user_png_ver[i] != png_libpng_ver[i])

+        png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;

+   } while (png_libpng_ver[i++]);

+   if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)

+   {

+     /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so

+      * we must recompile any applications that use any older library version.

+      * For versions after libpng 1.0, we will be compatible, so we need

+      * only check the first digit.

+      */

+     if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||

+         (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||

+         (user_png_ver[0] == '0' && user_png_ver[2] < '9'))

+     {

+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)

+        char msg[80];

+        if (user_png_ver)

+        {

+          sprintf(msg, "Application was compiled with png.h from libpng-%.20s",

+             user_png_ver);

+          png_warning(png_ptr, msg);

+        }

+        sprintf(msg, "Application  is  running with png.c from libpng-%.20s",

+           png_libpng_ver);

+        png_warning(png_ptr, msg);

+#endif

+#ifdef PNG_ERROR_NUMBERS_SUPPORTED

+        png_ptr->flags=0;

+#endif

+        png_error(png_ptr,

+           "Incompatible libpng version in application and library");

+     }

+   }

+   /* initialize zbuf - compression buffer */

+   png_ptr->zbuf_size = PNG_ZBUF_SIZE;

+   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,

+      (png_uint_32)png_ptr->zbuf_size);

+   png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL,

+      png_flush_ptr_NULL);

+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)

+   png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,

+      1, png_doublep_NULL, png_doublep_NULL);

+#endif

+#ifdef PNG_SETJMP_SUPPORTED

+/* Applications that neglect to set up their own setjmp() and then encounter

+   a png_error() will longjmp here.  Since the jmpbuf is then meaningless we

+   abort instead of returning. */

+#ifdef USE_FAR_KEYWORD

+   if (setjmp(jmpbuf))

+      PNG_ABORT();

+   png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf));

+#else

+   if (setjmp(png_ptr->jmpbuf))

+      PNG_ABORT();

+#endif

+#endif

+   return (png_ptr);

+}

+/* Initialize png_ptr structure, and allocate any memory needed */

+#undef png_write_init

+void PNGAPI

+png_write_init(png_structp png_ptr)

+{

+   /* We only come here via pre-1.0.7-compiled applications */

+   png_write_init_2(png_ptr, "1.0.6 or earlier", 0, 0);

+}

+void PNGAPI

+png_write_init_2(png_structp png_ptr, png_const_charp user_png_ver,

+   png_size_t png_struct_size, png_size_t png_info_size)

+{

+   /* We only come here via pre-1.0.12-compiled applications */

+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)

+   if(png_sizeof(png_struct) > png_struct_size ||

+      png_sizeof(png_info) > png_info_size)

+   {

+      char msg[80];

+      png_ptr->warning_fn=NULL;

+      if (user_png_ver)

+      {

+        sprintf(msg, "Application was compiled with png.h from libpng-%.20s",

+           user_png_ver);

+        png_warning(png_ptr, msg);

+      }

+      sprintf(msg, "Application  is  running with png.c from libpng-%.20s",

+         png_libpng_ver);

+      png_warning(png_ptr, msg);

+   }

+#endif

+   if(png_sizeof(png_struct) > png_struct_size)

+     {

+       png_ptr->error_fn=NULL;

+#ifdef PNG_ERROR_NUMBERS_SUPPORTED

+       png_ptr->flags=0;

+#endif

+       png_error(png_ptr,

+       "The png struct allocated by the application for writing is too small.");

+     }

+   if(png_sizeof(png_info) > png_info_size)

+     {

+       png_ptr->error_fn=NULL;

+#ifdef PNG_ERROR_NUMBERS_SUPPORTED

+       png_ptr->flags=0;

+#endif

+       png_error(png_ptr,

+       "The info struct allocated by the application for writing is too small.");

+     }

+   png_write_init_3(&png_ptr, user_png_ver, png_struct_size);

+}

+void PNGAPI

+png_write_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,

+   png_size_t png_struct_size)

+{

+   png_structp png_ptr=*ptr_ptr;

+#ifdef PNG_SETJMP_SUPPORTED

+   jmp_buf tmp_jmp; /* to save current jump buffer */

+#endif

+   int i = 0;

+   do

+   {

+     if (user_png_ver[i] != png_libpng_ver[i])

+     {

+#ifdef PNG_LEGACY_SUPPORTED

+       png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;

+#else

+       png_ptr->warning_fn=NULL;

+       png_warning(png_ptr,

+     "Application uses deprecated png_write_init() and should be recompiled.");

+       break;

+#endif

+     }

+   } while (png_libpng_ver[i++]);

+   png_debug(1, "in png_write_init_3\n");

+#ifdef PNG_SETJMP_SUPPORTED

+   /* save jump buffer and error functions */

+   png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof (jmp_buf));

+#endif

+   if (png_sizeof(png_struct) > png_struct_size)

+     {

+       png_destroy_struct(png_ptr);

+       png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);

+       *ptr_ptr = png_ptr;

+     }

+   /* reset all variables to 0 */

+   png_memset(png_ptr, 0, png_sizeof (png_struct));

+   /* added at libpng-1.2.6 */

+#ifdef PNG_SET_USER_LIMITS_SUPPORTED

+   png_ptr->user_width_max=PNG_USER_WIDTH_MAX;

+   png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;

+#endif

+#if !defined(PNG_1_0_X)

+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED

+   png_init_mmx_flags(png_ptr);   /* 1.2.0 addition */

+#endif

+#endif /* PNG_1_0_X */

+#ifdef PNG_SETJMP_SUPPORTED

+   /* restore jump buffer */

+   png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof (jmp_buf));

+#endif

+   png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL,

+      png_flush_ptr_NULL);

+   /* initialize zbuf - compression buffer */

+   png_ptr->zbuf_size = PNG_ZBUF_SIZE;

+   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,

+      (png_uint_32)png_ptr->zbuf_size);

+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)

+   png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,

+      1, png_doublep_NULL, png_doublep_NULL);

+#endif

+}

+/* Write a few rows of image data.  If the image is interlaced,

+ * either you will have to write the 7 sub images, or, if you

+ * have called png_set_interlace_handling(), you will have to

+ * "write" the image seven times.

+ */

+void PNGAPI

+png_write_rows(png_structp png_ptr, png_bytepp row,

+   png_uint_32 num_rows)

+{

+   png_uint_32 i; /* row counter */

+   png_bytepp rp; /* row pointer */

+   png_debug(1, "in png_write_rows\n");

+   /* loop through the rows */

+   for (i = 0, rp = row; i < num_rows; i++, rp++)

+   {

+      png_write_row(png_ptr, *rp);

+   }

+}

+/* Write the image.  You only need to call this function once, even

+ * if you are writing an interlaced image.

+ */

+void PNGAPI

+png_write_image(png_structp png_ptr, png_bytepp image)

+{

+   png_uint_32 i; /* row index */

+   int pass, num_pass; /* pass variables */

+   png_bytepp rp; /* points to current row */

+   png_debug(1, "in png_write_image\n");

+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)

+   /* intialize interlace handling.  If image is not interlaced,

+      this will set pass to 1 */

+   num_pass = png_set_interlace_handling(png_ptr);

+#else

+   num_pass = 1;

+#endif

+   /* loop through passes */

+   for (pass = 0; pass < num_pass; pass++)

+   {

+      /* loop through image */

+      for (i = 0, rp = image; i < png_ptr->height; i++, rp++)

+      {

+         png_write_row(png_ptr, *rp);

+      }

+   }

+}

+/* called by user to write a row of image data */

+void PNGAPI

+png_write_row(png_structp png_ptr, png_bytep row)

+{

+   png_debug2(1, "in png_write_row (row %ld, pass %d)\n",

+      png_ptr->row_number, png_ptr->pass);

+   /* initialize transformations and other stuff if first time */

+   if (png_ptr->row_number == 0 && png_ptr->pass == 0)

+   {

+   /* make sure we wrote the header info */

+   if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))

+      png_error(png_ptr,

+         "png_write_info was never called before png_write_row.");

+   /* check for transforms that have been set but were defined out */

+#if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED)

+   if (png_ptr->transformations & PNG_INVERT_MONO)

+      png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined.");

+#endif

+#if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED)

+   if (png_ptr->transformations & PNG_FILLER)

+      png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined.");

+#endif

+#if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && defined(PNG_READ_PACKSWAP_SUPPORTED)

+   if (png_ptr->transformations & PNG_PACKSWAP)

+      png_warning(png_ptr, "PNG_WRITE_PACKSWAP_SUPPORTED is not defined.");

+#endif

+#if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED)

+   if (png_ptr->transformations & PNG_PACK)

+      png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined.");

+#endif

+#if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED)

+   if (png_ptr->transformations & PNG_SHIFT)

+      png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined.");

+#endif

+#if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED)

+   if (png_ptr->transformations & PNG_BGR)

+      png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined.");

+#endif

+#if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED)

+   if (png_ptr->transformations & PNG_SWAP_BYTES)

+      png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined.");

+#endif

+      png_write_start_row(png_ptr);

+   }

+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)

+   /* if interlaced and not interested in row, return */

+   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))

+   {

+      switch (png_ptr->pass)

+      {

+         case 0:

+            if (png_ptr->row_number & 0x07)

+            {

+               png_write_finish_row(png_ptr);

+               return;

+            }

+            break;

+         case 1:

+            if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)

+            {

+               png_write_finish_row(png_ptr);

+               return;

+            }

+            break;

+         case 2:

+            if ((png_ptr->row_number & 0x07) != 4)

+            {

+               png_write_finish_row(png_ptr);

+               return;

+            }

+            break;

+         case 3:

+            if ((png_ptr->row_number & 0x03) || png_ptr->width < 3)

+            {

+               png_write_finish_row(png_ptr);

+               return;

+            }

+            break;

+         case 4:

+            if ((png_ptr->row_number & 0x03) != 2)

+            {

+               png_write_finish_row(png_ptr);

+               return;

+            }

+            break;

+         case 5:

+            if ((png_ptr->row_number & 0x01) || png_ptr->width < 2)

+            {

+               png_write_finish_row(png_ptr);

+               return;

+            }

+            break;

+         case 6:

+            if (!(png_ptr->row_number & 0x01))

+            {

+               png_write_finish_row(png_ptr);

+               return;

+            }

+            break;

+      }

+   }

+#endif

+   /* set up row info for transformations */

+   png_ptr->row_info.color_type = png_ptr->color_type;

+   png_ptr->row_info.width = png_ptr->usr_width;

+   png_ptr->row_info.channels = png_ptr->usr_channels;

+   png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth;

+   png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *

+      png_ptr->row_info.channels);

+   png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,

+      png_ptr->row_info.width);

+   png_debug1(3, "row_info->color_type = %d\n", png_ptr->row_info.color_type);

+   png_debug1(3, "row_info->width = %lu\n", png_ptr->row_info.width);

+   png_debug1(3, "row_info->channels = %d\n", png_ptr->row_info.channels);

+   png_debug1(3, "row_info->bit_depth = %d\n", png_ptr->row_info.bit_depth);

+   png_debug1(3, "row_info->pixel_depth = %d\n", png_ptr->row_info.pixel_depth);

+   png_debug1(3, "row_info->rowbytes = %lu\n", png_ptr->row_info.rowbytes);

+   /* Copy user's row into buffer, leaving room for filter byte. */

+   png_memcpy_check(png_ptr, png_ptr->row_buf + 1, row,

+      png_ptr->row_info.rowbytes);

+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)

+   /* handle interlacing */

+   if (png_ptr->interlaced && png_ptr->pass < 6 &&

+      (png_ptr->transformations & PNG_INTERLACE))

+   {

+      png_do_write_interlace(&(png_ptr->row_info),

+         png_ptr->row_buf + 1, png_ptr->pass);

+      /* this should always get caught above, but still ... */

+      if (!(png_ptr->row_info.width))

+      {

+         png_write_finish_row(png_ptr);

+         return;

+      }

+   }

+#endif

+   /* handle other transformations */

+   if (png_ptr->transformations)

+      png_do_write_transformations(png_ptr);

+#if defined(PNG_MNG_FEATURES_SUPPORTED)

+   /* Write filter_method 64 (intrapixel differencing) only if

+    * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and

+    * 2. Libpng did not write a PNG signature (this filter_method is only

+    *    used in PNG datastreams that are embedded in MNG datastreams) and

+    * 3. The application called png_permit_mng_features with a mask that

+    *    included PNG_FLAG_MNG_FILTER_64 and

+    * 4. The filter_method is 64 and

+    * 5. The color_type is RGB or RGBA

+    */

+   if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&

+      (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))

+   {

+      /* Intrapixel differencing */

+      png_do_write_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);

+   }

+#endif

+   /* Find a filter if necessary, filter the row and write it out. */

+   png_write_find_filter(png_ptr, &(png_ptr->row_info));

+   if (png_ptr->write_row_fn != NULL)

+      (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);

+}

+#if defined(PNG_WRITE_FLUSH_SUPPORTED)

+/* Set the automatic flush interval or 0 to turn flushing off */

+void PNGAPI

+png_set_flush(png_structp png_ptr, int nrows)

+{

+   png_debug(1, "in png_set_flush\n");

+   png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);

+}

+/* flush the current output buffers now */

+void PNGAPI

+png_write_flush(png_structp png_ptr)

+{

+   int wrote_IDAT;

+   png_debug(1, "in png_write_flush\n");

+   /* We have already written out all of the data */

+   if (png_ptr->row_number >= png_ptr->num_rows)

+     return;

+   do

+   {

+      int ret;

+      /* compress the data */

+      ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH);

+      wrote_IDAT = 0;

+      /* check for compression errors */

+      if (ret != Z_OK)

+      {

+         if (png_ptr->zstream.msg != NULL)

+            png_error(png_ptr, png_ptr->zstream.msg);

+         else

+            png_error(png_ptr, "zlib error");

+      }

+      if (!(png_ptr->zstream.avail_out))

+      {

+         /* write the IDAT and reset the zlib output buffer */

+         png_write_IDAT(png_ptr, png_ptr->zbuf,

+                        png_ptr->zbuf_size);

+         png_ptr->zstream.next_out = png_ptr->zbuf;

+         png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+         wrote_IDAT = 1;

+      }

+   } while(wrote_IDAT == 1);

+   /* If there is any data left to be output, write it into a new IDAT */

+   if (png_ptr->zbuf_size != png_ptr->zstream.avail_out)

+   {

+      /* write the IDAT and reset the zlib output buffer */

+      png_write_IDAT(png_ptr, png_ptr->zbuf,

+                     png_ptr->zbuf_size - png_ptr->zstream.avail_out);

+      png_ptr->zstream.next_out = png_ptr->zbuf;

+      png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+   }

+   png_ptr->flush_rows = 0;

+   png_flush(png_ptr);

+}

+#endif /* PNG_WRITE_FLUSH_SUPPORTED */

+/* free all memory used by the write */

+void PNGAPI

+png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)

+{

+   png_structp png_ptr = NULL;

+   png_infop info_ptr = NULL;

+#ifdef PNG_USER_MEM_SUPPORTED

+   png_free_ptr free_fn = NULL;

+   png_voidp mem_ptr = NULL;

+#endif

+   png_debug(1, "in png_destroy_write_struct\n");

+   if (png_ptr_ptr != NULL)

+   {

+      png_ptr = *png_ptr_ptr;

+#ifdef PNG_USER_MEM_SUPPORTED

+      free_fn = png_ptr->free_fn;

+      mem_ptr = png_ptr->mem_ptr;

+#endif

+   }

+   if (info_ptr_ptr != NULL)

+      info_ptr = *info_ptr_ptr;

+   if (info_ptr != NULL)

+   {

+      png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);

+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)

+      if (png_ptr->num_chunk_list)

+      {

+         png_free(png_ptr, png_ptr->chunk_list);

+         png_ptr->chunk_list=NULL;

+         png_ptr->num_chunk_list=0;

+      }

+#endif

+#ifdef PNG_USER_MEM_SUPPORTED

+      png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,

+         (png_voidp)mem_ptr);

+#else

+      png_destroy_struct((png_voidp)info_ptr);

+#endif

+      *info_ptr_ptr = NULL;

+   }

+   if (png_ptr != NULL)

+   {

+      png_write_destroy(png_ptr);

+#ifdef PNG_USER_MEM_SUPPORTED

+      png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,

+         (png_voidp)mem_ptr);

+#else

+      png_destroy_struct((png_voidp)png_ptr);

+#endif

+      *png_ptr_ptr = NULL;

+   }

+}

+/* Free any memory used in png_ptr struct (old method) */

+void /* PRIVATE */

+png_write_destroy(png_structp png_ptr)

+{

+#ifdef PNG_SETJMP_SUPPORTED

+   jmp_buf tmp_jmp; /* save jump buffer */

+#endif

+   png_error_ptr error_fn;

+   png_error_ptr warning_fn;

+   png_voidp error_ptr;

+#ifdef PNG_USER_MEM_SUPPORTED

+   png_free_ptr free_fn;

+#endif

+   png_debug(1, "in png_write_destroy\n");

+   /* free any memory zlib uses */

+   deflateEnd(&png_ptr->zstream);

+   /* free our memory.  png_free checks NULL for us. */

+   png_free(png_ptr, png_ptr->zbuf);

+   png_free(png_ptr, png_ptr->row_buf);

+   png_free(png_ptr, png_ptr->prev_row);

+   png_free(png_ptr, png_ptr->sub_row);

+   png_free(png_ptr, png_ptr->up_row);

+   png_free(png_ptr, png_ptr->avg_row);

+   png_free(png_ptr, png_ptr->paeth_row);

+#if defined(PNG_TIME_RFC1123_SUPPORTED)

+   png_free(png_ptr, png_ptr->time_buffer);

+#endif

+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)

+   png_free(png_ptr, png_ptr->prev_filters);

+   png_free(png_ptr, png_ptr->filter_weights);

+   png_free(png_ptr, png_ptr->inv_filter_weights);

+   png_free(png_ptr, png_ptr->filter_costs);

+   png_free(png_ptr, png_ptr->inv_filter_costs);

+#endif

+#ifdef PNG_SETJMP_SUPPORTED

+   /* reset structure */

+   png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof (jmp_buf));

+#endif

+   error_fn = png_ptr->error_fn;

+   warning_fn = png_ptr->warning_fn;

+   error_ptr = png_ptr->error_ptr;

+#ifdef PNG_USER_MEM_SUPPORTED

+   free_fn = png_ptr->free_fn;

+#endif

+   png_memset(png_ptr, 0, png_sizeof (png_struct));

+   png_ptr->error_fn = error_fn;

+   png_ptr->warning_fn = warning_fn;

+   png_ptr->error_ptr = error_ptr;

+#ifdef PNG_USER_MEM_SUPPORTED

+   png_ptr->free_fn = free_fn;

+#endif

+#ifdef PNG_SETJMP_SUPPORTED

+   png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof (jmp_buf));

+#endif

+}

+/* Allow the application to select one or more row filters to use. */

+void PNGAPI

+png_set_filter(png_structp png_ptr, int method, int filters)

+{

+   png_debug(1, "in png_set_filter\n");

+#if defined(PNG_MNG_FEATURES_SUPPORTED)

+   if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&

+      (method == PNG_INTRAPIXEL_DIFFERENCING))

+         method = PNG_FILTER_TYPE_BASE;

+#endif

+   if (method == PNG_FILTER_TYPE_BASE)

+   {

+      switch (filters & (PNG_ALL_FILTERS | 0x07))

+      {

+         case 5:

+         case 6:

+         case 7: png_warning(png_ptr, "Unknown row filter for method 0");

+         case PNG_FILTER_VALUE_NONE:  png_ptr->do_filter=PNG_FILTER_NONE; break;

+         case PNG_FILTER_VALUE_SUB:   png_ptr->do_filter=PNG_FILTER_SUB;  break;

+         case PNG_FILTER_VALUE_UP:    png_ptr->do_filter=PNG_FILTER_UP;   break;

+         case PNG_FILTER_VALUE_AVG:   png_ptr->do_filter=PNG_FILTER_AVG;  break;

+         case PNG_FILTER_VALUE_PAETH: png_ptr->do_filter=PNG_FILTER_PAETH;break;

+         default: png_ptr->do_filter = (png_byte)filters; break;

+      }

+      /* If we have allocated the row_buf, this means we have already started

+       * with the image and we should have allocated all of the filter buffers

+       * that have been selected.  If prev_row isn't already allocated, then

+       * it is too late to start using the filters that need it, since we

+       * will be missing the data in the previous row.  If an application

+       * wants to start and stop using particular filters during compression,

+       * it should start out with all of the filters, and then add and

+       * remove them after the start of compression.

+       */

+      if (png_ptr->row_buf != NULL)

+      {

+         if ((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL)

+         {

+            png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,

+              (png_ptr->rowbytes + 1));

+            png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;

+         }

+         if ((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL)

+         {

+            if (png_ptr->prev_row == NULL)

+            {

+               png_warning(png_ptr, "Can't add Up filter after starting");

+               png_ptr->do_filter &= ~PNG_FILTER_UP;

+            }

+            else

+            {

+               png_ptr->up_row = (png_bytep)png_malloc(png_ptr,

+                  (png_ptr->rowbytes + 1));

+               png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;

+            }

+         }

+         if ((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL)

+         {

+            if (png_ptr->prev_row == NULL)

+            {

+               png_warning(png_ptr, "Can't add Average filter after starting");

+               png_ptr->do_filter &= ~PNG_FILTER_AVG;

+            }

+            else

+            {

+               png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,

+                  (png_ptr->rowbytes + 1));

+               png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;

+            }

+         }

+         if ((png_ptr->do_filter & PNG_FILTER_PAETH) &&

+             png_ptr->paeth_row == NULL)

+         {

+            if (png_ptr->prev_row == NULL)

+            {

+               png_warning(png_ptr, "Can't add Paeth filter after starting");

+               png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH);

+            }

+            else

+            {

+               png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,

+                  (png_ptr->rowbytes + 1));

+               png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;

+            }

+         }

+         if (png_ptr->do_filter == PNG_NO_FILTERS)

+            png_ptr->do_filter = PNG_FILTER_NONE;

+      }

+   }

+   else

+      png_error(png_ptr, "Unknown custom filter method");

+}

+/* This allows us to influence the way in which libpng chooses the "best"

+ * filter for the current scanline.  While the "minimum-sum-of-absolute-

+ * differences metric is relatively fast and effective, there is some

+ * question as to whether it can be improved upon by trying to keep the

+ * filtered data going to zlib more consistent, hopefully resulting in

+ * better compression.

+ */

+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)      /* GRR 970116 */

+void PNGAPI

+png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,

+   int num_weights, png_doublep filter_weights,

+   png_doublep filter_costs)

+{

+   int i;

+   png_debug(1, "in png_set_filter_heuristics\n");

+   if (heuristic_method >= PNG_FILTER_HEURISTIC_LAST)

+   {

+      png_warning(png_ptr, "Unknown filter heuristic method");

+      return;

+   }

+   if (heuristic_method == PNG_FILTER_HEURISTIC_DEFAULT)

+   {

+      heuristic_method = PNG_FILTER_HEURISTIC_UNWEIGHTED;

+   }

+   if (num_weights < 0 || filter_weights == NULL ||

+      heuristic_method == PNG_FILTER_HEURISTIC_UNWEIGHTED)

+   {

+      num_weights = 0;

+   }

+   png_ptr->num_prev_filters = (png_byte)num_weights;

+   png_ptr->heuristic_method = (png_byte)heuristic_method;

+   if (num_weights > 0)

+   {

+      if (png_ptr->prev_filters == NULL)

+      {

+         png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr,

+            (png_uint_32)(png_sizeof(png_byte) * num_weights));

+         /* To make sure that the weighting starts out fairly */

+         for (i = 0; i < num_weights; i++)

+         {

+            png_ptr->prev_filters[i] = 255;

+         }

+      }

+      if (png_ptr->filter_weights == NULL)

+      {

+         png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr,

+            (png_uint_32)(png_sizeof(png_uint_16) * num_weights));

+         png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr,

+            (png_uint_32)(png_sizeof(png_uint_16) * num_weights));

+         for (i = 0; i < num_weights; i++)

+         {

+            png_ptr->inv_filter_weights[i] =

+            png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;

+         }

+      }

+      for (i = 0; i < num_weights; i++)

+      {

+         if (filter_weights[i] < 0.0)

+         {

+            png_ptr->inv_filter_weights[i] =

+            png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;

+         }

+         else

+         {

+            png_ptr->inv_filter_weights[i] =

+               (png_uint_16)((double)PNG_WEIGHT_FACTOR*filter_weights[i]+0.5);

+            png_ptr->filter_weights[i] =

+               (png_uint_16)((double)PNG_WEIGHT_FACTOR/filter_weights[i]+0.5);

+         }

+      }

+   }

+   /* If, in the future, there are other filter methods, this would

+    * need to be based on png_ptr->filter.

+    */

+   if (png_ptr->filter_costs == NULL)

+   {

+      png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr,

+         (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));

+      png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr,

+         (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));

+      for (i = 0; i < PNG_FILTER_VALUE_LAST; i++)

+      {

+         png_ptr->inv_filter_costs[i] =

+         png_ptr->filter_costs[i] = PNG_COST_FACTOR;

+      }

+   }

+   /* Here is where we set the relative costs of the different filters.  We

+    * should take the desired compression level into account when setting

+    * the costs, so that Paeth, for instance, has a high relative cost at low

+    * compression levels, while it has a lower relative cost at higher

+    * compression settings.  The filter types are in order of increasing

+    * relative cost, so it would be possible to do this with an algorithm.

+    */

+   for (i = 0; i < PNG_FILTER_VALUE_LAST; i++)

+   {

+      if (filter_costs == NULL || filter_costs[i] < 0.0)

+      {

+         png_ptr->inv_filter_costs[i] =

+         png_ptr->filter_costs[i] = PNG_COST_FACTOR;

+      }

+      else if (filter_costs[i] >= 1.0)

+      {

+         png_ptr->inv_filter_costs[i] =

+            (png_uint_16)((double)PNG_COST_FACTOR / filter_costs[i] + 0.5);

+         png_ptr->filter_costs[i] =

+            (png_uint_16)((double)PNG_COST_FACTOR * filter_costs[i] + 0.5);

+      }

+   }

+}

+#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */

+void PNGAPI

+png_set_compression_level(png_structp png_ptr, int level)

+{

+   png_debug(1, "in png_set_compression_level\n");

+   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL;

+   png_ptr->zlib_level = level;

+}

+void PNGAPI

+png_set_compression_mem_level(png_structp png_ptr, int mem_level)

+{

+   png_debug(1, "in png_set_compression_mem_level\n");

+   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL;

+   png_ptr->zlib_mem_level = mem_level;

+}

+void PNGAPI

+png_set_compression_strategy(png_structp png_ptr, int strategy)

+{

+   png_debug(1, "in png_set_compression_strategy\n");

+   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;

+   png_ptr->zlib_strategy = strategy;

+}

+void PNGAPI

+png_set_compression_window_bits(png_structp png_ptr, int window_bits)

+{

+   if (window_bits > 15)

+      png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");

+   else if (window_bits < 8)

+      png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");

+#ifndef WBITS_8_OK

+   /* avoid libpng bug with 256-byte windows */

+   if (window_bits == 8)

+     {

+       png_warning(png_ptr, "Compression window is being reset to 512");

+       window_bits=9;

+     }

+#endif

+   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS;

+   png_ptr->zlib_window_bits = window_bits;

+}

+void PNGAPI

+png_set_compression_method(png_structp png_ptr, int method)

+{

+   png_debug(1, "in png_set_compression_method\n");

+   if (method != 8)

+      png_warning(png_ptr, "Only compression method 8 is supported by PNG");

+   png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_METHOD;

+   png_ptr->zlib_method = method;

+}

+void PNGAPI

+png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn)

+{

+   png_ptr->write_row_fn = write_row_fn;

+}

+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

+void PNGAPI

+png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr

+   write_user_transform_fn)

+{

+   png_debug(1, "in png_set_write_user_transform_fn\n");

+   png_ptr->transformations |= PNG_USER_TRANSFORM;

+   png_ptr->write_user_transform_fn = write_user_transform_fn;

+}

+#endif

+#if defined(PNG_INFO_IMAGE_SUPPORTED)

+void PNGAPI

+png_write_png(png_structp png_ptr, png_infop info_ptr,

+              int transforms, png_voidp params)

+{

+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)

+   /* invert the alpha channel from opacity to transparency */

+   if (transforms & PNG_TRANSFORM_INVERT_ALPHA)

+       png_set_invert_alpha(png_ptr);

+#endif

+   /* Write the file header information. */

+   png_write_info(png_ptr, info_ptr);

+   /* ------ these transformations don't touch the info structure ------- */

+#if defined(PNG_WRITE_INVERT_SUPPORTED)

+   /* invert monochrome pixels */

+   if (transforms & PNG_TRANSFORM_INVERT_MONO)

+       png_set_invert_mono(png_ptr);

+#endif

+#if defined(PNG_WRITE_SHIFT_SUPPORTED)

+   /* Shift the pixels up to a legal bit depth and fill in

+    * as appropriate to correctly scale the image.

+    */

+   if ((transforms & PNG_TRANSFORM_SHIFT)

+               && (info_ptr->valid & PNG_INFO_sBIT))

+       png_set_shift(png_ptr, &info_ptr->sig_bit);

+#endif

+#if defined(PNG_WRITE_PACK_SUPPORTED)

+   /* pack pixels into bytes */

+   if (transforms & PNG_TRANSFORM_PACKING)

+       png_set_packing(png_ptr);

+#endif

+#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)

+   /* swap location of alpha bytes from ARGB to RGBA */

+   if (transforms & PNG_TRANSFORM_SWAP_ALPHA)

+       png_set_swap_alpha(png_ptr);

+#endif

+#if defined(PNG_WRITE_FILLER_SUPPORTED)

+   /* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into

+    * RGB (4 channels -> 3 channels). The second parameter is not used.

+    */

+   if (transforms & PNG_TRANSFORM_STRIP_FILLER)

+       png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);

+#endif

+#if defined(PNG_WRITE_BGR_SUPPORTED)

+   /* flip BGR pixels to RGB */

+   if (transforms & PNG_TRANSFORM_BGR)

+       png_set_bgr(png_ptr);

+#endif

+#if defined(PNG_WRITE_SWAP_SUPPORTED)

+   /* swap bytes of 16-bit files to most significant byte first */

+   if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)

+       png_set_swap(png_ptr);

+#endif

+#if defined(PNG_WRITE_PACKSWAP_SUPPORTED)

+   /* swap bits of 1, 2, 4 bit packed pixel formats */

+   if (transforms & PNG_TRANSFORM_PACKSWAP)

+       png_set_packswap(png_ptr);

+#endif

+   /* ----------------------- end of transformations ------------------- */

+   /* write the bits */

+   if (info_ptr->valid & PNG_INFO_IDAT)

+       png_write_image(png_ptr, info_ptr->row_pointers);

+   /* It is REQUIRED to call this to finish writing the rest of the file */

+   png_write_end(png_ptr, info_ptr);

+   if(transforms == 0 || params == NULL)

+      /* quiet compiler warnings */ return;

+}

+#endif

+#endif /* PNG_WRITE_SUPPORTED */

--- /dev/null

+++ b/src/gfx/libpng/pngwtran.c

@@ -1,0 +1,563 @@

+/* pngwtran.c - transforms the data in a row for PNG writers

+ *

+ * libpng version 1.2.8 - December 3, 2004

+ * For conditions of distribution and use, see copyright notice in png.h

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

+ */

+#define PNG_INTERNAL

+#include "png.h"

+#ifdef PNG_WRITE_SUPPORTED

+/* Transform the data according to the user's wishes.  The order of

+ * transformations is significant.

+ */

+void /* PRIVATE */

+png_do_write_transformations(png_structp png_ptr)

+{

+   png_debug(1, "in png_do_write_transformations\n");

+   if (png_ptr == NULL)

+      return;

+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

+   if (png_ptr->transformations & PNG_USER_TRANSFORM)

+      if(png_ptr->write_user_transform_fn != NULL)

+        (*(png_ptr->write_user_transform_fn)) /* user write transform function */

+          (png_ptr,                    /* png_ptr */

+           &(png_ptr->row_info),       /* row_info:     */

+             /*  png_uint_32 width;          width of row */

+             /*  png_uint_32 rowbytes;       number of bytes in row */

+             /*  png_byte color_type;        color type of pixels */

+             /*  png_byte bit_depth;         bit depth of samples */

+             /*  png_byte channels;          number of channels (1-4) */

+             /*  png_byte pixel_depth;       bits per pixel (depth*channels) */

+           png_ptr->row_buf + 1);      /* start of pixel data for row */

+#endif

+#if defined(PNG_WRITE_FILLER_SUPPORTED)

+   if (png_ptr->transformations & PNG_FILLER)

+      png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,

+         png_ptr->flags);

+#endif

+#if defined(PNG_WRITE_PACKSWAP_SUPPORTED)

+   if (png_ptr->transformations & PNG_PACKSWAP)

+      png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);

+#endif

+#if defined(PNG_WRITE_PACK_SUPPORTED)

+   if (png_ptr->transformations & PNG_PACK)

+      png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1,

+         (png_uint_32)png_ptr->bit_depth);

+#endif

+#if defined(PNG_WRITE_SWAP_SUPPORTED)

+   if (png_ptr->transformations & PNG_SWAP_BYTES)

+      png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);

+#endif

+#if defined(PNG_WRITE_SHIFT_SUPPORTED)

+   if (png_ptr->transformations & PNG_SHIFT)

+      png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1,

+         &(png_ptr->shift));

+#endif

+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)

+   if (png_ptr->transformations & PNG_INVERT_ALPHA)

+      png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);

+#endif

+#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)

+   if (png_ptr->transformations & PNG_SWAP_ALPHA)

+      png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);

+#endif

+#if defined(PNG_WRITE_BGR_SUPPORTED)

+   if (png_ptr->transformations & PNG_BGR)

+      png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);

+#endif

+#if defined(PNG_WRITE_INVERT_SUPPORTED)

+   if (png_ptr->transformations & PNG_INVERT_MONO)

+      png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);

+#endif

+}

+#if defined(PNG_WRITE_PACK_SUPPORTED)

+/* Pack pixels into bytes.  Pass the true bit depth in bit_depth.  The

+ * row_info bit depth should be 8 (one pixel per byte).  The channels

+ * should be 1 (this only happens on grayscale and paletted images).

+ */

+void /* PRIVATE */

+png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)

+{

+   png_debug(1, "in png_do_pack\n");

+   if (row_info->bit_depth == 8 &&

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+       row != NULL && row_info != NULL &&

+#endif

+      row_info->channels == 1)

+   {

+      switch ((int)bit_depth)

+      {

+         case 1:

+         {

+            png_bytep sp, dp;

+            int mask, v;

+            png_uint_32 i;

+            png_uint_32 row_width = row_info->width;

+            sp = row;

+            dp = row;

+            mask = 0x80;

+            v = 0;

+            for (i = 0; i < row_width; i++)

+            {

+               if (*sp != 0)

+                  v |= mask;

+               sp++;

+               if (mask > 1)

+                  mask >>= 1;

+               else

+               {

+                  mask = 0x80;

+                  *dp = (png_byte)v;

+                  dp++;

+                  v = 0;

+               }

+            }

+            if (mask != 0x80)

+               *dp = (png_byte)v;

+            break;

+         }

+         case 2:

+         {

+            png_bytep sp, dp;

+            int shift, v;

+            png_uint_32 i;

+            png_uint_32 row_width = row_info->width;

+            sp = row;

+            dp = row;

+            shift = 6;

+            v = 0;

+            for (i = 0; i < row_width; i++)

+            {

+               png_byte value;

+               value = (png_byte)(*sp & 0x03);

+               v |= (value << shift);

+               if (shift == 0)

+               {

+                  shift = 6;

+                  *dp = (png_byte)v;

+                  dp++;

+                  v = 0;

+               }

+               else

+                  shift -= 2;

+               sp++;

+            }

+            if (shift != 6)

+               *dp = (png_byte)v;

+            break;

+         }

+         case 4:

+         {

+            png_bytep sp, dp;

+            int shift, v;

+            png_uint_32 i;

+            png_uint_32 row_width = row_info->width;

+            sp = row;

+            dp = row;

+            shift = 4;

+            v = 0;

+            for (i = 0; i < row_width; i++)

+            {

+               png_byte value;

+               value = (png_byte)(*sp & 0x0f);

+               v |= (value << shift);

+               if (shift == 0)

+               {

+                  shift = 4;

+                  *dp = (png_byte)v;

+                  dp++;

+                  v = 0;

+               }

+               else

+                  shift -= 4;

+               sp++;

+            }

+            if (shift != 4)

+               *dp = (png_byte)v;

+            break;

+         }

+      }

+      row_info->bit_depth = (png_byte)bit_depth;

+      row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels);

+      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,

+         row_info->width);

+   }

+}

+#endif

+#if defined(PNG_WRITE_SHIFT_SUPPORTED)

+/* Shift pixel values to take advantage of whole range.  Pass the

+ * true number of bits in bit_depth.  The row should be packed

+ * according to row_info->bit_depth.  Thus, if you had a row of

+ * bit depth 4, but the pixels only had values from 0 to 7, you

+ * would pass 3 as bit_depth, and this routine would translate the

+ * data to 0 to 15.

+ */

+void /* PRIVATE */

+png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)

+{

+   png_debug(1, "in png_do_shift\n");

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+   if (row != NULL && row_info != NULL &&

+#else

+   if (

+#endif

+      row_info->color_type != PNG_COLOR_TYPE_PALETTE)

+   {

+      int shift_start[4], shift_dec[4];

+      int channels = 0;

+      if (row_info->color_type & PNG_COLOR_MASK_COLOR)

+      {

+         shift_start[channels] = row_info->bit_depth - bit_depth->red;

+         shift_dec[channels] = bit_depth->red;

+         channels++;

+         shift_start[channels] = row_info->bit_depth - bit_depth->green;

+         shift_dec[channels] = bit_depth->green;

+         channels++;

+         shift_start[channels] = row_info->bit_depth - bit_depth->blue;

+         shift_dec[channels] = bit_depth->blue;

+         channels++;

+      }

+      else

+      {

+         shift_start[channels] = row_info->bit_depth - bit_depth->gray;

+         shift_dec[channels] = bit_depth->gray;

+         channels++;

+      }

+      if (row_info->color_type & PNG_COLOR_MASK_ALPHA)

+      {

+         shift_start[channels] = row_info->bit_depth - bit_depth->alpha;

+         shift_dec[channels] = bit_depth->alpha;

+         channels++;

+      }

+      /* with low row depths, could only be grayscale, so one channel */

+      if (row_info->bit_depth < 8)

+      {

+         png_bytep bp = row;

+         png_uint_32 i;

+         png_byte mask;

+         png_uint_32 row_bytes = row_info->rowbytes;

+         if (bit_depth->gray == 1 && row_info->bit_depth == 2)

+            mask = 0x55;

+         else if (row_info->bit_depth == 4 && bit_depth->gray == 3)

+            mask = 0x11;

+         else

+            mask = 0xff;

+         for (i = 0; i < row_bytes; i++, bp++)

+         {

+            png_uint_16 v;

+            int j;

+            v = *bp;

+            *bp = 0;

+            for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0])

+            {

+               if (j > 0)

+                  *bp |= (png_byte)((v << j) & 0xff);

+               else

+                  *bp |= (png_byte)((v >> (-j)) & mask);

+            }

+         }

+      }

+      else if (row_info->bit_depth == 8)

+      {

+         png_bytep bp = row;

+         png_uint_32 i;

+         png_uint_32 istop = channels * row_info->width;

+         for (i = 0; i < istop; i++, bp++)

+         {

+            png_uint_16 v;

+            int j;

+            int c = (int)(i%channels);

+            v = *bp;

+            *bp = 0;

+            for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])

+            {

+               if (j > 0)

+                  *bp |= (png_byte)((v << j) & 0xff);

+               else

+                  *bp |= (png_byte)((v >> (-j)) & 0xff);

+            }

+         }

+      }

+      else

+      {

+         png_bytep bp;

+         png_uint_32 i;

+         png_uint_32 istop = channels * row_info->width;

+         for (bp = row, i = 0; i < istop; i++)

+         {

+            int c = (int)(i%channels);

+            png_uint_16 value, v;

+            int j;

+            v = (png_uint_16)(((png_uint_16)(*bp) << 8) + *(bp + 1));

+            value = 0;

+            for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])

+            {

+               if (j > 0)

+                  value |= (png_uint_16)((v << j) & (png_uint_16)0xffff);

+               else

+                  value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff);

+            }

+            *bp++ = (png_byte)(value >> 8);

+            *bp++ = (png_byte)(value & 0xff);

+         }

+      }

+   }

+}

+#endif

+#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)

+void /* PRIVATE */

+png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)

+{

+   png_debug(1, "in png_do_write_swap_alpha\n");

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+   if (row != NULL && row_info != NULL)

+#endif

+   {

+      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+      {

+         /* This converts from ARGB to RGBA */

+         if (row_info->bit_depth == 8)

+         {

+            png_bytep sp, dp;

+            png_uint_32 i;

+            png_uint_32 row_width = row_info->width;

+            for (i = 0, sp = dp = row; i < row_width; i++)

+            {

+               png_byte save = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = save;

+            }

+         }

+         /* This converts from AARRGGBB to RRGGBBAA */

+         else

+         {

+            png_bytep sp, dp;

+            png_uint_32 i;

+            png_uint_32 row_width = row_info->width;

+            for (i = 0, sp = dp = row; i < row_width; i++)

+            {

+               png_byte save[2];

+               save[0] = *(sp++);

+               save[1] = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = save[0];

+               *(dp++) = save[1];

+            }

+         }

+      }

+      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

+      {

+         /* This converts from AG to GA */

+         if (row_info->bit_depth == 8)

+         {

+            png_bytep sp, dp;

+            png_uint_32 i;

+            png_uint_32 row_width = row_info->width;

+            for (i = 0, sp = dp = row; i < row_width; i++)

+            {

+               png_byte save = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = save;

+            }

+         }

+         /* This converts from AAGG to GGAA */

+         else

+         {

+            png_bytep sp, dp;

+            png_uint_32 i;

+            png_uint_32 row_width = row_info->width;

+            for (i = 0, sp = dp = row; i < row_width; i++)

+            {

+               png_byte save[2];

+               save[0] = *(sp++);

+               save[1] = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = save[0];

+               *(dp++) = save[1];

+            }

+         }

+      }

+   }

+}

+#endif

+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)

+void /* PRIVATE */

+png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)

+{

+   png_debug(1, "in png_do_write_invert_alpha\n");

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+   if (row != NULL && row_info != NULL)

+#endif

+   {

+      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+      {

+         /* This inverts the alpha channel in RGBA */

+         if (row_info->bit_depth == 8)

+         {

+            png_bytep sp, dp;

+            png_uint_32 i;

+            png_uint_32 row_width = row_info->width;

+            for (i = 0, sp = dp = row; i < row_width; i++)

+            {

+               *(dp++) = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = (png_byte)(255 - *(sp++));

+            }

+         }

+         /* This inverts the alpha channel in RRGGBBAA */

+         else

+         {

+            png_bytep sp, dp;

+            png_uint_32 i;

+            png_uint_32 row_width = row_info->width;

+            for (i = 0, sp = dp = row; i < row_width; i++)

+            {

+               *(dp++) = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = (png_byte)(255 - *(sp++));

+               *(dp++) = (png_byte)(255 - *(sp++));

+            }

+         }

+      }

+      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

+      {

+         /* This inverts the alpha channel in GA */

+         if (row_info->bit_depth == 8)

+         {

+            png_bytep sp, dp;

+            png_uint_32 i;

+            png_uint_32 row_width = row_info->width;

+            for (i = 0, sp = dp = row; i < row_width; i++)

+            {

+               *(dp++) = *(sp++);

+               *(dp++) = (png_byte)(255 - *(sp++));

+            }

+         }

+         /* This inverts the alpha channel in GGAA */

+         else

+         {

+            png_bytep sp, dp;

+            png_uint_32 i;

+            png_uint_32 row_width = row_info->width;

+            for (i = 0, sp = dp = row; i < row_width; i++)

+            {

+               *(dp++) = *(sp++);

+               *(dp++) = *(sp++);

+               *(dp++) = (png_byte)(255 - *(sp++));

+               *(dp++) = (png_byte)(255 - *(sp++));

+            }

+         }

+      }

+   }

+}

+#endif

+#if defined(PNG_MNG_FEATURES_SUPPORTED)

+/* undoes intrapixel differencing  */

+void /* PRIVATE */

+png_do_write_intrapixel(png_row_infop row_info, png_bytep row)

+{

+   png_debug(1, "in png_do_write_intrapixel\n");

+   if (

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+       row != NULL && row_info != NULL &&

+#endif

+       (row_info->color_type & PNG_COLOR_MASK_COLOR))

+   {

+      int bytes_per_pixel;

+      png_uint_32 row_width = row_info->width;

+      if (row_info->bit_depth == 8)

+      {

+         png_bytep rp;

+         png_uint_32 i;

+         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

+            bytes_per_pixel = 3;

+         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+            bytes_per_pixel = 4;

+         else

+            return;

+         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

+         {

+            *(rp)   = (png_byte)((*rp     - *(rp+1))&0xff);

+            *(rp+2) = (png_byte)((*(rp+2) - *(rp+1))&0xff);

+         }

+      }

+      else if (row_info->bit_depth == 16)

+      {

+         png_bytep rp;

+         png_uint_32 i;

+         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

+            bytes_per_pixel = 6;

+         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

+            bytes_per_pixel = 8;

+         else

+            return;

+         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

+         {

+            png_uint_32 s0   = (*(rp  ) << 8) | *(rp+1);

+            png_uint_32 s1   = (*(rp+2) << 8) | *(rp+3);

+            png_uint_32 s2   = (*(rp+4) << 8) | *(rp+5);

+            png_uint_32 red  = (png_uint_32)((s0-s1) & 0xffffL);

+            png_uint_32 blue = (png_uint_32)((s2-s1) & 0xffffL);

+            *(rp  ) = (png_byte)((red >> 8) & 0xff);

+            *(rp+1) = (png_byte)(red & 0xff);

+            *(rp+4) = (png_byte)((blue >> 8) & 0xff);

+            *(rp+5) = (png_byte)(blue & 0xff);

+         }

+      }

+   }

+}

+#endif /* PNG_MNG_FEATURES_SUPPORTED */

+#endif /* PNG_WRITE_SUPPORTED */

--- /dev/null

+++ b/src/gfx/libpng/pngwutil.c

@@ -1,0 +1,2730 @@

+/* pngwutil.c - utilities to write a PNG file

+ *

+ * libpng version 1.2.8 - December 3, 2004

+ * For conditions of distribution and use, see copyright notice in png.h

+ * Copyright (c) 1998-2004 Glenn Randers-Pehrson

+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

+ */

+#define PNG_INTERNAL

+#include "png.h"

+#ifdef PNG_WRITE_SUPPORTED

+/* Place a 32-bit number into a buffer in PNG byte order.  We work

+ * with unsigned numbers for convenience, although one supported

+ * ancillary chunk uses signed (two's complement) numbers.

+ */

+void /* PRIVATE */

+png_save_uint_32(png_bytep buf, png_uint_32 i)

+{

+   buf[0] = (png_byte)((i >> 24) & 0xff);

+   buf[1] = (png_byte)((i >> 16) & 0xff);

+   buf[2] = (png_byte)((i >> 8) & 0xff);

+   buf[3] = (png_byte)(i & 0xff);

+}

+#if defined(PNG_WRITE_pCAL_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED)

+/* The png_save_int_32 function assumes integers are stored in two's

+ * complement format.  If this isn't the case, then this routine needs to

+ * be modified to write data in two's complement format.

+ */

+void /* PRIVATE */

+png_save_int_32(png_bytep buf, png_int_32 i)

+{

+   buf[0] = (png_byte)((i >> 24) & 0xff);

+   buf[1] = (png_byte)((i >> 16) & 0xff);

+   buf[2] = (png_byte)((i >> 8) & 0xff);

+   buf[3] = (png_byte)(i & 0xff);

+}

+#endif

+/* Place a 16-bit number into a buffer in PNG byte order.

+ * The parameter is declared unsigned int, not png_uint_16,

+ * just to avoid potential problems on pre-ANSI C compilers.

+ */

+void /* PRIVATE */

+png_save_uint_16(png_bytep buf, unsigned int i)

+{

+   buf[0] = (png_byte)((i >> 8) & 0xff);

+   buf[1] = (png_byte)(i & 0xff);

+}

+/* Write a PNG chunk all at once.  The type is an array of ASCII characters

+ * representing the chunk name.  The array must be at least 4 bytes in

+ * length, and does not need to be null terminated.  To be safe, pass the

+ * pre-defined chunk names here, and if you need a new one, define it

+ * where the others are defined.  The length is the length of the data.

+ * All the data must be present.  If that is not possible, use the

+ * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end()

+ * functions instead.

+ */

+void PNGAPI

+png_write_chunk(png_structp png_ptr, png_bytep chunk_name,

+   png_bytep data, png_size_t length)

+{

+   png_write_chunk_start(png_ptr, chunk_name, (png_uint_32)length);

+   png_write_chunk_data(png_ptr, data, length);

+   png_write_chunk_end(png_ptr);

+}

+/* Write the start of a PNG chunk.  The type is the chunk type.

+ * The total_length is the sum of the lengths of all the data you will be

+ * passing in png_write_chunk_data().

+ */

+void PNGAPI

+png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,

+   png_uint_32 length)

+{

+   png_byte buf[4];

+   png_debug2(0, "Writing %s chunk (%lu bytes)\n", chunk_name, length);

+   /* write the length */

+   png_save_uint_32(buf, length);

+   png_write_data(png_ptr, buf, (png_size_t)4);

+   /* write the chunk name */

+   png_write_data(png_ptr, chunk_name, (png_size_t)4);

+   /* reset the crc and run it over the chunk name */

+   png_reset_crc(png_ptr);

+   png_calculate_crc(png_ptr, chunk_name, (png_size_t)4);

+}

+/* Write the data of a PNG chunk started with png_write_chunk_start().

+ * Note that multiple calls to this function are allowed, and that the

+ * sum of the lengths from these calls *must* add up to the total_length

+ * given to png_write_chunk_start().

+ */

+void PNGAPI

+png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length)

+{

+   /* write the data, and run the CRC over it */

+   if (data != NULL && length > 0)

+   {

+      png_calculate_crc(png_ptr, data, length);

+      png_write_data(png_ptr, data, length);

+   }

+}

+/* Finish a chunk started with png_write_chunk_start(). */

+void PNGAPI

+png_write_chunk_end(png_structp png_ptr)

+{

+   png_byte buf[4];

+   /* write the crc */

+   png_save_uint_32(buf, png_ptr->crc);

+   png_write_data(png_ptr, buf, (png_size_t)4);

+}

+/* Simple function to write the signature.  If we have already written

+ * the magic bytes of the signature, or more likely, the PNG stream is

+ * being embedded into another stream and doesn't need its own signature,

+ * we should call png_set_sig_bytes() to tell libpng how many of the

+ * bytes have already been written.

+ */

+void /* PRIVATE */

+png_write_sig(png_structp png_ptr)

+{

+   png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};

+   /* write the rest of the 8 byte signature */

+   png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],

+      (png_size_t)8 - png_ptr->sig_bytes);

+   if(png_ptr->sig_bytes < 3)

+      png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;

+}

+#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_iCCP_SUPPORTED)

+/*

+ * This pair of functions encapsulates the operation of (a) compressing a

+ * text string, and (b) issuing it later as a series of chunk data writes.

+ * The compression_state structure is shared context for these functions

+ * set up by the caller in order to make the whole mess thread-safe.

+ */

+typedef struct

+{

+    char *input;   /* the uncompressed input data */

+    int input_len;   /* its length */

+    int num_output_ptr; /* number of output pointers used */

+    int max_output_ptr; /* size of output_ptr */

+    png_charpp output_ptr; /* array of pointers to output */

+} compression_state;

+/* compress given text into storage in the png_ptr structure */

+static int /* PRIVATE */

+png_text_compress(png_structp png_ptr,

+        png_charp text, png_size_t text_len, int compression,

+        compression_state *comp)

+{

+   int ret;

+   comp->num_output_ptr = comp->max_output_ptr = 0;

+   comp->output_ptr = NULL;

+   comp->input = NULL;

+   /* we may just want to pass the text right through */

+   if (compression == PNG_TEXT_COMPRESSION_NONE)

+   {

+       comp->input = text;

+       comp->input_len = text_len;

+       return((int)text_len);

+   }

+   if (compression >= PNG_TEXT_COMPRESSION_LAST)

+   {

+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)

+      char msg[50];

+      sprintf(msg, "Unknown compression type %d", compression);

+      png_warning(png_ptr, msg);

+#else

+      png_warning(png_ptr, "Unknown compression type");

+#endif

+   }

+   /* We can't write the chunk until we find out how much data we have,

+    * which means we need to run the compressor first and save the

+    * output.  This shouldn't be a problem, as the vast majority of

+    * comments should be reasonable, but we will set up an array of

+    * malloc'd pointers to be sure.

+    *

+    * If we knew the application was well behaved, we could simplify this

+    * greatly by assuming we can always malloc an output buffer large

+    * enough to hold the compressed text ((1001 * text_len / 1000) + 12)

+    * and malloc this directly.  The only time this would be a bad idea is

+    * if we can't malloc more than 64K and we have 64K of random input

+    * data, or if the input string is incredibly large (although this

+    * wouldn't cause a failure, just a slowdown due to swapping).

+    */

+   /* set up the compression buffers */

+   png_ptr->zstream.avail_in = (uInt)text_len;

+   png_ptr->zstream.next_in = (Bytef *)text;

+   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+   png_ptr->zstream.next_out = (Bytef *)png_ptr->zbuf;

+   /* this is the same compression loop as in png_write_row() */

+   do

+   {

+      /* compress the data */

+      ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);

+      if (ret != Z_OK)

+      {

+         /* error */

+         if (png_ptr->zstream.msg != NULL)

+            png_error(png_ptr, png_ptr->zstream.msg);

+         else

+            png_error(png_ptr, "zlib error");

+      }

+      /* check to see if we need more room */

+      if (!(png_ptr->zstream.avail_out))

+      {

+         /* make sure the output array has room */

+         if (comp->num_output_ptr >= comp->max_output_ptr)

+         {

+            int old_max;

+            old_max = comp->max_output_ptr;

+            comp->max_output_ptr = comp->num_output_ptr + 4;

+            if (comp->output_ptr != NULL)

+            {

+               png_charpp old_ptr;

+               old_ptr = comp->output_ptr;

+               comp->output_ptr = (png_charpp)png_malloc(png_ptr,

+                  (png_uint_32)(comp->max_output_ptr *

+                  png_sizeof (png_charpp)));

+               png_memcpy(comp->output_ptr, old_ptr, old_max

+                  * png_sizeof (png_charp));

+               png_free(png_ptr, old_ptr);

+            }

+            else

+               comp->output_ptr = (png_charpp)png_malloc(png_ptr,

+                  (png_uint_32)(comp->max_output_ptr *

+                  png_sizeof (png_charp)));

+         }

+         /* save the data */

+         comp->output_ptr[comp->num_output_ptr] = (png_charp)png_malloc(png_ptr,

+            (png_uint_32)png_ptr->zbuf_size);

+         png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,

+            png_ptr->zbuf_size);

+         comp->num_output_ptr++;

+         /* and reset the buffer */

+         png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+         png_ptr->zstream.next_out = png_ptr->zbuf;

+      }

+   /* continue until we don't have any more to compress */

+   } while (png_ptr->zstream.avail_in);

+   /* finish the compression */

+   do

+   {

+      /* tell zlib we are finished */

+      ret = deflate(&png_ptr->zstream, Z_FINISH);

+      if (ret == Z_OK)

+      {

+         /* check to see if we need more room */

+         if (!(png_ptr->zstream.avail_out))

+         {

+            /* check to make sure our output array has room */

+            if (comp->num_output_ptr >= comp->max_output_ptr)

+            {

+               int old_max;

+               old_max = comp->max_output_ptr;

+               comp->max_output_ptr = comp->num_output_ptr + 4;

+               if (comp->output_ptr != NULL)

+               {

+                  png_charpp old_ptr;

+                  old_ptr = comp->output_ptr;

+                  /* This could be optimized to realloc() */

+                  comp->output_ptr = (png_charpp)png_malloc(png_ptr,

+                     (png_uint_32)(comp->max_output_ptr *

+                     png_sizeof (png_charpp)));

+                  png_memcpy(comp->output_ptr, old_ptr,

+                     old_max * png_sizeof (png_charp));

+                  png_free(png_ptr, old_ptr);

+               }

+               else

+                  comp->output_ptr = (png_charpp)png_malloc(png_ptr,

+                     (png_uint_32)(comp->max_output_ptr *

+                     png_sizeof (png_charp)));

+            }

+            /* save off the data */

+            comp->output_ptr[comp->num_output_ptr] =

+               (png_charp)png_malloc(png_ptr, (png_uint_32)png_ptr->zbuf_size);

+            png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,

+               png_ptr->zbuf_size);

+            comp->num_output_ptr++;

+            /* and reset the buffer pointers */

+            png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+            png_ptr->zstream.next_out = png_ptr->zbuf;

+         }

+      }

+      else if (ret != Z_STREAM_END)

+      {

+         /* we got an error */

+         if (png_ptr->zstream.msg != NULL)

+            png_error(png_ptr, png_ptr->zstream.msg);

+         else

+            png_error(png_ptr, "zlib error");

+      }

+   } while (ret != Z_STREAM_END);

+   /* text length is number of buffers plus last buffer */

+   text_len = png_ptr->zbuf_size * comp->num_output_ptr;

+   if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)

+      text_len += png_ptr->zbuf_size - (png_size_t)png_ptr->zstream.avail_out;

+   return((int)text_len);

+}

+/* ship the compressed text out via chunk writes */

+static void /* PRIVATE */

+png_write_compressed_data_out(png_structp png_ptr, compression_state *comp)

+{

+   int i;

+   /* handle the no-compression case */

+   if (comp->input)

+   {

+       png_write_chunk_data(png_ptr, (png_bytep)comp->input,

+                            (png_size_t)comp->input_len);

+       return;

+   }

+   /* write saved output buffers, if any */

+   for (i = 0; i < comp->num_output_ptr; i++)

+   {

+      png_write_chunk_data(png_ptr,(png_bytep)comp->output_ptr[i],

+         png_ptr->zbuf_size);

+      png_free(png_ptr, comp->output_ptr[i]);

+      comp->output_ptr[i]=NULL;

+   }

+   if (comp->max_output_ptr != 0)

+      png_free(png_ptr, comp->output_ptr);

+      comp->output_ptr=NULL;

+   /* write anything left in zbuf */

+   if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size)

+      png_write_chunk_data(png_ptr, png_ptr->zbuf,

+         png_ptr->zbuf_size - png_ptr->zstream.avail_out);

+   /* reset zlib for another zTXt/iTXt or image data */

+   deflateReset(&png_ptr->zstream);

+   png_ptr->zstream.data_type = Z_BINARY;

+}

+#endif

+/* Write the IHDR chunk, and update the png_struct with the necessary

+ * information.  Note that the rest of this code depends upon this

+ * information being correct.

+ */

+void /* PRIVATE */

+png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,

+   int bit_depth, int color_type, int compression_type, int filter_type,

+   int interlace_type)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_IHDR;

+#endif

+   png_byte buf[13]; /* buffer to store the IHDR info */

+   png_debug(1, "in png_write_IHDR\n");

+   /* Check that we have valid input data from the application info */

+   switch (color_type)

+   {

+      case PNG_COLOR_TYPE_GRAY:

+         switch (bit_depth)

+         {

+            case 1:

+            case 2:

+            case 4:

+            case 8:

+            case 16: png_ptr->channels = 1; break;

+            default: png_error(png_ptr,"Invalid bit depth for grayscale image");

+         }

+         break;

+      case PNG_COLOR_TYPE_RGB:

+         if (bit_depth != 8 && bit_depth != 16)

+            png_error(png_ptr, "Invalid bit depth for RGB image");

+         png_ptr->channels = 3;

+         break;

+      case PNG_COLOR_TYPE_PALETTE:

+         switch (bit_depth)

+         {

+            case 1:

+            case 2:

+            case 4:

+            case 8: png_ptr->channels = 1; break;

+            default: png_error(png_ptr, "Invalid bit depth for paletted image");

+         }

+         break;

+      case PNG_COLOR_TYPE_GRAY_ALPHA:

+         if (bit_depth != 8 && bit_depth != 16)

+            png_error(png_ptr, "Invalid bit depth for grayscale+alpha image");

+         png_ptr->channels = 2;

+         break;

+      case PNG_COLOR_TYPE_RGB_ALPHA:

+         if (bit_depth != 8 && bit_depth != 16)

+            png_error(png_ptr, "Invalid bit depth for RGBA image");

+         png_ptr->channels = 4;

+         break;

+      default:

+         png_error(png_ptr, "Invalid image color type specified");

+   }

+   if (compression_type != PNG_COMPRESSION_TYPE_BASE)

+   {

+      png_warning(png_ptr, "Invalid compression type specified");

+      compression_type = PNG_COMPRESSION_TYPE_BASE;

+   }

+   /* Write filter_method 64 (intrapixel differencing) only if

+    * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and

+    * 2. Libpng did not write a PNG signature (this filter_method is only

+    *    used in PNG datastreams that are embedded in MNG datastreams) and

+    * 3. The application called png_permit_mng_features with a mask that

+    *    included PNG_FLAG_MNG_FILTER_64 and

+    * 4. The filter_method is 64 and

+    * 5. The color_type is RGB or RGBA

+    */

+   if (

+#if defined(PNG_MNG_FEATURES_SUPPORTED)

+      !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&

+      ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&

+      (color_type == PNG_COLOR_TYPE_RGB ||

+       color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&

+      (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&

+#endif

+      filter_type != PNG_FILTER_TYPE_BASE)

+   {

+      png_warning(png_ptr, "Invalid filter type specified");

+      filter_type = PNG_FILTER_TYPE_BASE;

+   }

+#ifdef PNG_WRITE_INTERLACING_SUPPORTED

+   if (interlace_type != PNG_INTERLACE_NONE &&

+      interlace_type != PNG_INTERLACE_ADAM7)

+   {

+      png_warning(png_ptr, "Invalid interlace type specified");

+      interlace_type = PNG_INTERLACE_ADAM7;

+   }

+#else

+   interlace_type=PNG_INTERLACE_NONE;

+#endif

+   /* save off the relevent information */

+   png_ptr->bit_depth = (png_byte)bit_depth;

+   png_ptr->color_type = (png_byte)color_type;

+   png_ptr->interlaced = (png_byte)interlace_type;

+#if defined(PNG_MNG_FEATURES_SUPPORTED)

+   png_ptr->filter_type = (png_byte)filter_type;

+#endif

+   png_ptr->compression_type = (png_byte)compression_type;

+   png_ptr->width = width;

+   png_ptr->height = height;

+   png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);

+   png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width);

+   /* set the usr info, so any transformations can modify it */

+   png_ptr->usr_width = png_ptr->width;

+   png_ptr->usr_bit_depth = png_ptr->bit_depth;

+   png_ptr->usr_channels = png_ptr->channels;

+   /* pack the header information into the buffer */

+   png_save_uint_32(buf, width);

+   png_save_uint_32(buf + 4, height);

+   buf[8] = (png_byte)bit_depth;

+   buf[9] = (png_byte)color_type;

+   buf[10] = (png_byte)compression_type;

+   buf[11] = (png_byte)filter_type;

+   buf[12] = (png_byte)interlace_type;

+   /* write the chunk */

+   png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13);

+   /* initialize zlib with PNG info */

+   png_ptr->zstream.zalloc = png_zalloc;

+   png_ptr->zstream.zfree = png_zfree;

+   png_ptr->zstream.opaque = (voidpf)png_ptr;

+   if (!(png_ptr->do_filter))

+   {

+      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||

+         png_ptr->bit_depth < 8)

+         png_ptr->do_filter = PNG_FILTER_NONE;

+      else

+         png_ptr->do_filter = PNG_ALL_FILTERS;

+   }

+   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY))

+   {

+      if (png_ptr->do_filter != PNG_FILTER_NONE)

+         png_ptr->zlib_strategy = Z_FILTERED;

+      else

+         png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY;

+   }

+   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_LEVEL))

+      png_ptr->zlib_level = Z_DEFAULT_COMPRESSION;

+   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL))

+      png_ptr->zlib_mem_level = 8;

+   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS))

+      png_ptr->zlib_window_bits = 15;

+   if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD))

+      png_ptr->zlib_method = 8;

+   deflateInit2(&png_ptr->zstream, png_ptr->zlib_level,

+      png_ptr->zlib_method, png_ptr->zlib_window_bits,

+      png_ptr->zlib_mem_level, png_ptr->zlib_strategy);

+   png_ptr->zstream.next_out = png_ptr->zbuf;

+   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+   /* libpng is not interested in zstream.data_type */

+   /* set it to a predefined value, to avoid its evaluation inside zlib */

+   png_ptr->zstream.data_type = Z_BINARY;

+   png_ptr->mode = PNG_HAVE_IHDR;

+}

+/* write the palette.  We are careful not to trust png_color to be in the

+ * correct order for PNG, so people can redefine it to any convenient

+ * structure.

+ */

+void /* PRIVATE */

+png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_PLTE;

+#endif

+   png_uint_32 i;

+   png_colorp pal_ptr;

+   png_byte buf[3];

+   png_debug(1, "in png_write_PLTE\n");

+   if ((

+#if defined(PNG_MNG_FEATURES_SUPPORTED)

+        !(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) &&

+#endif

+        num_pal == 0) || num_pal > 256)

+   {

+     if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

+     {

+        png_error(png_ptr, "Invalid number of colors in palette");

+     }

+     else

+     {

+        png_warning(png_ptr, "Invalid number of colors in palette");

+        return;

+     }

+   }

+   if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))

+   {

+      png_warning(png_ptr,

+        "Ignoring request to write a PLTE chunk in grayscale PNG");

+      return;

+   }

+   png_ptr->num_palette = (png_uint_16)num_pal;

+   png_debug1(3, "num_palette = %d\n", png_ptr->num_palette);

+   png_write_chunk_start(png_ptr, (png_bytep)png_PLTE, num_pal * 3);

+#ifndef PNG_NO_POINTER_INDEXING

+   for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)

+   {

+      buf[0] = pal_ptr->red;

+      buf[1] = pal_ptr->green;

+      buf[2] = pal_ptr->blue;

+      png_write_chunk_data(png_ptr, buf, (png_size_t)3);

+   }

+#else

+   /* This is a little slower but some buggy compilers need to do this instead */

+   pal_ptr=palette;

+   for (i = 0; i < num_pal; i++)

+   {

+      buf[0] = pal_ptr[i].red;

+      buf[1] = pal_ptr[i].green;

+      buf[2] = pal_ptr[i].blue;

+      png_write_chunk_data(png_ptr, buf, (png_size_t)3);

+   }

+#endif

+   png_write_chunk_end(png_ptr);

+   png_ptr->mode |= PNG_HAVE_PLTE;

+}

+/* write an IDAT chunk */

+void /* PRIVATE */

+png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_IDAT;

+#endif

+   png_debug(1, "in png_write_IDAT\n");

+   /* Optimize the CMF field in the zlib stream. */

+   /* This hack of the zlib stream is compliant to the stream specification. */

+   if (!(png_ptr->mode & PNG_HAVE_IDAT) &&

+       png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)

+   {

+      unsigned int z_cmf = data[0];  /* zlib compression method and flags */

+      if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70)

+      {

+         /* Avoid memory underflows and multiplication overflows. */

+         /* The conditions below are practically always satisfied;

+            however, they still must be checked. */

+         if (length >= 2 &&

+             png_ptr->height < 16384 && png_ptr->width < 16384)

+         {

+            png_uint_32 uncompressed_idat_size = png_ptr->height *

+               ((png_ptr->width *

+               png_ptr->channels * png_ptr->bit_depth + 15) >> 3);

+            unsigned int z_cinfo = z_cmf >> 4;

+            unsigned int half_z_window_size = 1 << (z_cinfo + 7);

+            while (uncompressed_idat_size <= half_z_window_size &&

+                   half_z_window_size >= 256)

+            {

+               z_cinfo--;

+               half_z_window_size >>= 1;

+            }

+            z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4);

+            if (data[0] != (png_byte)z_cmf)

+            {

+               data[0] = (png_byte)z_cmf;

+               data[1] &= 0xe0;

+               data[1] += (png_byte)(0x1f - ((z_cmf << 8) + data[1]) % 0x1f);

+            }

+         }

+      }

+      else

+         png_error(png_ptr,

+            "Invalid zlib compression method or flags in IDAT");

+   }

+   png_write_chunk(png_ptr, (png_bytep)png_IDAT, data, length);

+   png_ptr->mode |= PNG_HAVE_IDAT;

+}

+/* write an IEND chunk */

+void /* PRIVATE */

+png_write_IEND(png_structp png_ptr)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_IEND;

+#endif

+   png_debug(1, "in png_write_IEND\n");

+   png_write_chunk(png_ptr, (png_bytep)png_IEND, png_bytep_NULL,

+     (png_size_t)0);

+   png_ptr->mode |= PNG_HAVE_IEND;

+}

+#if defined(PNG_WRITE_gAMA_SUPPORTED)

+/* write a gAMA chunk */

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+void /* PRIVATE */

+png_write_gAMA(png_structp png_ptr, double file_gamma)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_gAMA;

+#endif

+   png_uint_32 igamma;

+   png_byte buf[4];

+   png_debug(1, "in png_write_gAMA\n");

+   /* file_gamma is saved in 1/100,000ths */

+   igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5);

+   png_save_uint_32(buf, igamma);

+   png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);

+}

+#endif

+#ifdef PNG_FIXED_POINT_SUPPORTED

+void /* PRIVATE */

+png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_gAMA;

+#endif

+   png_byte buf[4];

+   png_debug(1, "in png_write_gAMA\n");

+   /* file_gamma is saved in 1/100,000ths */

+   png_save_uint_32(buf, (png_uint_32)file_gamma);

+   png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);

+}

+#endif

+#endif

+#if defined(PNG_WRITE_sRGB_SUPPORTED)

+/* write a sRGB chunk */

+void /* PRIVATE */

+png_write_sRGB(png_structp png_ptr, int srgb_intent)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_sRGB;

+#endif

+   png_byte buf[1];

+   png_debug(1, "in png_write_sRGB\n");

+   if(srgb_intent >= PNG_sRGB_INTENT_LAST)

+         png_warning(png_ptr,

+            "Invalid sRGB rendering intent specified");

+   buf[0]=(png_byte)srgb_intent;

+   png_write_chunk(png_ptr, (png_bytep)png_sRGB, buf, (png_size_t)1);

+}

+#endif

+#if defined(PNG_WRITE_iCCP_SUPPORTED)

+/* write an iCCP chunk */

+void /* PRIVATE */

+png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,

+   png_charp profile, int profile_len)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_iCCP;

+#endif

+   png_size_t name_len;

+   png_charp new_name;

+   compression_state comp;

+   png_debug(1, "in png_write_iCCP\n");

+   if (name == NULL || (name_len = png_check_keyword(png_ptr, name,

+      &new_name)) == 0)

+   {

+      png_warning(png_ptr, "Empty keyword in iCCP chunk");

+      return;

+   }

+   if (compression_type != PNG_COMPRESSION_TYPE_BASE)

+      png_warning(png_ptr, "Unknown compression type in iCCP chunk");

+   if (profile == NULL)

+      profile_len = 0;

+   if (profile_len)

+       profile_len = png_text_compress(png_ptr, profile, (png_size_t)profile_len,

+          PNG_COMPRESSION_TYPE_BASE, &comp);

+   /* make sure we include the NULL after the name and the compression type */

+   png_write_chunk_start(png_ptr, (png_bytep)png_iCCP,

+          (png_uint_32)name_len+profile_len+2);

+   new_name[name_len+1]=0x00;

+   png_write_chunk_data(png_ptr, (png_bytep)new_name, name_len + 2);

+   if (profile_len)

+      png_write_compressed_data_out(png_ptr, &comp);

+   png_write_chunk_end(png_ptr);

+   png_free(png_ptr, new_name);

+}

+#endif

+#if defined(PNG_WRITE_sPLT_SUPPORTED)

+/* write a sPLT chunk */

+void /* PRIVATE */

+png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_sPLT;

+#endif

+   png_size_t name_len;

+   png_charp new_name;

+   png_byte entrybuf[10];

+   int entry_size = (spalette->depth == 8 ? 6 : 10);

+   int palette_size = entry_size * spalette->nentries;

+   png_sPLT_entryp ep;

+#ifdef PNG_NO_POINTER_INDEXING

+   int i;

+#endif

+   png_debug(1, "in png_write_sPLT\n");

+   if (spalette->name == NULL || (name_len = png_check_keyword(png_ptr,

+      spalette->name, &new_name))==0)

+   {

+      png_warning(png_ptr, "Empty keyword in sPLT chunk");

+      return;

+   }

+   /* make sure we include the NULL after the name */

+   png_write_chunk_start(png_ptr, (png_bytep)png_sPLT,

+          (png_uint_32)(name_len + 2 + palette_size));

+   png_write_chunk_data(png_ptr, (png_bytep)new_name, name_len + 1);

+   png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, 1);

+   /* loop through each palette entry, writing appropriately */

+#ifndef PNG_NO_POINTER_INDEXING

+   for (ep = spalette->entries; ep<spalette->entries+spalette->nentries; ep++)

+   {

+       if (spalette->depth == 8)

+       {

+           entrybuf[0] = (png_byte)ep->red;

+           entrybuf[1] = (png_byte)ep->green;

+           entrybuf[2] = (png_byte)ep->blue;

+           entrybuf[3] = (png_byte)ep->alpha;

+           png_save_uint_16(entrybuf + 4, ep->frequency);

+       }

+       else

+       {

+           png_save_uint_16(entrybuf + 0, ep->red);

+           png_save_uint_16(entrybuf + 2, ep->green);

+           png_save_uint_16(entrybuf + 4, ep->blue);

+           png_save_uint_16(entrybuf + 6, ep->alpha);

+           png_save_uint_16(entrybuf + 8, ep->frequency);

+       }

+       png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);

+   }

+#else

+   ep=spalette->entries;

+   for (i=0; i>spalette->nentries; i++)

+   {

+       if (spalette->depth == 8)

+       {

+           entrybuf[0] = (png_byte)ep[i].red;

+           entrybuf[1] = (png_byte)ep[i].green;

+           entrybuf[2] = (png_byte)ep[i].blue;

+           entrybuf[3] = (png_byte)ep[i].alpha;

+           png_save_uint_16(entrybuf + 4, ep[i].frequency);

+       }

+       else

+       {

+           png_save_uint_16(entrybuf + 0, ep[i].red);

+           png_save_uint_16(entrybuf + 2, ep[i].green);

+           png_save_uint_16(entrybuf + 4, ep[i].blue);

+           png_save_uint_16(entrybuf + 6, ep[i].alpha);

+           png_save_uint_16(entrybuf + 8, ep[i].frequency);

+       }

+       png_write_chunk_data(png_ptr, entrybuf, entry_size);

+   }

+#endif

+   png_write_chunk_end(png_ptr);

+   png_free(png_ptr, new_name);

+}

+#endif

+#if defined(PNG_WRITE_sBIT_SUPPORTED)

+/* write the sBIT chunk */

+void /* PRIVATE */

+png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_sBIT;

+#endif

+   png_byte buf[4];

+   png_size_t size;

+   png_debug(1, "in png_write_sBIT\n");

+   /* make sure we don't depend upon the order of PNG_COLOR_8 */

+   if (color_type & PNG_COLOR_MASK_COLOR)

+   {

+      png_byte maxbits;

+      maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 :

+                png_ptr->usr_bit_depth);

+      if (sbit->red == 0 || sbit->red > maxbits ||

+          sbit->green == 0 || sbit->green > maxbits ||

+          sbit->blue == 0 || sbit->blue > maxbits)

+      {

+         png_warning(png_ptr, "Invalid sBIT depth specified");

+         return;

+      }

+      buf[0] = sbit->red;

+      buf[1] = sbit->green;

+      buf[2] = sbit->blue;

+      size = 3;

+   }

+   else

+   {

+      if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth)

+      {

+         png_warning(png_ptr, "Invalid sBIT depth specified");

+         return;

+      }

+      buf[0] = sbit->gray;

+      size = 1;

+   }

+   if (color_type & PNG_COLOR_MASK_ALPHA)

+   {

+      if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth)

+      {

+         png_warning(png_ptr, "Invalid sBIT depth specified");

+         return;

+      }

+      buf[size++] = sbit->alpha;

+   }

+   png_write_chunk(png_ptr, (png_bytep)png_sBIT, buf, size);

+}

+#endif

+#if defined(PNG_WRITE_cHRM_SUPPORTED)

+/* write the cHRM chunk */

+#ifdef PNG_FLOATING_POINT_SUPPORTED

+void /* PRIVATE */

+png_write_cHRM(png_structp png_ptr, double white_x, double white_y,

+   double red_x, double red_y, double green_x, double green_y,

+   double blue_x, double blue_y)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_cHRM;

+#endif

+   png_byte buf[32];

+   png_uint_32 itemp;

+   png_debug(1, "in png_write_cHRM\n");

+   /* each value is saved in 1/100,000ths */

+   if (white_x < 0 || white_x > 0.8 || white_y < 0 || white_y > 0.8 ||

+       white_x + white_y > 1.0)

+   {

+      png_warning(png_ptr, "Invalid cHRM white point specified");

+#if !defined(PNG_NO_CONSOLE_IO)

+      fprintf(stderr,"white_x=%f, white_y=%f\n",white_x, white_y);

+#endif

+      return;

+   }

+   itemp = (png_uint_32)(white_x * 100000.0 + 0.5);

+   png_save_uint_32(buf, itemp);

+   itemp = (png_uint_32)(white_y * 100000.0 + 0.5);

+   png_save_uint_32(buf + 4, itemp);

+   if (red_x < 0 || red_x > 0.8 || red_y < 0 || red_y > 0.8 ||

+       red_x + red_y > 1.0)

+   {

+      png_warning(png_ptr, "Invalid cHRM red point specified");

+      return;

+   }

+   itemp = (png_uint_32)(red_x * 100000.0 + 0.5);

+   png_save_uint_32(buf + 8, itemp);

+   itemp = (png_uint_32)(red_y * 100000.0 + 0.5);

+   png_save_uint_32(buf + 12, itemp);

+   if (green_x < 0 || green_x > 0.8 || green_y < 0 || green_y > 0.8 ||

+       green_x + green_y > 1.0)

+   {

+      png_warning(png_ptr, "Invalid cHRM green point specified");

+      return;

+   }

+   itemp = (png_uint_32)(green_x * 100000.0 + 0.5);

+   png_save_uint_32(buf + 16, itemp);

+   itemp = (png_uint_32)(green_y * 100000.0 + 0.5);

+   png_save_uint_32(buf + 20, itemp);

+   if (blue_x < 0 || blue_x > 0.8 || blue_y < 0 || blue_y > 0.8 ||

+       blue_x + blue_y > 1.0)

+   {

+      png_warning(png_ptr, "Invalid cHRM blue point specified");

+      return;

+   }

+   itemp = (png_uint_32)(blue_x * 100000.0 + 0.5);

+   png_save_uint_32(buf + 24, itemp);

+   itemp = (png_uint_32)(blue_y * 100000.0 + 0.5);

+   png_save_uint_32(buf + 28, itemp);

+   png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);

+}

+#endif

+#ifdef PNG_FIXED_POINT_SUPPORTED

+void /* PRIVATE */

+png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x,

+   png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y,

+   png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x,

+   png_fixed_point blue_y)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_cHRM;

+#endif

+   png_byte buf[32];

+   png_debug(1, "in png_write_cHRM\n");

+   /* each value is saved in 1/100,000ths */

+   if (white_x > 80000L || white_y > 80000L || white_x + white_y > 100000L)

+   {

+      png_warning(png_ptr, "Invalid fixed cHRM white point specified");

+#if !defined(PNG_NO_CONSOLE_IO)

+      fprintf(stderr,"white_x=%ld, white_y=%ld\n",white_x, white_y);

+#endif

+      return;

+   }

+   png_save_uint_32(buf, (png_uint_32)white_x);

+   png_save_uint_32(buf + 4, (png_uint_32)white_y);

+   if (red_x > 80000L || red_y > 80000L || red_x + red_y > 100000L)

+   {

+      png_warning(png_ptr, "Invalid cHRM fixed red point specified");

+      return;

+   }

+   png_save_uint_32(buf + 8, (png_uint_32)red_x);

+   png_save_uint_32(buf + 12, (png_uint_32)red_y);

+   if (green_x > 80000L || green_y > 80000L || green_x + green_y > 100000L)

+   {

+      png_warning(png_ptr, "Invalid fixed cHRM green point specified");

+      return;

+   }

+   png_save_uint_32(buf + 16, (png_uint_32)green_x);

+   png_save_uint_32(buf + 20, (png_uint_32)green_y);

+   if (blue_x > 80000L || blue_y > 80000L || blue_x + blue_y > 100000L)

+   {

+      png_warning(png_ptr, "Invalid fixed cHRM blue point specified");

+      return;

+   }

+   png_save_uint_32(buf + 24, (png_uint_32)blue_x);

+   png_save_uint_32(buf + 28, (png_uint_32)blue_y);

+   png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);

+}

+#endif

+#endif

+#if defined(PNG_WRITE_tRNS_SUPPORTED)

+/* write the tRNS chunk */

+void /* PRIVATE */

+png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,

+   int num_trans, int color_type)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_tRNS;

+#endif

+   png_byte buf[6];

+   png_debug(1, "in png_write_tRNS\n");

+   if (color_type == PNG_COLOR_TYPE_PALETTE)

+   {

+      if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)

+      {

+         png_warning(png_ptr,"Invalid number of transparent colors specified");

+         return;

+      }

+      /* write the chunk out as it is */

+      png_write_chunk(png_ptr, (png_bytep)png_tRNS, trans, (png_size_t)num_trans);

+   }

+   else if (color_type == PNG_COLOR_TYPE_GRAY)

+   {

+      /* one 16 bit value */

+      if(tran->gray >= (1 << png_ptr->bit_depth))

+      {

+         png_warning(png_ptr,

+           "Ignoring attempt to write tRNS chunk out-of-range for bit_depth");

+         return;

+      }

+      png_save_uint_16(buf, tran->gray);

+      png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)2);

+   }

+   else if (color_type == PNG_COLOR_TYPE_RGB)

+   {

+      /* three 16 bit values */

+      png_save_uint_16(buf, tran->red);

+      png_save_uint_16(buf + 2, tran->green);

+      png_save_uint_16(buf + 4, tran->blue);

+      if(png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))

+         {

+            png_warning(png_ptr,

+              "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");

+            return;

+         }

+      png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)6);

+   }

+   else

+   {

+      png_warning(png_ptr, "Can't write tRNS with an alpha channel");

+   }

+}

+#endif

+#if defined(PNG_WRITE_bKGD_SUPPORTED)

+/* write the background chunk */

+void /* PRIVATE */

+png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_bKGD;

+#endif

+   png_byte buf[6];

+   png_debug(1, "in png_write_bKGD\n");

+   if (color_type == PNG_COLOR_TYPE_PALETTE)

+   {

+      if (

+#if defined(PNG_MNG_FEATURES_SUPPORTED)

+          (png_ptr->num_palette ||

+          (!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) &&

+#endif

+         back->index > png_ptr->num_palette)

+      {

+         png_warning(png_ptr, "Invalid background palette index");

+         return;

+      }

+      buf[0] = back->index;

+      png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)1);

+   }

+   else if (color_type & PNG_COLOR_MASK_COLOR)

+   {

+      png_save_uint_16(buf, back->red);

+      png_save_uint_16(buf + 2, back->green);

+      png_save_uint_16(buf + 4, back->blue);

+      if(png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))

+         {

+            png_warning(png_ptr,

+              "Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8");

+            return;

+         }

+      png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)6);

+   }

+   else

+   {

+      if(back->gray >= (1 << png_ptr->bit_depth))

+      {

+         png_warning(png_ptr,

+           "Ignoring attempt to write bKGD chunk out-of-range for bit_depth");

+         return;

+      }

+      png_save_uint_16(buf, back->gray);

+      png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)2);

+   }

+}

+#endif

+#if defined(PNG_WRITE_hIST_SUPPORTED)

+/* write the histogram */

+void /* PRIVATE */

+png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_hIST;

+#endif

+   int i;

+   png_byte buf[3];

+   png_debug(1, "in png_write_hIST\n");

+   if (num_hist > (int)png_ptr->num_palette)

+   {

+      png_debug2(3, "num_hist = %d, num_palette = %d\n", num_hist,

+         png_ptr->num_palette);

+      png_warning(png_ptr, "Invalid number of histogram entries specified");

+      return;

+   }

+   png_write_chunk_start(png_ptr, (png_bytep)png_hIST, (png_uint_32)(num_hist * 2));

+   for (i = 0; i < num_hist; i++)

+   {

+      png_save_uint_16(buf, hist[i]);

+      png_write_chunk_data(png_ptr, buf, (png_size_t)2);

+   }

+   png_write_chunk_end(png_ptr);

+}

+#endif

+#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \

+    defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)

+/* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification,

+ * and if invalid, correct the keyword rather than discarding the entire

+ * chunk.  The PNG 1.0 specification requires keywords 1-79 characters in

+ * length, forbids leading or trailing whitespace, multiple internal spaces,

+ * and the non-break space (0x80) from ISO 8859-1.  Returns keyword length.

+ *

+ * The new_key is allocated to hold the corrected keyword and must be freed

+ * by the calling routine.  This avoids problems with trying to write to

+ * static keywords without having to have duplicate copies of the strings.

+ */

+png_size_t /* PRIVATE */

+png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)

+{

+   png_size_t key_len;

+   png_charp kp, dp;

+   int kflag;

+   int kwarn=0;

+   png_debug(1, "in png_check_keyword\n");

+   *new_key = NULL;

+   if (key == NULL || (key_len = png_strlen(key)) == 0)

+   {

+      png_warning(png_ptr, "zero length keyword");

+      return ((png_size_t)0);

+   }

+   png_debug1(2, "Keyword to be checked is '%s'\n", key);

+   *new_key = (png_charp)png_malloc_warn(png_ptr, (png_uint_32)(key_len + 2));

+   if (*new_key == NULL)

+   {

+      png_warning(png_ptr, "Out of memory while procesing keyword");

+      return ((png_size_t)0);

+   }

+   /* Replace non-printing characters with a blank and print a warning */

+   for (kp = key, dp = *new_key; *kp != '\0'; kp++, dp++)

+   {

+      if (*kp < 0x20 || (*kp > 0x7E && (png_byte)*kp < 0xA1))

+      {

+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)

+         char msg[40];

+         sprintf(msg, "invalid keyword character 0x%02X", *kp);

+         png_warning(png_ptr, msg);

+#else

+         png_warning(png_ptr, "invalid character in keyword");

+#endif

+         *dp = ' ';

+      }

+      else

+      {

+         *dp = *kp;

+      }

+   }

+   *dp = '\0';

+   /* Remove any trailing white space. */

+   kp = *new_key + key_len - 1;

+   if (*kp == ' ')

+   {

+      png_warning(png_ptr, "trailing spaces removed from keyword");

+      while (*kp == ' ')

+      {

+        *(kp--) = '\0';

+        key_len--;

+      }

+   }

+   /* Remove any leading white space. */

+   kp = *new_key;

+   if (*kp == ' ')

+   {

+      png_warning(png_ptr, "leading spaces removed from keyword");

+      while (*kp == ' ')

+      {

+        kp++;

+        key_len--;

+      }

+   }

+   png_debug1(2, "Checking for multiple internal spaces in '%s'\n", kp);

+   /* Remove multiple internal spaces. */

+   for (kflag = 0, dp = *new_key; *kp != '\0'; kp++)

+   {

+      if (*kp == ' ' && kflag == 0)

+      {

+         *(dp++) = *kp;

+         kflag = 1;

+      }

+      else if (*kp == ' ')

+      {

+         key_len--;

+         kwarn=1;

+      }

+      else

+      {

+         *(dp++) = *kp;

+         kflag = 0;

+      }

+   }

+   *dp = '\0';

+   if(kwarn)

+      png_warning(png_ptr, "extra interior spaces removed from keyword");

+   if (key_len == 0)

+   {

+      png_free(png_ptr, *new_key);

+      *new_key=NULL;

+      png_warning(png_ptr, "Zero length keyword");

+   }

+   if (key_len > 79)

+   {

+      png_warning(png_ptr, "keyword length must be 1 - 79 characters");

+      new_key[79] = '\0';

+      key_len = 79;

+   }

+   return (key_len);

+}

+#endif

+#if defined(PNG_WRITE_tEXt_SUPPORTED)

+/* write a tEXt chunk */

+void /* PRIVATE */

+png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,

+   png_size_t text_len)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_tEXt;

+#endif

+   png_size_t key_len;

+   png_charp new_key;

+   png_debug(1, "in png_write_tEXt\n");

+   if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)

+   {

+      png_warning(png_ptr, "Empty keyword in tEXt chunk");

+      return;

+   }

+   if (text == NULL || *text == '\0')

+      text_len = 0;

+   else

+      text_len = png_strlen(text);

+   /* make sure we include the 0 after the key */

+   png_write_chunk_start(png_ptr, (png_bytep)png_tEXt, (png_uint_32)key_len+text_len+1);

+   /*

+    * We leave it to the application to meet PNG-1.0 requirements on the

+    * contents of the text.  PNG-1.0 through PNG-1.2 discourage the use of

+    * any non-Latin-1 characters except for NEWLINE.  ISO PNG will forbid them.

+    * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.

+    */

+   png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1);

+   if (text_len)

+      png_write_chunk_data(png_ptr, (png_bytep)text, text_len);

+   png_write_chunk_end(png_ptr);

+   png_free(png_ptr, new_key);

+}

+#endif

+#if defined(PNG_WRITE_zTXt_SUPPORTED)

+/* write a compressed text chunk */

+void /* PRIVATE */

+png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,

+   png_size_t text_len, int compression)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_zTXt;

+#endif

+   png_size_t key_len;

+   char buf[1];

+   png_charp new_key;

+   compression_state comp;

+   png_debug(1, "in png_write_zTXt\n");

+   if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)

+   {

+      png_warning(png_ptr, "Empty keyword in zTXt chunk");

+      return;

+   }

+   if (text == NULL || *text == '\0' || compression==PNG_TEXT_COMPRESSION_NONE)

+   {

+      png_write_tEXt(png_ptr, new_key, text, (png_size_t)0);

+      png_free(png_ptr, new_key);

+      return;

+   }

+   text_len = png_strlen(text);

+   png_free(png_ptr, new_key);

+   /* compute the compressed data; do it now for the length */

+   text_len = png_text_compress(png_ptr, text, text_len, compression,

+       &comp);

+   /* write start of chunk */

+   png_write_chunk_start(png_ptr, (png_bytep)png_zTXt, (png_uint_32)

+      (key_len+text_len+2));

+   /* write key */

+   png_write_chunk_data(png_ptr, (png_bytep)key, key_len + 1);

+   buf[0] = (png_byte)compression;

+   /* write compression */

+   png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1);

+   /* write the compressed data */

+   png_write_compressed_data_out(png_ptr, &comp);

+   /* close the chunk */

+   png_write_chunk_end(png_ptr);

+}

+#endif

+#if defined(PNG_WRITE_iTXt_SUPPORTED)

+/* write an iTXt chunk */

+void /* PRIVATE */

+png_write_iTXt(png_structp png_ptr, int compression, png_charp key,

+    png_charp lang, png_charp lang_key, png_charp text)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_iTXt;

+#endif

+   png_size_t lang_len, key_len, lang_key_len, text_len;

+   png_charp new_lang, new_key;

+   png_byte cbuf[2];

+   compression_state comp;

+   png_debug(1, "in png_write_iTXt\n");

+   if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)

+   {

+      png_warning(png_ptr, "Empty keyword in iTXt chunk");

+      return;

+   }

+   if (lang == NULL || (lang_len = png_check_keyword(png_ptr, lang, &new_lang))==0)

+   {

+      png_warning(png_ptr, "Empty language field in iTXt chunk");

+      new_lang = NULL;

+      lang_len = 0;

+   }

+   if (lang_key == NULL)

+     lang_key_len = 0;

+   else

+     lang_key_len = png_strlen(lang_key);

+   if (text == NULL)

+      text_len = 0;

+   else

+     text_len = png_strlen(text);

+   /* compute the compressed data; do it now for the length */

+   text_len = png_text_compress(png_ptr, text, text_len, compression-2,

+      &comp);

+   /* make sure we include the compression flag, the compression byte,

+    * and the NULs after the key, lang, and lang_key parts */

+   png_write_chunk_start(png_ptr, (png_bytep)png_iTXt,

+          (png_uint_32)(

+        5 /* comp byte, comp flag, terminators for key, lang and lang_key */

+        + key_len

+        + lang_len

+        + lang_key_len

+        + text_len));

+   /*

+    * We leave it to the application to meet PNG-1.0 requirements on the

+    * contents of the text.  PNG-1.0 through PNG-1.2 discourage the use of

+    * any non-Latin-1 characters except for NEWLINE.  ISO PNG will forbid them.

+    * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.

+    */

+   png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1);

+   /* set the compression flag */

+   if (compression == PNG_ITXT_COMPRESSION_NONE || \

+       compression == PNG_TEXT_COMPRESSION_NONE)

+       cbuf[0] = 0;

+   else /* compression == PNG_ITXT_COMPRESSION_zTXt */

+       cbuf[0] = 1;

+   /* set the compression method */

+   cbuf[1] = 0;

+   png_write_chunk_data(png_ptr, cbuf, 2);

+   cbuf[0] = 0;

+   png_write_chunk_data(png_ptr, (new_lang ? (png_bytep)new_lang : cbuf), lang_len + 1);

+   png_write_chunk_data(png_ptr, (lang_key ? (png_bytep)lang_key : cbuf), lang_key_len + 1);

+   png_write_compressed_data_out(png_ptr, &comp);

+   png_write_chunk_end(png_ptr);

+   png_free(png_ptr, new_key);

+   if (new_lang)

+     png_free(png_ptr, new_lang);

+}

+#endif

+#if defined(PNG_WRITE_oFFs_SUPPORTED)

+/* write the oFFs chunk */

+void /* PRIVATE */

+png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset,

+   int unit_type)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_oFFs;

+#endif

+   png_byte buf[9];

+   png_debug(1, "in png_write_oFFs\n");

+   if (unit_type >= PNG_OFFSET_LAST)

+      png_warning(png_ptr, "Unrecognized unit type for oFFs chunk");

+   png_save_int_32(buf, x_offset);

+   png_save_int_32(buf + 4, y_offset);

+   buf[8] = (png_byte)unit_type;

+   png_write_chunk(png_ptr, (png_bytep)png_oFFs, buf, (png_size_t)9);

+}

+#endif

+#if defined(PNG_WRITE_pCAL_SUPPORTED)

+/* write the pCAL chunk (described in the PNG extensions document) */

+void /* PRIVATE */

+png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,

+   png_int_32 X1, int type, int nparams, png_charp units, png_charpp params)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_pCAL;

+#endif

+   png_size_t purpose_len, units_len, total_len;

+   png_uint_32p params_len;

+   png_byte buf[10];

+   png_charp new_purpose;

+   int i;

+   png_debug1(1, "in png_write_pCAL (%d parameters)\n", nparams);

+   if (type >= PNG_EQUATION_LAST)

+      png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");

+   purpose_len = png_check_keyword(png_ptr, purpose, &new_purpose) + 1;

+   png_debug1(3, "pCAL purpose length = %d\n", (int)purpose_len);

+   units_len = png_strlen(units) + (nparams == 0 ? 0 : 1);

+   png_debug1(3, "pCAL units length = %d\n", (int)units_len);

+   total_len = purpose_len + units_len + 10;

+   params_len = (png_uint_32p)png_malloc(png_ptr, (png_uint_32)(nparams

+      *png_sizeof(png_uint_32)));

+   /* Find the length of each parameter, making sure we don't count the

+      null terminator for the last parameter. */

+   for (i = 0; i < nparams; i++)

+   {

+      params_len[i] = png_strlen(params[i]) + (i == nparams - 1 ? 0 : 1);

+      png_debug2(3, "pCAL parameter %d length = %lu\n", i, params_len[i]);

+      total_len += (png_size_t)params_len[i];

+   }

+   png_debug1(3, "pCAL total length = %d\n", (int)total_len);

+   png_write_chunk_start(png_ptr, (png_bytep)png_pCAL, (png_uint_32)total_len);

+   png_write_chunk_data(png_ptr, (png_bytep)new_purpose, purpose_len);

+   png_save_int_32(buf, X0);

+   png_save_int_32(buf + 4, X1);

+   buf[8] = (png_byte)type;

+   buf[9] = (png_byte)nparams;

+   png_write_chunk_data(png_ptr, buf, (png_size_t)10);

+   png_write_chunk_data(png_ptr, (png_bytep)units, (png_size_t)units_len);

+   png_free(png_ptr, new_purpose);

+   for (i = 0; i < nparams; i++)

+   {

+      png_write_chunk_data(png_ptr, (png_bytep)params[i],

+         (png_size_t)params_len[i]);

+   }

+   png_free(png_ptr, params_len);

+   png_write_chunk_end(png_ptr);

+}

+#endif

+#if defined(PNG_WRITE_sCAL_SUPPORTED)

+/* write the sCAL chunk */

+#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)

+void /* PRIVATE */

+png_write_sCAL(png_structp png_ptr, int unit, double width,double height)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_sCAL;

+#endif

+   png_size_t total_len;

+   char wbuf[32], hbuf[32];

+   png_byte bunit = unit;

+   png_debug(1, "in png_write_sCAL\n");

+#if defined(_WIN32_WCE)

+/* sprintf() function is not supported on WindowsCE */

+   {

+      wchar_t wc_buf[32];

+      swprintf(wc_buf, TEXT("%12.12e"), width);

+      WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, wbuf, 32, NULL, NULL);

+      swprintf(wc_buf, TEXT("%12.12e"), height);

+      WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, hbuf, 32, NULL, NULL);

+   }

+#else

+   sprintf(wbuf, "%12.12e", width);

+   sprintf(hbuf, "%12.12e", height);

+#endif

+   total_len = 1 + png_strlen(wbuf)+1 + png_strlen(hbuf);

+   png_debug1(3, "sCAL total length = %d\n", (int)total_len);

+   png_write_chunk_start(png_ptr, (png_bytep)png_sCAL, (png_uint_32)total_len);

+   png_write_chunk_data(png_ptr, (png_bytep)&bunit, 1);

+   png_write_chunk_data(png_ptr, (png_bytep)wbuf, png_strlen(wbuf)+1);

+   png_write_chunk_data(png_ptr, (png_bytep)hbuf, png_strlen(hbuf));

+   png_write_chunk_end(png_ptr);

+}

+#else

+#ifdef PNG_FIXED_POINT_SUPPORTED

+void /* PRIVATE */

+png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width,

+   png_charp height)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_sCAL;

+#endif

+   png_size_t total_len;

+   char wbuf[32], hbuf[32];

+   png_byte bunit = unit;

+   png_debug(1, "in png_write_sCAL_s\n");

+   png_strcpy(wbuf,(const char *)width);

+   png_strcpy(hbuf,(const char *)height);

+   total_len = 1 + png_strlen(wbuf)+1 + png_strlen(hbuf);

+   png_debug1(3, "sCAL total length = %d\n", total_len);

+   png_write_chunk_start(png_ptr, (png_bytep)png_sCAL, (png_uint_32)total_len);

+   png_write_chunk_data(png_ptr, (png_bytep)&bunit, 1);

+   png_write_chunk_data(png_ptr, (png_bytep)wbuf, png_strlen(wbuf)+1);

+   png_write_chunk_data(png_ptr, (png_bytep)hbuf, png_strlen(hbuf));

+   png_write_chunk_end(png_ptr);

+}

+#endif

+#endif

+#endif

+#if defined(PNG_WRITE_pHYs_SUPPORTED)

+/* write the pHYs chunk */

+void /* PRIVATE */

+png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit,

+   png_uint_32 y_pixels_per_unit,

+   int unit_type)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_pHYs;

+#endif

+   png_byte buf[9];

+   png_debug(1, "in png_write_pHYs\n");

+   if (unit_type >= PNG_RESOLUTION_LAST)

+      png_warning(png_ptr, "Unrecognized unit type for pHYs chunk");

+   png_save_uint_32(buf, x_pixels_per_unit);

+   png_save_uint_32(buf + 4, y_pixels_per_unit);

+   buf[8] = (png_byte)unit_type;

+   png_write_chunk(png_ptr, (png_bytep)png_pHYs, buf, (png_size_t)9);

+}

+#endif

+#if defined(PNG_WRITE_tIME_SUPPORTED)

+/* Write the tIME chunk.  Use either png_convert_from_struct_tm()

+ * or png_convert_from_time_t(), or fill in the structure yourself.

+ */

+void /* PRIVATE */

+png_write_tIME(png_structp png_ptr, png_timep mod_time)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   PNG_tIME;

+#endif

+   png_byte buf[7];

+   png_debug(1, "in png_write_tIME\n");

+   if (mod_time->month  > 12 || mod_time->month  < 1 ||

+       mod_time->day    > 31 || mod_time->day    < 1 ||

+       mod_time->hour   > 23 || mod_time->second > 60)

+   {

+      png_warning(png_ptr, "Invalid time specified for tIME chunk");

+      return;

+   }

+   png_save_uint_16(buf, mod_time->year);

+   buf[2] = mod_time->month;

+   buf[3] = mod_time->day;

+   buf[4] = mod_time->hour;

+   buf[5] = mod_time->minute;

+   buf[6] = mod_time->second;

+   png_write_chunk(png_ptr, (png_bytep)png_tIME, buf, (png_size_t)7);

+}

+#endif

+/* initializes the row writing capability of libpng */

+void /* PRIVATE */

+png_write_start_row(png_structp png_ptr)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */

+   /* start of interlace block */

+   int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

+   /* offset to next interlace block */

+   int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

+   /* start of interlace block in the y direction */

+   int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};

+   /* offset to next interlace block in the y direction */

+   int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};

+#endif

+   png_size_t buf_size;

+   png_debug(1, "in png_write_start_row\n");

+   buf_size = (png_size_t)(PNG_ROWBYTES(

+      png_ptr->usr_channels*png_ptr->usr_bit_depth,png_ptr->width)+1);

+   /* set up row buffer */

+   png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size);

+   png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;

+   /* set up filtering buffer, if using this filter */

+   if (png_ptr->do_filter & PNG_FILTER_SUB)

+   {

+      png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,

+         (png_ptr->rowbytes + 1));

+      png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;

+   }

+   /* We only need to keep the previous row if we are using one of these. */

+   if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH))

+   {

+     /* set up previous row buffer */

+      png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size);

+      png_memset(png_ptr->prev_row, 0, buf_size);

+      if (png_ptr->do_filter & PNG_FILTER_UP)

+      {

+         png_ptr->up_row = (png_bytep )png_malloc(png_ptr,

+            (png_ptr->rowbytes + 1));

+         png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;

+      }

+      if (png_ptr->do_filter & PNG_FILTER_AVG)

+      {

+         png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,

+            (png_ptr->rowbytes + 1));

+         png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;

+      }

+      if (png_ptr->do_filter & PNG_FILTER_PAETH)

+      {

+         png_ptr->paeth_row = (png_bytep )png_malloc(png_ptr,

+            (png_ptr->rowbytes + 1));

+         png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;

+      }

+   }

+#ifdef PNG_WRITE_INTERLACING_SUPPORTED

+   /* if interlaced, we need to set up width and height of pass */

+   if (png_ptr->interlaced)

+   {

+      if (!(png_ptr->transformations & PNG_INTERLACE))

+      {

+         png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -

+            png_pass_ystart[0]) / png_pass_yinc[0];

+         png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 -

+            png_pass_start[0]) / png_pass_inc[0];

+      }

+      else

+      {

+         png_ptr->num_rows = png_ptr->height;

+         png_ptr->usr_width = png_ptr->width;

+      }

+   }

+   else

+#endif

+   {

+      png_ptr->num_rows = png_ptr->height;

+      png_ptr->usr_width = png_ptr->width;

+   }

+   png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+   png_ptr->zstream.next_out = png_ptr->zbuf;

+}

+/* Internal use only.  Called when finished processing a row of data. */

+void /* PRIVATE */

+png_write_finish_row(png_structp png_ptr)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */

+   /* start of interlace block */

+   int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

+   /* offset to next interlace block */

+   int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

+   /* start of interlace block in the y direction */

+   int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};

+   /* offset to next interlace block in the y direction */

+   int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};

+#endif

+   int ret;

+   png_debug(1, "in png_write_finish_row\n");

+   /* next row */

+   png_ptr->row_number++;

+   /* see if we are done */

+   if (png_ptr->row_number < png_ptr->num_rows)

+      return;

+#ifdef PNG_WRITE_INTERLACING_SUPPORTED

+   /* if interlaced, go to next pass */

+   if (png_ptr->interlaced)

+   {

+      png_ptr->row_number = 0;

+      if (png_ptr->transformations & PNG_INTERLACE)

+      {

+         png_ptr->pass++;

+      }

+      else

+      {

+         /* loop until we find a non-zero width or height pass */

+         do

+         {

+            png_ptr->pass++;

+            if (png_ptr->pass >= 7)

+               break;

+            png_ptr->usr_width = (png_ptr->width +

+               png_pass_inc[png_ptr->pass] - 1 -

+               png_pass_start[png_ptr->pass]) /

+               png_pass_inc[png_ptr->pass];

+            png_ptr->num_rows = (png_ptr->height +

+               png_pass_yinc[png_ptr->pass] - 1 -

+               png_pass_ystart[png_ptr->pass]) /

+               png_pass_yinc[png_ptr->pass];

+            if (png_ptr->transformations & PNG_INTERLACE)

+               break;

+         } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0);

+      }

+      /* reset the row above the image for the next pass */

+      if (png_ptr->pass < 7)

+      {

+         if (png_ptr->prev_row != NULL)

+            png_memset(png_ptr->prev_row, 0,

+               (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels*

+               png_ptr->usr_bit_depth,png_ptr->width))+1);

+         return;

+      }

+   }

+#endif

+   /* if we get here, we've just written the last row, so we need

+      to flush the compressor */

+   do

+   {

+      /* tell the compressor we are done */

+      ret = deflate(&png_ptr->zstream, Z_FINISH);

+      /* check for an error */

+      if (ret == Z_OK)

+      {

+         /* check to see if we need more room */

+         if (!(png_ptr->zstream.avail_out))

+         {

+            png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);

+            png_ptr->zstream.next_out = png_ptr->zbuf;

+            png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+         }

+      }

+      else if (ret != Z_STREAM_END)

+      {

+         if (png_ptr->zstream.msg != NULL)

+            png_error(png_ptr, png_ptr->zstream.msg);

+         else

+            png_error(png_ptr, "zlib error");

+      }

+   } while (ret != Z_STREAM_END);

+   /* write any extra space */

+   if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)

+   {

+      png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size -

+         png_ptr->zstream.avail_out);

+   }

+   deflateReset(&png_ptr->zstream);

+   png_ptr->zstream.data_type = Z_BINARY;

+}

+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)

+/* Pick out the correct pixels for the interlace pass.

+ * The basic idea here is to go through the row with a source

+ * pointer and a destination pointer (sp and dp), and copy the

+ * correct pixels for the pass.  As the row gets compacted,

+ * sp will always be >= dp, so we should never overwrite anything.

+ * See the default: case for the easiest code to understand.

+ */

+void /* PRIVATE */

+png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)

+{

+#ifdef PNG_USE_LOCAL_ARRAYS

+   /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */

+   /* start of interlace block */

+   int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};

+   /* offset to next interlace block */

+   int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};

+#endif

+   png_debug(1, "in png_do_write_interlace\n");

+   /* we don't have to do anything on the last pass (6) */

+#if defined(PNG_USELESS_TESTS_SUPPORTED)

+   if (row != NULL && row_info != NULL && pass < 6)

+#else

+   if (pass < 6)

+#endif

+   {

+      /* each pixel depth is handled separately */

+      switch (row_info->pixel_depth)

+      {

+         case 1:

+         {

+            png_bytep sp;

+            png_bytep dp;

+            int shift;

+            int d;

+            int value;

+            png_uint_32 i;

+            png_uint_32 row_width = row_info->width;

+            dp = row;

+            d = 0;

+            shift = 7;

+            for (i = png_pass_start[pass]; i < row_width;

+               i += png_pass_inc[pass])

+            {

+               sp = row + (png_size_t)(i >> 3);

+               value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01;

+               d |= (value << shift);

+               if (shift == 0)

+               {

+                  shift = 7;

+                  *dp++ = (png_byte)d;

+                  d = 0;

+               }

+               else

+                  shift--;

+            }

+            if (shift != 7)

+               *dp = (png_byte)d;

+            break;

+         }

+         case 2:

+         {

+            png_bytep sp;

+            png_bytep dp;

+            int shift;

+            int d;

+            int value;

+            png_uint_32 i;

+            png_uint_32 row_width = row_info->width;

+            dp = row;

+            shift = 6;

+            d = 0;

+            for (i = png_pass_start[pass]; i < row_width;

+               i += png_pass_inc[pass])

+            {

+               sp = row + (png_size_t)(i >> 2);

+               value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03;

+               d |= (value << shift);

+               if (shift == 0)

+               {

+                  shift = 6;

+                  *dp++ = (png_byte)d;

+                  d = 0;

+               }

+               else

+                  shift -= 2;

+            }

+            if (shift != 6)

+                   *dp = (png_byte)d;

+            break;

+         }

+         case 4:

+         {

+            png_bytep sp;

+            png_bytep dp;

+            int shift;

+            int d;

+            int value;

+            png_uint_32 i;

+            png_uint_32 row_width = row_info->width;

+            dp = row;

+            shift = 4;

+            d = 0;

+            for (i = png_pass_start[pass]; i < row_width;

+               i += png_pass_inc[pass])

+            {

+               sp = row + (png_size_t)(i >> 1);

+               value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f;

+               d |= (value << shift);

+               if (shift == 0)

+               {

+                  shift = 4;

+                  *dp++ = (png_byte)d;

+                  d = 0;

+               }

+               else

+                  shift -= 4;

+            }

+            if (shift != 4)

+               *dp = (png_byte)d;

+            break;

+         }

+         default:

+         {

+            png_bytep sp;

+            png_bytep dp;

+            png_uint_32 i;

+            png_uint_32 row_width = row_info->width;

+            png_size_t pixel_bytes;

+            /* start at the beginning */

+            dp = row;

+            /* find out how many bytes each pixel takes up */

+            pixel_bytes = (row_info->pixel_depth >> 3);

+            /* loop through the row, only looking at the pixels that

+               matter */

+            for (i = png_pass_start[pass]; i < row_width;

+               i += png_pass_inc[pass])

+            {

+               /* find out where the original pixel is */

+               sp = row + (png_size_t)i * pixel_bytes;

+               /* move the pixel */

+               if (dp != sp)

+                  png_memcpy(dp, sp, pixel_bytes);

+               /* next pixel */

+               dp += pixel_bytes;

+            }

+            break;

+         }

+      }

+      /* set new row width */

+      row_info->width = (row_info->width +

+         png_pass_inc[pass] - 1 -

+         png_pass_start[pass]) /

+         png_pass_inc[pass];

+         row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,

+            row_info->width);

+   }

+}

+#endif

+/* This filters the row, chooses which filter to use, if it has not already

+ * been specified by the application, and then writes the row out with the

+ * chosen filter.

+ */

+#define PNG_MAXSUM (((png_uint_32)(-1)) >> 1)

+#define PNG_HISHIFT 10

+#define PNG_LOMASK ((png_uint_32)0xffffL)

+#define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT))

+void /* PRIVATE */

+png_write_find_filter(png_structp png_ptr, png_row_infop row_info)

+{

+   png_bytep prev_row, best_row, row_buf;

+   png_uint_32 mins, bpp;

+   png_byte filter_to_do = png_ptr->do_filter;

+   png_uint_32 row_bytes = row_info->rowbytes;

+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)

+   int num_p_filters = (int)png_ptr->num_prev_filters;

+#endif

+   png_debug(1, "in png_write_find_filter\n");

+   /* find out how many bytes offset each pixel is */

+   bpp = (row_info->pixel_depth + 7) >> 3;

+   prev_row = png_ptr->prev_row;

+   best_row = row_buf = png_ptr->row_buf;

+   mins = PNG_MAXSUM;

+   /* The prediction method we use is to find which method provides the

+    * smallest value when summing the absolute values of the distances

+    * from zero, using anything >= 128 as negative numbers.  This is known

+    * as the "minimum sum of absolute differences" heuristic.  Other

+    * heuristics are the "weighted minimum sum of absolute differences"

+    * (experimental and can in theory improve compression), and the "zlib

+    * predictive" method (not implemented yet), which does test compressions

+    * of lines using different filter methods, and then chooses the

+    * (series of) filter(s) that give minimum compressed data size (VERY

+    * computationally expensive).

+    *

+    * GRR 980525:  consider also

+    *   (1) minimum sum of absolute differences from running average (i.e.,

+    *       keep running sum of non-absolute differences & count of bytes)

+    *       [track dispersion, too?  restart average if dispersion too large?]

+    *  (1b) minimum sum of absolute differences from sliding average, probably

+    *       with window size <= deflate window (usually 32K)

+    *   (2) minimum sum of squared differences from zero or running average

+    *       (i.e., ~ root-mean-square approach)

+    */

+   /* We don't need to test the 'no filter' case if this is the only filter

+    * that has been chosen, as it doesn't actually do anything to the data.

+    */

+   if ((filter_to_do & PNG_FILTER_NONE) &&

+       filter_to_do != PNG_FILTER_NONE)

+   {

+      png_bytep rp;

+      png_uint_32 sum = 0;

+      png_uint_32 i;

+      int v;

+      for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++)

+      {

+         v = *rp;

+         sum += (v < 128) ? v : 256 - v;

+      }

+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)

+      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

+      {

+         png_uint_32 sumhi, sumlo;

+         int j;

+         sumlo = sum & PNG_LOMASK;

+         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */

+         /* Reduce the sum if we match any of the previous rows */

+         for (j = 0; j < num_p_filters; j++)

+         {

+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)

+            {

+               sumlo = (sumlo * png_ptr->filter_weights[j]) >>

+                  PNG_WEIGHT_SHIFT;

+               sumhi = (sumhi * png_ptr->filter_weights[j]) >>

+                  PNG_WEIGHT_SHIFT;

+            }

+         }

+         /* Factor in the cost of this filter (this is here for completeness,

+          * but it makes no sense to have a "cost" for the NONE filter, as

+          * it has the minimum possible computational cost - none).

+          */

+         sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>

+            PNG_COST_SHIFT;

+         sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>

+            PNG_COST_SHIFT;

+         if (sumhi > PNG_HIMASK)

+            sum = PNG_MAXSUM;

+         else

+            sum = (sumhi << PNG_HISHIFT) + sumlo;

+      }

+#endif

+      mins = sum;

+   }

+   /* sub filter */

+   if (filter_to_do == PNG_FILTER_SUB)

+   /* it's the only filter so no testing is needed */

+   {

+      png_bytep rp, lp, dp;

+      png_uint_32 i;

+      for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;

+           i++, rp++, dp++)

+      {

+         *dp = *rp;

+      }

+      for (lp = row_buf + 1; i < row_bytes;

+         i++, rp++, lp++, dp++)

+      {

+         *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);

+      }

+      best_row = png_ptr->sub_row;

+   }

+   else if (filter_to_do & PNG_FILTER_SUB)

+   {

+      png_bytep rp, dp, lp;

+      png_uint_32 sum = 0, lmins = mins;

+      png_uint_32 i;

+      int v;

+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)

+      /* We temporarily increase the "minimum sum" by the factor we

+       * would reduce the sum of this filter, so that we can do the

+       * early exit comparison without scaling the sum each time.

+       */

+      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

+      {

+         int j;

+         png_uint_32 lmhi, lmlo;

+         lmlo = lmins & PNG_LOMASK;

+         lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;

+         for (j = 0; j < num_p_filters; j++)

+         {

+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)

+            {

+               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>

+                  PNG_WEIGHT_SHIFT;

+               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>

+                  PNG_WEIGHT_SHIFT;

+            }

+         }

+         lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>

+            PNG_COST_SHIFT;

+         lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>

+            PNG_COST_SHIFT;

+         if (lmhi > PNG_HIMASK)

+            lmins = PNG_MAXSUM;

+         else

+            lmins = (lmhi << PNG_HISHIFT) + lmlo;

+      }

+#endif

+      for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;

+           i++, rp++, dp++)

+      {

+         v = *dp = *rp;

+         sum += (v < 128) ? v : 256 - v;

+      }

+      for (lp = row_buf + 1; i < row_bytes;

+         i++, rp++, lp++, dp++)

+      {

+         v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);

+         sum += (v < 128) ? v : 256 - v;

+         if (sum > lmins)  /* We are already worse, don't continue. */

+            break;

+      }

+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)

+      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

+      {

+         int j;

+         png_uint_32 sumhi, sumlo;

+         sumlo = sum & PNG_LOMASK;

+         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;

+         for (j = 0; j < num_p_filters; j++)

+         {

+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)

+            {

+               sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >>

+                  PNG_WEIGHT_SHIFT;

+               sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >>

+                  PNG_WEIGHT_SHIFT;

+            }

+         }

+         sumlo = (sumlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>

+            PNG_COST_SHIFT;

+         sumhi = (sumhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>

+            PNG_COST_SHIFT;

+         if (sumhi > PNG_HIMASK)

+            sum = PNG_MAXSUM;

+         else

+            sum = (sumhi << PNG_HISHIFT) + sumlo;

+      }

+#endif

+      if (sum < mins)

+      {

+         mins = sum;

+         best_row = png_ptr->sub_row;

+      }

+   }

+   /* up filter */

+   if (filter_to_do == PNG_FILTER_UP)

+   {

+      png_bytep rp, dp, pp;

+      png_uint_32 i;

+      for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,

+           pp = prev_row + 1; i < row_bytes;

+           i++, rp++, pp++, dp++)

+      {

+         *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);

+      }

+      best_row = png_ptr->up_row;

+   }

+   else if (filter_to_do & PNG_FILTER_UP)

+   {

+      png_bytep rp, dp, pp;

+      png_uint_32 sum = 0, lmins = mins;

+      png_uint_32 i;

+      int v;

+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)

+      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

+      {

+         int j;

+         png_uint_32 lmhi, lmlo;

+         lmlo = lmins & PNG_LOMASK;

+         lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;

+         for (j = 0; j < num_p_filters; j++)

+         {

+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)

+            {

+               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>

+                  PNG_WEIGHT_SHIFT;

+               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>

+                  PNG_WEIGHT_SHIFT;

+            }

+         }

+         lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>

+            PNG_COST_SHIFT;

+         lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>

+            PNG_COST_SHIFT;

+         if (lmhi > PNG_HIMASK)

+            lmins = PNG_MAXSUM;

+         else

+            lmins = (lmhi << PNG_HISHIFT) + lmlo;

+      }

+#endif

+      for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,

+           pp = prev_row + 1; i < row_bytes; i++)

+      {

+         v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);

+         sum += (v < 128) ? v : 256 - v;

+         if (sum > lmins)  /* We are already worse, don't continue. */

+            break;

+      }

+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)

+      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

+      {

+         int j;

+         png_uint_32 sumhi, sumlo;

+         sumlo = sum & PNG_LOMASK;

+         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;

+         for (j = 0; j < num_p_filters; j++)

+         {

+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)

+            {

+               sumlo = (sumlo * png_ptr->filter_weights[j]) >>

+                  PNG_WEIGHT_SHIFT;

+               sumhi = (sumhi * png_ptr->filter_weights[j]) >>

+                  PNG_WEIGHT_SHIFT;

+            }

+         }

+         sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>

+            PNG_COST_SHIFT;

+         sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>

+            PNG_COST_SHIFT;

+         if (sumhi > PNG_HIMASK)

+            sum = PNG_MAXSUM;

+         else

+            sum = (sumhi << PNG_HISHIFT) + sumlo;

+      }

+#endif

+      if (sum < mins)

+      {

+         mins = sum;

+         best_row = png_ptr->up_row;

+      }

+   }

+   /* avg filter */

+   if (filter_to_do == PNG_FILTER_AVG)

+   {

+      png_bytep rp, dp, pp, lp;

+      png_uint_32 i;

+      for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,

+           pp = prev_row + 1; i < bpp; i++)

+      {

+         *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);

+      }

+      for (lp = row_buf + 1; i < row_bytes; i++)

+      {

+         *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))

+                 & 0xff);

+      }

+      best_row = png_ptr->avg_row;

+   }

+   else if (filter_to_do & PNG_FILTER_AVG)

+   {

+      png_bytep rp, dp, pp, lp;

+      png_uint_32 sum = 0, lmins = mins;

+      png_uint_32 i;

+      int v;

+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)

+      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

+      {

+         int j;

+         png_uint_32 lmhi, lmlo;

+         lmlo = lmins & PNG_LOMASK;

+         lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;

+         for (j = 0; j < num_p_filters; j++)

+         {

+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG)

+            {

+               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>

+                  PNG_WEIGHT_SHIFT;

+               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>

+                  PNG_WEIGHT_SHIFT;

+            }

+         }

+         lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>

+            PNG_COST_SHIFT;

+         lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>

+            PNG_COST_SHIFT;

+         if (lmhi > PNG_HIMASK)

+            lmins = PNG_MAXSUM;

+         else

+            lmins = (lmhi << PNG_HISHIFT) + lmlo;

+      }

+#endif

+      for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,

+           pp = prev_row + 1; i < bpp; i++)

+      {

+         v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);

+         sum += (v < 128) ? v : 256 - v;

+      }

+      for (lp = row_buf + 1; i < row_bytes; i++)

+      {

+         v = *dp++ =

+          (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff);

+         sum += (v < 128) ? v : 256 - v;

+         if (sum > lmins)  /* We are already worse, don't continue. */

+            break;

+      }

+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)

+      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

+      {

+         int j;

+         png_uint_32 sumhi, sumlo;

+         sumlo = sum & PNG_LOMASK;

+         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;

+         for (j = 0; j < num_p_filters; j++)

+         {

+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)

+            {

+               sumlo = (sumlo * png_ptr->filter_weights[j]) >>

+                  PNG_WEIGHT_SHIFT;

+               sumhi = (sumhi * png_ptr->filter_weights[j]) >>

+                  PNG_WEIGHT_SHIFT;

+            }

+         }

+         sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>

+            PNG_COST_SHIFT;

+         sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>

+            PNG_COST_SHIFT;

+         if (sumhi > PNG_HIMASK)

+            sum = PNG_MAXSUM;

+         else

+            sum = (sumhi << PNG_HISHIFT) + sumlo;

+      }

+#endif

+      if (sum < mins)

+      {

+         mins = sum;

+         best_row = png_ptr->avg_row;

+      }

+   }

+   /* Paeth filter */

+   if (filter_to_do == PNG_FILTER_PAETH)

+   {

+      png_bytep rp, dp, pp, cp, lp;

+      png_uint_32 i;

+      for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,

+           pp = prev_row + 1; i < bpp; i++)

+      {

+         *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);

+      }

+      for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)

+      {

+         int a, b, c, pa, pb, pc, p;

+         b = *pp++;

+         c = *cp++;

+         a = *lp++;

+         p = b - c;

+         pc = a - c;

+#ifdef PNG_USE_ABS

+         pa = abs(p);

+         pb = abs(pc);

+         pc = abs(p + pc);

+#else

+         pa = p < 0 ? -p : p;

+         pb = pc < 0 ? -pc : pc;

+         pc = (p + pc) < 0 ? -(p + pc) : p + pc;

+#endif

+         p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;

+         *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);

+      }

+      best_row = png_ptr->paeth_row;

+   }

+   else if (filter_to_do & PNG_FILTER_PAETH)

+   {

+      png_bytep rp, dp, pp, cp, lp;

+      png_uint_32 sum = 0, lmins = mins;

+      png_uint_32 i;

+      int v;

+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)

+      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

+      {

+         int j;

+         png_uint_32 lmhi, lmlo;

+         lmlo = lmins & PNG_LOMASK;

+         lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;

+         for (j = 0; j < num_p_filters; j++)

+         {

+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)

+            {

+               lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>

+                  PNG_WEIGHT_SHIFT;

+               lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>

+                  PNG_WEIGHT_SHIFT;

+            }

+         }

+         lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>

+            PNG_COST_SHIFT;

+         lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>

+            PNG_COST_SHIFT;

+         if (lmhi > PNG_HIMASK)

+            lmins = PNG_MAXSUM;

+         else

+            lmins = (lmhi << PNG_HISHIFT) + lmlo;

+      }

+#endif

+      for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,

+           pp = prev_row + 1; i < bpp; i++)

+      {

+         v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);

+         sum += (v < 128) ? v : 256 - v;

+      }

+      for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)

+      {

+         int a, b, c, pa, pb, pc, p;

+         b = *pp++;

+         c = *cp++;

+         a = *lp++;

+#ifndef PNG_SLOW_PAETH

+         p = b - c;

+         pc = a - c;

+#ifdef PNG_USE_ABS

+         pa = abs(p);

+         pb = abs(pc);

+         pc = abs(p + pc);

+#else

+         pa = p < 0 ? -p : p;

+         pb = pc < 0 ? -pc : pc;

+         pc = (p + pc) < 0 ? -(p + pc) : p + pc;

+#endif

+         p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;

+#else /* PNG_SLOW_PAETH */

+         p = a + b - c;

+         pa = abs(p - a);

+         pb = abs(p - b);

+         pc = abs(p - c);

+         if (pa <= pb && pa <= pc)

+            p = a;

+         else if (pb <= pc)

+            p = b;

+         else

+            p = c;

+#endif /* PNG_SLOW_PAETH */

+         v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);

+         sum += (v < 128) ? v : 256 - v;

+         if (sum > lmins)  /* We are already worse, don't continue. */

+            break;

+      }

+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)

+      if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)

+      {

+         int j;

+         png_uint_32 sumhi, sumlo;

+         sumlo = sum & PNG_LOMASK;

+         sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;

+         for (j = 0; j < num_p_filters; j++)

+         {

+            if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)

+            {

+               sumlo = (sumlo * png_ptr->filter_weights[j]) >>

+                  PNG_WEIGHT_SHIFT;

+               sumhi = (sumhi * png_ptr->filter_weights[j]) >>

+                  PNG_WEIGHT_SHIFT;

+            }

+         }

+         sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>

+            PNG_COST_SHIFT;

+         sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>

+            PNG_COST_SHIFT;

+         if (sumhi > PNG_HIMASK)

+            sum = PNG_MAXSUM;

+         else

+            sum = (sumhi << PNG_HISHIFT) + sumlo;

+      }

+#endif

+      if (sum < mins)

+      {

+         best_row = png_ptr->paeth_row;

+      }

+   }

+   /* Do the actual writing of the filtered row data from the chosen filter. */

+   png_write_filtered_row(png_ptr, best_row);

+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)

+   /* Save the type of filter we picked this time for future calculations */

+   if (png_ptr->num_prev_filters > 0)

+   {

+      int j;

+      for (j = 1; j < num_p_filters; j++)

+      {

+         png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1];

+      }

+      png_ptr->prev_filters[j] = best_row[0];

+   }

+#endif

+}

+/* Do the actual writing of a previously filtered row. */

+void /* PRIVATE */

+png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row)

+{

+   png_debug(1, "in png_write_filtered_row\n");

+   png_debug1(2, "filter = %d\n", filtered_row[0]);

+   /* set up the zlib input buffer */

+   png_ptr->zstream.next_in = filtered_row;

+   png_ptr->zstream.avail_in = (uInt)png_ptr->row_info.rowbytes + 1;

+   /* repeat until we have compressed all the data */

+   do

+   {

+      int ret; /* return of zlib */

+      /* compress the data */

+      ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);

+      /* check for compression errors */

+      if (ret != Z_OK)

+      {

+         if (png_ptr->zstream.msg != NULL)

+            png_error(png_ptr, png_ptr->zstream.msg);

+         else

+            png_error(png_ptr, "zlib error");

+      }

+      /* see if it is time to write another IDAT */

+      if (!(png_ptr->zstream.avail_out))

+      {

+         /* write the IDAT and reset the zlib output buffer */

+         png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);

+         png_ptr->zstream.next_out = png_ptr->zbuf;

+         png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

+      }

+   /* repeat until all data has been compressed */

+   } while (png_ptr->zstream.avail_in);

+   /* swap the current and previous rows */

+   if (png_ptr->prev_row != NULL)

+   {

+      png_bytep tptr;

+      tptr = png_ptr->prev_row;

+      png_ptr->prev_row = png_ptr->row_buf;

+      png_ptr->row_buf = tptr;

+   }

+   /* finish row - updates counters and flushes zlib if last row */

+   png_write_finish_row(png_ptr);

+#if defined(PNG_WRITE_FLUSH_SUPPORTED)

+   png_ptr->flush_rows++;

+   if (png_ptr->flush_dist > 0 &&

+       png_ptr->flush_rows >= png_ptr->flush_dist)

+   {

+      png_write_flush(png_ptr);

+   }

+#endif

+}

+#endif /* PNG_WRITE_SUPPORTED */