Imported from libpng-1.2.0beta3.tar

Imported from libpng-1.2.0beta2.tar
Imported from libpng-1.2.0beta1.tar
2025-07-10 18:04:09 +02:00 · 2009-04-06 16:06:20 -05:00 · 2009-04-06 16:06:18 -05:00 · 2009-04-06 16:06:16 -05:00 · 2009-04-06 16:06:14 -05:00 · 2009-04-06 16:06:12 -05:00
59 changed files with 1783 additions and 1093 deletions
--- a/26
+++ b/26
@@ -1,16 +1,26 @@

-Libpng 1.0.11beta3 - April 15, 2001
+Libpng 1.2.0beta3 - May 18, 2001

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

-Changes since the last public release (1.0.10):
+Changes since the last public release (1.0.11):

-  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
-  Removed PNGAPI from private functions whose prototypes did not have PNGAPI.
-  Updated scripts/pngos2.def
-  Added checking the results of many instances of png_malloc() for NULL
+  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.
+  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.
+  Added a check for attempts to read or write PLTE in grayscale PNG datastreams.
+  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.
+  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.

 Send comments/corrections/commendations to
 png-implement@ccrc.wustl.edu or to randeg@alum.rpi.edu
--- a/32
+++ b/32
@@ -1,3 +1,4 @@
+
 CHANGES - changes for libpng

 version 0.2
@@ -921,8 +922,37 @@ version 1.0.11beta1 [April 3, 2001]
 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 15, 2001]
+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 18, 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.

 Send comments/corrections/commendations to
 png-implement@ccrc.wustl.edu or to randeg@alum.rpi.edu
--- a/13
+++ b/13
@@ -1,5 +1,5 @@

-Installing libpng version 1.0.11beta3 - April 15, 2001
+Installing libpng version 1.2.0beta3 - May 18, 2001

 Before installing libpng, you must first install zlib.  zlib
 can usually be found wherever you got libpng.  zlib can be
@@ -10,7 +10,7 @@ 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.0.11beta3" or "lpng109" and "zlib-1.1.3"
+might be called "libpng-1.2.0beta3" or "lpng109" and "zlib-1.1.3"
 or "zlib113") so that you have directories called "zlib" and "libpng".

 Your directory structure should look like this:
@@ -60,8 +60,8 @@ The files that are presently available in the scripts directory
 include

 makefile.std      =>  Generic UNIX makefile (cc, creates static libpng.a)
- makefile.linux    =>  Linux/ELF makefile (gcc, creates libpng.so.2.1.0.11beta3)
- makefile.gcmmx    =>  Linux/ELF makefile (gcc, creates libpng.so.2.1.0.11beta3,
+ makefile.linux    =>  Linux/ELF makefile (gcc, creates libpng.so.2.1.2.0beta3)
+ makefile.gcmmx    =>  Linux/ELF makefile (gcc, creates libpng.so.2.1.2.0beta3,
                       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
@@ -76,10 +76,11 @@ include
 makefile.intel    =>  Intel C/C++ version 4.0 and later
 libpng.icc        =>  Project file for IBM VisualAge/C++ version 4.0 or later
 makefile.macosx   =>  MACOS X Makefile
+ makefile.netbsd   =>  NetBSD/cc makefile, uses PNGGCCRD
 makefile.sgi      =>  Silicon Graphics IRIX makefile (cc, creates static lib)
- makefile.sggcc    =>  Silicon Graphics (gcc, creates libpng.so.2.1.0.11beta3)
+ makefile.sggcc    =>  Silicon Graphics (gcc, creates libpng.so.2.1.2.0beta3)
 makefile.sunos    =>  Sun makefile
- makefile.solaris  =>  Solaris 2.X makefile (gcc, creates libpng.so.2.1.0.11beta3)
+ makefile.solaris  =>  Solaris 2.X makefile (gcc, creates libpng.so.2.1.2.0beta3)
 makefile.sco      =>  For SCO OSr5  ELF and Unixware 7 with Native cc
 makefile.mips     =>  MIPS makefile
 makefile.acorn    =>  Acorn makefile
--- a/28
+++ b/28
@@ -1,28 +1,8 @@

-Known bugs in libpng-1.0.10
+Known bugs in libpng-1.2.0

-1. April 1, 2001: Missing type casts on png_malloc() calls (Dimitri Papadopolous)
+1. April 22, 2001: pnggccrd.c has been reported to crash on NetBSD when
+   reading interlaced PNG files, when assembler code is enabled.

-   A call to png_malloc() in pngread.c is missing the (png_bytep) type cast,
-   and four calls in pngset.c are missing type casts, (png_charp), (png_charp),
-   (png_bytep), and (png_bytep), respectively.
+   STATUS: Under investigation.

-   STATUS: fixed in libpng-1.0.11beta1.
-
-2. April 3, 2001: "//" comments cause the SGI compiler (o32) to fail to
-   compile pnggccrd.c (Richard Kettlewell).
-
-   STATUS: fixed in libpng-1.0.11beta1.
-
-3. April 5, 2001: The prototypes don't match several functions.
-
-   Functions png_info_init, png_zalloc, and several others have PNGAPI
-   in the C functions but not in the prototypes in png.h.  The functions
-   involved are all either deprecated or intended only for internal use.
-
-   STATUS: PNGAPI was removed from the C code in libpng-1.0.11beta2.
-
-4. April 14, 2001: Many instances of png_malloc() are not followed by
-   a check to make sure it didn't return NULL.
-
-   STATUS: tests were added in libpng-1.0.11beta3.
--- a/14
+++ b/14
@@ -8,8 +8,8 @@ COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
 If you modify libpng you may insert additional notices immediately following
 this sentence.

-libpng versions 1.0.7, July 1, 2000, through 1.0.11beta3, April 15, 2001, are
-Copyright (c) 2000, 2001 Glenn Randers-Pehrson
+libpng versions 1.0.7, July 1, 2000, through 1.2.0beta3, May 18, 2001, are
+Copyright (c) 2000 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

@@ -73,11 +73,11 @@ 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.
+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.
+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
@@ -99,4 +99,4 @@ certification mark of the Open Source Initiative.

 Glenn Randers-Pehrson
 randeg@alum.rpi.edu
-April 15, 2001
+May 18, 2001
--- a/11
+++ b/11
@@ -1,4 +1,4 @@
-README for libpng 1.0.11beta3 - April 15, 2001 (shared library 2.1)
+README for libpng 1.2.0beta3 - May 18, 2001 (shared library 2.1)
 See the note about version numbers near the top of png.h

 See INSTALL for instructions on how to install libpng.
@@ -183,9 +183,9 @@ Files in this distribution:
       descrip.mms      =>  VMS makefile for MMS or MMK
       makefile.std     =>  Generic UNIX makefile (cc, creates static libpng.a)
       makefile.linux   =>  Linux/ELF makefile
-                            (gcc, creates libpng.so.2.1.0.11beta3)
+                            (gcc, creates libpng.so.2.1.2.0beta3)
       makefile.gcmmx   =>  Linux/ELF makefile (gcc, creates
-                            libpng.so.2.1.0.11beta3, uses assembler code
+                            libpng.so.2.1.2.0beta3, 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
@@ -200,11 +200,12 @@ Files in this distribution:
       makefile.intel   =>  Intel C/C++ version 4.0 and later
       libpng.icc       =>  Project file, IBM VisualAge/C++ 4.0 or later
       makefile.macosx  =>  MACOS X Makefile
+       makefile.netbsd  =>  NetBSD/cc makefile, uses PNGGCCRD
       makefile.sgi     =>  Silicon Graphics IRIX (cc, creates static lib)
-       makefile.sggcc   =>  Silicon Graphics (gcc, creates libpng.so.2.1.0.11beta3)
+       makefile.sggcc   =>  Silicon Graphics (gcc, creates libpng.so.2.1.2.0beta3)
       makefile.sunos   =>  Sun makefile
       makefile.solaris =>  Solaris 2.X makefile
-                            (gcc, creates libpng.so.2.1.0.11beta3)
+                            (gcc, creates libpng.so.2.1.2.0beta3)
       makefile.sco     =>  For SCO OSr5  ELF and Unixware 7 with Native cc
       makefile.mips    =>  MIPS makefile
       makefile.acorn   =>  Acorn makefile
--- a/4
+++ b/4
@@ -1,13 +1,13 @@
   Y2K compliance in libpng:
   =========================

-      April 15, 2001
+      May 18, 2001

      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.0.11beta3 are Y2K compliant.  It is my belief that earlier
+      upward through 1.2.0beta3 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
--- a/2
+++ b/2
@@ -1,5 +1,5 @@
 echo "
-  There is no \"configure\" script for Libpng-1.0.11beta3.  Instead, please
+  There is no \"configure\" script for Libpng-1.2.0beta3.  Instead, please
  copy the appropriate makefile for your system from the \"scripts\"
  directory.  Read the INSTALL file for more details.
 "
--- a/contrib/gregbook/readpng2.c
+++ b/contrib/gregbook/readpng2.c
@@ -49,8 +49,77 @@ static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg);

 void readpng2_version_info(void)
 {
+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && \
+    (defined(__i386__) || defined(_M_IX86)) && \
+    defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)
+    /*
+     * WARNING:  This preprocessor approach means that the following code
+     *           cannot be used with a libpng DLL older than 1.2.0--the
+     *           compiled-in symbols for the new functions will not exist.
+     *           (Could use dlopen() and dlsym() on Unix and corresponding
+     *           calls for Windows, but not portable...)
+     */
+    {
+        int mmxsupport = png_mmx_support();
+        if (mmxsupport < 0)
+            fprintf(stderr, "   Compiled with libpng %s; using libpng %s "
+              "without MMX support.\n", PNG_LIBPNG_VER_STRING, png_libpng_ver);
+        else {
+            int compilerID;
+            png_uint_32 mmx_mask = png_get_mmx_flagmask(
+              PNG_SELECT_READ | PNG_SELECT_WRITE, &compilerID);
+
+            fprintf(stderr, "   Compiled with libpng %s; using libpng %s "
+              "with MMX support\n   (%s version).", PNG_LIBPNG_VER_STRING,
+              png_libpng_ver, compilerID == 1? "MSVC++" :
+              (compilerID == 2? "GNU C" : "unknown"));
+            fprintf(stderr, "  Processor %s MMX instructions.\n",
+              mmxsupport? "supports" : "does not support");
+            if (mmxsupport > 0) {
+                int num_optims = 0;
+
+                fprintf(stderr,
+                  "      Potential MMX optimizations supported by libpng:\n");
+                if (mmx_mask & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)
+                    ++num_optims;
+                if (mmx_mask & PNG_ASM_FLAG_MMX_READ_FILTER_UP)
+                    ++num_optims;
+                if (mmx_mask & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)
+                    ++num_optims;
+                if (mmx_mask & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)
+                    ++num_optims;
+                if (num_optims)
+                    fprintf(stderr,
+                      "         decoding %s row filters (reading)\n",
+                      (num_optims == 4)? "all non-trivial" : "some");
+                if (mmx_mask & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) {
+                    fprintf(stderr, "         combining rows (reading)\n");
+                    ++num_optims;
+                }
+                if (mmx_mask & PNG_ASM_FLAG_MMX_READ_INTERLACE) {
+                    fprintf(stderr,
+                      "         expanding interlacing (reading)\n");
+                    ++num_optims;
+                }
+                mmx_mask &= ~( 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 (mmx_mask) {
+                    fprintf(stderr, "         other (unknown)\n");
+                    ++num_optims;
+                }
+                if (num_optims == 0)
+                    fprintf(stderr, "         (none)\n");
+            }
+        }
+    }
+#else
    fprintf(stderr, "   Compiled with libpng %s; using libpng %s.\n",
      PNG_LIBPNG_VER_STRING, png_libpng_ver);
+#endif

    fprintf(stderr, "   Compiled with zlib %s; using zlib %s.\n",
      ZLIB_VERSION, zlib_version);
@@ -111,6 +180,97 @@ int readpng2_init(mainprog_info *mainprog_ptr)
    png_set_progressive_read_fn(png_ptr, mainprog_ptr,
      readpng2_info_callback, readpng2_row_callback, readpng2_end_callback);

+
+    /*
+     * may as well enable or disable MMX routines here, if supported;
+     *
+     * to enable all:  mask = png_get_mmx_flagmask (
+     *                   PNG_SELECT_READ | PNG_SELECT_WRITE, &compilerID);
+     *                 flags = png_get_asm_flags (png_ptr);
+     *                 flags |= mask;
+     *                 png_set_asm_flags (png_ptr, flags);
+     *
+     * to disable all:  mask = png_get_mmx_flagmask (
+     *                   PNG_SELECT_READ | PNG_SELECT_WRITE, &compilerID);
+     *                  flags = png_get_asm_flags (png_ptr);
+     *                  flags &= ~mask;
+     *                  png_set_asm_flags (png_ptr, flags);
+     */
+
+#if (defined(__i386__) || defined(_M_IX86)) && \
+    defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)
+    /*
+     * WARNING:  This preprocessor approach means that the following code
+     *           cannot be used with a libpng DLL older than 1.2.0--the
+     *           compiled-in symbols for the new functions will not exist.
+     *           (Could use dlopen() and dlsym() on Unix and corresponding
+     *           calls for Windows, but not portable...)
+     */
+    {
+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
+        png_uint_32 mmx_disable_mask = 0;
+        png_uint_32 asm_flags, mmx_mask;
+        int compilerID;
+
+        if (mainprog_ptr->nommxfilters)
+            mmx_disable_mask |= ( 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 (mainprog_ptr->nommxcombine)
+            mmx_disable_mask |= PNG_ASM_FLAG_MMX_READ_COMBINE_ROW;
+        if (mainprog_ptr->nommxinterlace)
+            mmx_disable_mask |= PNG_ASM_FLAG_MMX_READ_INTERLACE;
+        asm_flags = png_get_asm_flags(png_ptr);
+        png_set_asm_flags(png_ptr, asm_flags & ~mmx_disable_mask);
+
+
+        /* Now query libpng's asm settings, just for yuks.  Note that this
+         * differs from the querying of its *potential* MMX capabilities
+         * in readpng2_version_info(); this is true runtime verification. */
+
+        asm_flags = png_get_asm_flags(png_ptr);
+        mmx_mask = png_get_mmx_flagmask(PNG_SELECT_READ | PNG_SELECT_WRITE,
+          &compilerID);
+        if (asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_COMPILED)
+            fprintf(stderr,
+              "  MMX support (%s version) is compiled into libpng\n",
+              compilerID == 1? "MSVC++" :
+              (compilerID == 2? "GNU C" : "unknown"));
+        else
+            fprintf(stderr, "  MMX support is not compiled into libpng\n");
+        fprintf(stderr, "  MMX instructions are %ssupported by CPU\n",
+          (asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU)? "" : "not ");
+        fprintf(stderr, "  MMX read support for combining rows is %sabled\n",
+          (asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)? "en" : "dis");
+        fprintf(stderr,
+          "  MMX read support for expanding interlacing is %sabled\n",
+          (asm_flags & PNG_ASM_FLAG_MMX_READ_INTERLACE)? "en" : "dis");
+        fprintf(stderr, "  MMX read support for \"sub\" filter is %sabled\n",
+          (asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)? "en" : "dis");
+        fprintf(stderr, "  MMX read support for \"up\" filter is %sabled\n",
+          (asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP)? "en" : "dis");
+        fprintf(stderr, "  MMX read support for \"avg\" filter is %sabled\n",
+          (asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)? "en" : "dis");
+        fprintf(stderr, "  MMX read support for \"Paeth\" filter is %sabled\n",
+          (asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)? "en" : "dis");
+        asm_flags &= (mmx_mask & ~( 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 (asm_flags)
+            fprintf(stderr,
+              "  additional MMX support is also enabled (0x%02lx)\n",
+              asm_flags);
+#else  /* !PNG_ASSEMBLER_CODE_SUPPORTED */
+        fprintf(stderr, "  MMX querying is disabled in libpng.\n");
+#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */
+    }
+#endif
+
+
    /* make sure we save our pointers for use in readpng2_decode_data() */

    mainprog_ptr->png_ptr = png_ptr;
@@ -370,6 +530,7 @@ static void readpng2_end_callback(png_structp png_ptr, png_infop info_ptr)

    (*mainprog_ptr->mainprog_finish_display)();

+    info_ptr = info_ptr; /* without this the compiler whines about info_ptr */

    /* all done */

--- a/contrib/msvctest/msvctest.dsp
+++ b/contrib/msvctest/msvctest.dsp
@@ -54,7 +54,7 @@ BSC32=bscmake.exe
 # ADD BSC32 /nologo
 LINK32=link.exe
 # ADD BASE LINK32 /nologo /subsystem:console /machine:I386
-# ADD LINK32 ..\..\projects\msvc\win32\libpng\dll\libpng1.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 ..\..\projects\msvc\win32\libpng\dll\libpng3.lib /nologo /subsystem:console /machine:I386
 # Begin Special Build Tool
 OutDir=.\dll
 SOURCE="$(InputPath)"
@@ -84,7 +84,7 @@ BSC32=bscmake.exe
 # ADD BSC32 /nologo
 LINK32=link.exe
 # ADD BASE LINK32 /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 ..\..\projects\msvc\win32\libpng\dll_dbg\libpng1d.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 ..\..\projects\msvc\win32\libpng\dll_dbg\libpng3d.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
 # Begin Special Build Tool
 OutDir=.\dll_dbg
 SOURCE="$(InputPath)"
@@ -114,7 +114,7 @@ BSC32=bscmake.exe
 # ADD BSC32 /nologo
 LINK32=link.exe
 # ADD BASE LINK32 /nologo /subsystem:console /machine:I386
-# ADD LINK32 ..\..\projects\msvc\win32\libpng\dll_asm\libpng1a.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 ..\..\projects\msvc\win32\libpng\dll_asm\libpng3a.lib /nologo /subsystem:console /machine:I386
 # Begin Special Build Tool
 OutDir=.\dll_asm
 SOURCE="$(InputPath)"
@@ -144,7 +144,7 @@ BSC32=bscmake.exe
 # ADD BSC32 /nologo
 LINK32=link.exe
 # ADD BASE LINK32 /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 ..\..\projects\msvc\win32\libpng\dll_dbga\libpng1b.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 ..\..\projects\msvc\win32\libpng\dll_dbga\libpng3b.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
 # Begin Special Build Tool
 OutDir=.\dll_dbga
 SOURCE="$(InputPath)"
--- a/contrib/visupng/PngFile.c
+++ b/contrib/visupng/PngFile.c
@@ -370,14 +370,14 @@ BOOL PngSaveImage (PTSTR pstrFileName, png_byte *pDiData,
        
        // clean up after the write, and free any memory allocated
        
-        png_destroy_write_struct(&png_ptr, &info_ptr);
+        png_destroy_write_struct(&png_ptr, (png_infopp) NULL);
        
        // yepp, done
    }

    Catch (msg)
    {
-        png_destroy_write_struct(&png_ptr, &info_ptr);
+        png_destroy_write_struct(&png_ptr, (png_infopp) NULL);

        if(ppbRowPointers)
            free (ppbRowPointers);
--- a/contrib/visupng/VisualPng.dsp
+++ b/contrib/visupng/VisualPng.dsp
@@ -59,8 +59,8 @@ BSC32=bscmake.exe
 # ADD BASE BSC32 /nologo
 # ADD BSC32 /nologo
 LINK32=link.exe
-# ADD BASE LINK32 libpng1.lib zlibd.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /libpath:"libpng" /libpath:"zlib"
-# ADD LINK32 libpng1.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /libpath:"..\..\projects\msvc\win32\libpng\dll"
+# ADD BASE LINK32 libpng3.lib zlibd.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /libpath:"libpng" /libpath:"zlib"
+# ADD LINK32 libpng3.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /libpath:"..\..\projects\msvc\win32\libpng\dll"
 # Begin Special Build Tool
 OutDir=.\dll
 SOURCE="$(InputPath)"
@@ -92,9 +92,9 @@ BSC32=bscmake.exe
 # ADD BASE BSC32 /nologo
 # ADD BSC32 /nologo
 LINK32=link.exe
-# ADD BASE LINK32 libpng1.lib zlibd.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /nodefaultlib:"libc" /pdbtype:sept /libpath:"libpng" /libpath:"zlib"
+# ADD BASE LINK32 libpng3.lib zlibd.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /nodefaultlib:"libc" /pdbtype:sept /libpath:"libpng" /libpath:"zlib"
 # SUBTRACT BASE LINK32 /nodefaultlib
-# ADD LINK32 libpng1d.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /nodefaultlib:"libc" /pdbtype:sept /libpath:"..\..\projects\msvc\win32\libpng\dll_dbg"
+# ADD LINK32 libpng3d.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /nodefaultlib:"libc" /pdbtype:sept /libpath:"..\..\projects\msvc\win32\libpng\dll_dbg"
 # SUBTRACT LINK32 /nodefaultlib
 # Begin Special Build Tool
 OutDir=.\dll_dbg
@@ -128,7 +128,7 @@ BSC32=bscmake.exe
 # ADD BASE BSC32 /nologo
 # ADD BSC32 /nologo
 LINK32=link.exe
-# ADD BASE LINK32 libpng1.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /libpath:"..\..\projects\msvc\win32\libpng\dll"
+# ADD BASE LINK32 libpng3.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /libpath:"..\..\projects\msvc\win32\libpng\dll"
 # ADD LINK32 libpng.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /libpath:"..\..\projects\msvc\win32\libpng\lib"
 # Begin Special Build Tool
 OutDir=.\lib
@@ -161,7 +161,7 @@ BSC32=bscmake.exe
 # ADD BASE BSC32 /nologo
 # ADD BSC32 /nologo
 LINK32=link.exe
-# ADD BASE LINK32 libpng1d.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /nodefaultlib:"libc" /pdbtype:sept /libpath:"..\..\projects\msvc\win32\libpng\dll_dbg"
+# ADD BASE LINK32 libpng3d.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /nodefaultlib:"libc" /pdbtype:sept /libpath:"..\..\projects\msvc\win32\libpng\dll_dbg"
 # SUBTRACT BASE LINK32 /nodefaultlib
 # ADD LINK32 libpng.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /nodefaultlib:"libc" /pdbtype:sept /libpath:"..\..\projects\msvc\win32\libpng\lib_dbg"
 # SUBTRACT LINK32 /nodefaultlib
--- a/example.c
+++ b/example.c
@@ -338,7 +338,8 @@ void read_png(FILE *fp, unsigned int sig_read)  /* file is already open */

   for (row = 0; row < height; row++)
   {
-      row_pointers[row] = malloc(png_get_rowbytes(png_ptr, info_ptr));
+      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 */
@@ -605,8 +606,6 @@ void write_png(char *file_name /* , ... other image information ... */)
   /* set the palette if there is one.  REQUIRED for indexed-color images */
   palette = (png_colorp)png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH
             * sizeof (png_color));
-   if (palette == NULL)
-      png_error(png_ptr, "Example: malloc of palette failed");
   /* ... 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
--- a/libpng.3
+++ b/libpng.3
@@ -1,6 +1,6 @@
-.TH LIBPNG 3 "April 15, 2001"
+.TH LIBPNG 3 "May 18, 2001"
 .SH NAME
-libpng \- Portable Network Graphics (PNG) Reference Library 1.0.11beta3
+libpng \- Portable Network Graphics (PNG) Reference Library 1.2.0beta3
 .SH SYNOPSIS
 \fI\fB

@@ -100,6 +100,10 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.0.11beta3

 \fI\fB

+\fBpng_uint_32 png_get_asm_flags (png_structp \fIpng_ptr\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
@@ -192,6 +196,18 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.0.11beta3

 \fI\fB

+\fBpng_byte png_get_mmx_bitdepth_threshold (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
+\fBpng_uint_32 png_get_mmx_flagmask (int \fP\fIflag_select\fP\fB, int \fI*compilerID\fP\fB);\fP
+
+\fI\fB
+
+\fBpng_uint_32 png_get_mmx_rowbytes_threshold (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
@@ -302,11 +318,15 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.0.11beta3

 \fI\fB

-\fBvoid png_info_init (png_infop \fIinfo_ptr\fP\fB);\fP
+\fBvoid png_init_io (png_structp \fP\fIpng_ptr\fP\fB, FILE \fI*fp\fP\fB);\fP

 \fI\fB

-\fBvoid png_init_io (png_structp \fP\fIpng_ptr\fP\fB, FILE \fI*fp\fP\fB);\fP
+\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

@@ -334,7 +354,11 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.0.11beta3

 \fI\fB

-\fBvoid png_permit_empty_plte (png_structp \fP\fIpng_ptr\fP\fB, int \fIempty_plte_permitted\fP\fB);\fP
+\fBint png_mmx_support \fI(void\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

@@ -362,7 +386,9 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.0.11beta3

 \fI\fB

-\fBDEPRECATED: void png_read_init_2 (png_structp \fP\fIpng_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
+\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

@@ -384,6 +410,10 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.0.11beta3

 \fI\fB

+\fBpng_set_asm_flags (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fIasm_flags\fP\fB);\fP
+
+\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
@@ -512,6 +542,10 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.0.11beta3

 \fI\fB

+\fBpng_set_mmx_thresholds (png_structp \fP\fIpng_ptr\fP\fB, png_byte \fP\fImmx_bitdepth_threshold\fP\fB, png_uint_32 \fImmx_rowbytes_threshold\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
@@ -604,6 +638,12 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.0.11beta3

 \fI\fB

+\fBvoid png_set_strip_error_numbers (png_structp \fIpng_ptr,
+
+\fBpng_uint_32 \fIstrip_mode\fP\fB);\fP
+
+\fI\fB
+
 \fBvoid png_set_swap (png_structp \fIpng_ptr\fP\fB);\fP

 \fI\fB
@@ -712,7 +752,7 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.0.11beta3

 \fI\fB

-\fBDEPRECATED: void png_write_init_2 (png_structp \fP\fIpng_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
+\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

@@ -747,10 +787,10 @@ 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.0.11beta3 - April 15, 2001
+ libpng version 1.2.0beta3 - May 18, 2001
 Updated and distributed by Glenn Randers-Pehrson
 <randeg@alum.rpi.edu>
- Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
+ Copyright (c) 1998-2001 Glenn Randers-Pehrson
 For conditions of distribution and use, see copyright
 notice in png.h.

@@ -1033,7 +1073,8 @@ 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);
+    void read_row_callback(png_ptr ptr, png_uint_32 row,
+       int pass);
    {
      /* put your code here */
    }
@@ -2142,10 +2183,9 @@ png_infop info_ptr;

 /* 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)
+    png_uint_32 row_num, int pass)
 {
    /* If the image is interlaced, and you turned
       on the interlace handler, this function will
@@ -3061,6 +3101,10 @@ Your replacement memory functions must have prototypes as follows:
       png_uint_32 size);
    void free_fn(png_structp png_ptr, png_voidp ptr);

+Your malloc_fn() can return NULL in case of failure.  The png_malloc()
+function will 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
@@ -3387,8 +3431,106 @@ 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

-.SH VI.  MNG support
+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).
+
+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.
@@ -3413,7 +3555,7 @@ 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 VII.  Changes to Libpng from version 0.88
+.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
@@ -3423,7 +3565,7 @@ 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_destory() have been
+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.

@@ -3462,15 +3604,15 @@ application:

   png_uint_32 application_vn = PNG_LIBPNG_VER;

-.SH VIII. Y2K Compliance in libpng
+.SH IX. Y2K Compliance in libpng

-April 15, 2001
+May 18, 2001

 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.0.11beta3 are Y2K compliant.  It is my belief that earlier
+upward through 1.2.0beta3 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
@@ -3580,6 +3722,12 @@ the first widely used release:
 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.12a              2    10012  2.1.0.12a
+ 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           3    10200  3.1.2.0beta3

 Henceforth the source version will match the shared-library minor
 and patch numbers; the shared-library major version number will be
@@ -3637,7 +3785,7 @@ possible without all of you.

 Thanks to Frank J. T. Wojcik for helping with the documentation.

-Libpng version 1.0.11beta3 - April 15, 2001:
+Libpng version 1.2.0beta3 - May 18, 2001:
 Initially created in 1995 by Guy Eric Schalnat, then of Group 42, Inc.
 Currently maintained by Glenn Randers-Pehrson (randeg@alum.rpi.edu).

@@ -3654,7 +3802,7 @@ included in the libpng distribution, the latter shall prevail.)
 If you modify libpng you may insert additional notices immediately following
 this sentence.

-libpng versions 1.0.7, July 1, 2000, through  1.0.11beta3, April 15, 2001, are
+libpng versions 1.0.7, July 1, 2000, through  1.2.0beta3, May 18, 2001, are
 Copyright (c) 2000-2001 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
@@ -3746,7 +3894,7 @@ certification mark of the Open Source Initiative.

 Glenn Randers-Pehrson
 randeg@alum.rpi.edu
-April 15, 2001
+May 18, 2001

 .\" end of man page

--- a/libpng.txt
+++ b/libpng.txt
@@ -1,9 +1,9 @@
 libpng.txt - A description on how to use and modify libpng

- libpng version 1.0.11beta3 - April 15, 2001
+ libpng version 1.2.0beta3 - May 18, 2001
 Updated and distributed by Glenn Randers-Pehrson
 <randeg@alum.rpi.edu>
- Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
+ Copyright (c) 1998-2001 Glenn Randers-Pehrson
 For conditions of distribution and use, see copyright
 notice in png.h.

@@ -286,7 +286,8 @@ 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);
+    void read_row_callback(png_ptr ptr, png_uint_32 row,
+       int pass);
    {
      /* put your code here */
    }
@@ -1395,10 +1396,9 @@ png_infop info_ptr;

 /* 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)
+    png_uint_32 row_num, int pass)
 {
    /* If the image is interlaced, and you turned
       on the interlace handler, this function will
@@ -2314,6 +2314,10 @@ Your replacement memory functions must have prototypes as follows:
       png_uint_32 size);
    void free_fn(png_structp png_ptr, png_voidp ptr);

+Your malloc_fn() can return NULL in case of failure.  The png_malloc()
+function will 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
@@ -2640,8 +2644,106 @@ 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

-VI.  MNG support
+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).
+
+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.
@@ -2666,7 +2768,7 @@ 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.

-VII.  Changes to Libpng from version 0.88
+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
@@ -2676,7 +2778,7 @@ 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_destory() have been
+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.

@@ -2715,15 +2817,15 @@ application:

   png_uint_32 application_vn = PNG_LIBPNG_VER;

-VIII. Y2K Compliance in libpng
+IX. Y2K Compliance in libpng

-April 15, 2001
+May 18, 2001

 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.0.11beta3 are Y2K compliant.  It is my belief that earlier
+upward through 1.2.0beta3 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
--- a/libpngpf.3
+++ b/libpngpf.3
@@ -1,6 +1,6 @@
-.TH LIBPNGPF 3 "April 15, 2001"
+.TH LIBPNGPF 3 "May 18, 2001"
 .SH NAME
-libpng \- Portable Network Graphics (PNG) Reference Library 1.0.11beta3
+libpng \- Portable Network Graphics (PNG) Reference Library 1.2.0beta3
 (private functions)
 .SH SYNOPSIS
 \fB#include <png.h>\fP
@@ -47,11 +47,11 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.0.11beta3

 \fI\fB

-\fBpng_voidp png_create_struct (int \fP\fItype\fP\fB, png_malloc_ptr \fImalloc_fn\fP\fB);\fP
+\fBpng_voidp png_create_struct (int \fItype\fP\fB);\fP

 \fI\fB

-\fBpng_voidp png_create_struct_2 (int \fItype\fP\fB);\fP
+\fBpng_voidp png_create_struct_2 (int \fP\fItype\fP\fB, png_malloc_ptr \fP\fImalloc_fn\fP\fB, png_voidp \fImem_ptr\fP\fB);\fP

 \fI\fB

@@ -63,7 +63,7 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.0.11beta3

 \fI\fB

-\fBvoid png_destroy_struct_2 (png_voidp \fP\fIstruct_ptr\fP\fB, png_free_ptr \fIfree_fn\fP\fB);\fP
+\fBvoid png_destroy_struct_2 (png_voidp \fP\fIstruct_ptr\fP\fB, png_free_ptr \fP\fIfree_fn\fP\fB, png_voidp \fImem_ptr\fP\fB);\fP

 \fI\fB

@@ -283,6 +283,10 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.0.11beta3

 \fI\fB

+\fBvoid png_init_mmx_flags (png_structp \fIpng_ptr\fP\fB);\fP
+
+\fI\fB
+
 \fBvoid png_init_read_transformations (png_structp \fIpng_ptr\fP\fB);\fP

 \fI\fB
@@ -425,6 +429,8 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.0.11beta3

 \fBvoid png_write_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_filtered_row (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fIfiltered_row\fP\fB);\fP

 \fI\fB
@@ -539,7 +545,8 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.0.11beta3

 .SH DESCRIPTION
 The functions listed above are used privately by libpng
-and are not recommended for use by applications.  They
+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.

--- a/png.5
+++ b/png.5
@@ -1,4 +1,4 @@
-.TH PNG 5 "April 15, 2001"
+.TH PNG 5 "May 18, 2001"
 .SH NAME
 png \- Portable Network Graphics (PNG) format
 .SH DESCRIPTION
--- a/png.c
+++ b/png.c
@@ -1,7 +1,7 @@

 /* png.c - location for general purpose libpng functions
 *
- * libpng version 1.0.11beta3 - April 15, 2001
+ * libpng version 1.2.0beta3 - May 18, 2001
 * Copyright (c) 1998-2001 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.)
@@ -13,14 +13,14 @@
 #include "png.h"

 /* Generate a compiler error if there is an old png.h in the search path. */
-typedef version_1_0_11beta3 Your_png_h_is_not_version_1_0_11beta3;
+typedef version_1_2_0beta3 Your_png_h_is_not_version_1_2_0beta3;

 /* 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] = "1.0.11beta3";
+const char png_libpng_ver[18] = "1.2.0beta3";

 /* png_sig was changed to a function in version 1.0.5c */
 /* Place to hold the signature string for a PNG file. */
@@ -142,18 +142,15 @@ png_zalloc(voidpf png_ptr, uInt items, uInt size)
   png_voidp ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);

 #ifndef PNG_NO_ZALLOC_ZERO
-   if (ptr)
+   if (num_bytes > (png_uint_32)0x8000L)
   {
-     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);
-     }
+      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);
@@ -216,12 +213,12 @@ png_create_info_struct(png_structp png_ptr)
   if(png_ptr == NULL) return (NULL);
 #ifdef PNG_USER_MEM_SUPPORTED
   if ((info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
-      png_ptr->malloc_fn)) != NULL)
+      png_ptr->malloc_fn, png_ptr->mem_ptr)) != NULL)
 #else
   if ((info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO)) != NULL)
 #endif
   {
-      png_info_init(info_ptr);
+      png_info_init_3(&info_ptr, sizeof(png_info));
   }

   return (info_ptr);
@@ -246,7 +243,8 @@ png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
      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_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,
+          png_ptr->mem_ptr);
 #else
      png_destroy_struct((png_voidp)info_ptr);
 #endif
@@ -258,10 +256,28 @@ png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
 * and applications using it are urged to use png_create_info_struct()
 * instead.
 */
-void /* PRIVATE */
+#undef png_info_init
+void PNGAPI
 png_info_init(png_infop info_ptr)
 {
-   png_debug(1, "in png_info_init\n");
+   /* We only come here via pre-1.0.12-compiled applications */
+   png_info_init_3(&info_ptr, 0);
+}
+
+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(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, sizeof (png_info));
 }
@@ -285,7 +301,8 @@ png_data_freer(png_structp png_ptr, png_infop info_ptr,
 #endif

 void PNGAPI
-png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, int num)
+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)
@@ -539,7 +556,7 @@ png_info_destroy(png_structp png_ptr, png_infop info_ptr)
   }
 #endif

-   png_info_init(info_ptr);
+   png_info_init_3(&info_ptr, sizeof(png_info));
 }

 /* This function returns a pointer to the io_ptr associated with the user
@@ -584,31 +601,27 @@ png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
         sizeof(char)));
   }

-   if (png_ptr->time_buffer == NULL)
-      png_warning(png_ptr, "Malloc of buffer for tIME chunk failed");
-   else
-   {
 #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);
-     }
+   {
+      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*sizeof(char));
-     }
+   {
+      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*sizeof(char));
+   }
 #else
   sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000",
       ptime->day % 32, short_months[(ptime->month - 1) % 12],
@@ -616,7 +629,6 @@ png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
       ptime->second % 61);
 #endif
 #endif /* _WIN32_WCE */
-   }
   return ((png_charp)png_ptr->time_buffer);
 }
 #endif /* PNG_TIME_RFC1123_SUPPORTED */
@@ -634,7 +646,7 @@ png_charp PNGAPI
 png_get_copyright(png_structp png_ptr)
 {
   if (png_ptr != NULL || png_ptr == NULL)  /* silence compiler warning */
-   return ((png_charp) "\n libpng version 1.0.11beta3 - April 15, 2001\n\
+   return ((png_charp) "\n libpng version 1.2.0beta3 - May 18, 2001\n\
   Copyright (c) 1998-2001 Glenn Randers-Pehrson\n\
   Copyright (c) 1996, 1997 Andreas Dilger\n\
   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.\n");
@@ -652,8 +664,8 @@ 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) "1.0.11beta3");
-   return((png_charp) "1.0.11beta3");
+      return((png_charp) "1.2.0beta3");
+   return((png_charp) "1.2.0beta3");
 }

 png_charp PNGAPI
@@ -703,17 +715,64 @@ png_uint_32 PNGAPI
 png_access_version_number(void)
 {
   /* Version of *.c files used when building libpng */
-   return((png_uint_32) 10011L);
+   return((png_uint_32) 10200L);
 }


-#if 0 /* delay this until version 1.2.0 */
-/* this function was added to libpng 1.0.9 (porting aid to libpng-1.2.0) */
-#ifndef PNG_ASSEMBLER_CODE_SUPPORTED
+#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()) {
+        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 /* 0 */
--- a/png.h
+++ b/png.h
@@ -1,7 +1,7 @@

 /* png.h - header file for PNG reference library
 *
- * libpng version 1.0.11beta3 - April 15, 2001
+ * libpng version 1.2.0beta3 - May 18, 2001
 * Copyright (c) 1998-2001 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.)
@@ -9,7 +9,7 @@
 * 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.0.11beta3 - April 15, 2001: Glenn
+ *  libpng versions 0.97, January 1998, through 1.2.0beta3 - May 18, 2001: Glenn
 *  See also "Contributing Authors", below.
 *
 * Note about libpng version numbers:
@@ -68,6 +68,12 @@
 *    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.12a                  2    10012  2.1.0.12a
+ *    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               3    10200  3.1.2.0beta3
 *
 *    Henceforth the source version will match the shared-library major
 *    and minor numbers; the shared-library major version number will be
@@ -97,7 +103,7 @@
 * If you modify libpng you may insert additional notices immediately following
 * this sentence.
 *
- * libpng versions 1.0.7, July 1, 2000, through  1.0.11beta3, April 15, 2001, are
+ * libpng versions 1.0.7, July 1, 2000, through  1.2.0beta3, May 18, 2001, are
 * Copyright (c) 2000, 2001 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
@@ -202,13 +208,13 @@
 * Y2K compliance in libpng:
 * =========================
 *
- *    April 15, 2001
+ *    May 18, 2001
 *
 *    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.0.11beta3 are Y2K compliant.  It is my belief that earlier
+ *    upward through 1.2.0beta3 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
@@ -264,15 +270,15 @@
 */

 /* Version information for png.h - this should match the version in png.c */
-#define PNG_LIBPNG_VER_STRING "1.0.11beta3"
+#define PNG_LIBPNG_VER_STRING "1.2.0beta3"

-#define PNG_LIBPNG_VER_SONUM   2
+#define PNG_LIBPNG_VER_SONUM   3
 #define PNG_LIBPNG_VER_DLLNUM  %DLLNUM%

 /* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */
 #define PNG_LIBPNG_VER_MAJOR   1
-#define PNG_LIBPNG_VER_MINOR   0
-#define PNG_LIBPNG_VER_RELEASE 11
+#define PNG_LIBPNG_VER_MINOR   2
+#define PNG_LIBPNG_VER_RELEASE 0
 /* This should match the numeric part of the final component of
 * PNG_LIBPNG_VER_STRING, omitting any leading zero: */

@@ -291,7 +297,7 @@
 * 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 10011 /* 1.0.11 */
+#define PNG_LIBPNG_VER 10200 /* 1.2.0 */

 #ifndef PNG_VERSION_INFO_ONLY

@@ -697,6 +703,7 @@ defined(PNG_READ_BACKGROUND_SUPPORTED)
   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
@@ -1137,12 +1144,6 @@ struct png_struct_def
   png_charp time_buffer;            /* String to hold RFC 1123 time text */
 #endif

-#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 members added in libpng-1.0.6 */

 #ifdef PNG_FREE_ME_SUPPORTED
@@ -1159,35 +1160,59 @@ struct png_struct_def
   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)
-/* Note to maintainer: change this to png_uint_32 at next opportunity */
-   png_byte mng_features_permitted;
+/* changed from png_byte to png_uint_32 at version 1.2.0 */
+   png_uint_32 mng_features_permitted;
 #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_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_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

 };


 /* This prevents a compiler error in png_get_copyright() in png.c if png.c
-and png.h are both at * version 1.0.11beta3
+   and png.h are both at version 1.2.0beta3
 */
-typedef png_structp version_1_0_11beta3;
+typedef png_structp version_1_2_0beta3;

 typedef png_struct FAR * FAR * png_structpp;

@@ -1238,6 +1263,7 @@ extern PNG_EXPORT(void,png_set_compression_buffer_size)
 /* 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,
@@ -1268,8 +1294,11 @@ extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr));
 extern PNG_EXPORT(png_infop,png_create_info_struct)
   PNGARG((png_structp png_ptr));

-/* Initialize the info structure (old interface - NOT DLL EXPORTED) */
-extern void png_info_init PNGARG((png_infop info_ptr));
+/* Initialize the info structure (old interface - DEPRECATED) */
+extern PNG_EXPORT(void,png_info_init) PNGARG((png_infop info_ptr));
+#define png_info_init(info_ptr) png_info_init_3(&(info_ptr), 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,
@@ -2227,15 +2256,80 @@ extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp
   png_ptr, png_uint_32 mng_features_permitted));
 #endif

-#if 0 /* delay these until version 1.2.0 */
+/* 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
+
+
+/* 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_ASSEMBLER_CODE_SUPPORTED */
+
 /* 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

 /* Maintainer: Put new public prototypes here ^, in libpng.3, and project defs */

 #define PNG_HEADER_VERSION_STRING \
-   " libpng version 1.0.11beta3 - April 15, 2001 (header)\n"
+   " libpng version 1.2.0beta3 - May 18, 2001 (header)\n"

 #ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED
 /* With these routines we avoid an integer divide, which will be slower on
@@ -2358,6 +2452,8 @@ extern PNG_EXPORT(int,png_mmx_support) PNGARG((void));
 #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

 /* For use in png_set_keep_unknown, png_handle_as_unknown */
 #define HANDLE_CHUNK_AS_DEFAULT   0
@@ -2466,8 +2562,10 @@ PNG_EXTERN png_uint_16 png_get_uint_16 PNGARG((png_bytep buf));
 * (old interface - DEPRECATED - use png_create_read_struct instead).
 */
 extern PNG_EXPORT(void,png_read_init) PNGARG((png_structp png_ptr));
-#define png_read_init(png_ptr) png_read_init_2(png_ptr, \
-    PNG_LIBPNG_VER_STRING,  sizeof(png_struct), sizeof(png_info));
+#define png_read_init(png_ptr) png_read_init_3(&(png_ptr), \
+    PNG_LIBPNG_VER_STRING,  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));
@@ -2476,8 +2574,10 @@ extern PNG_EXPORT(void,png_read_init_2) PNGARG((png_structp png_ptr,
 * (old interface - DEPRECATED - use png_create_write_struct instead).
 */
 extern PNG_EXPORT(void,png_write_init) PNGARG((png_structp png_ptr));
-#define png_write_init(png_ptr) png_write_init_2(png_ptr, \
-    PNG_LIBPNG_VER_STRING, sizeof(png_struct), sizeof(png_info));
+#define png_write_init(png_ptr) png_write_init_3(&(png_ptr), \
+    PNG_LIBPNG_VER_STRING, 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));
@@ -2489,9 +2589,9 @@ PNG_EXTERN png_voidp png_create_struct PNGARG((int type));
 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));
+  malloc_fn, png_voidp mem_ptr));
 PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr,
-   png_free_ptr free_fn));
+   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,
@@ -3035,6 +3135,10 @@ 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 */
--- a/pngasmrd.h
+++ b/pngasmrd.h
@@ -1,6 +1,6 @@
 /* pngasmrd.h - assembler version of utilities to read a PNG file
 *
- * libpng 1.0.11beta3 - April 15, 2001
+ * libpng 1.2.0beta3 - May 18, 2001
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 2001 Glenn Randers-Pehrson
 *
--- a/pngconf.h
+++ b/pngconf.h
@@ -1,6 +1,6 @@
 /* pngconf.h - machine configurable file for libpng
 *
- * libpng 1.0.11beta3 - April 15, 2001
+ * libpng 1.2.0beta3 - May 18, 2001
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2001 Glenn Randers-Pehrson
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -45,15 +45,13 @@
 #  define PNG_WRITE_SUPPORTED
 #endif

-/* Enable if you need to support PNGs that are embedded in MNG
-   datastreams */
-/*
+/* 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 */
 #ifndef 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
@@ -91,47 +89,58 @@
 * 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 
 */
 #if defined(__CYGWIN__)
-#  if defined(PNG_BUILD_DLL)
+#  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)
-#      define PNG_DLL
+#    if defined(PNG_DLL)
+#      undef PNG_DLL
 #    endif
-#    if defined(PNG_STATIC)
-#      undef PNG_STATIC
-#    endif
-#  else
-#    if defined(ALL_STATIC)
+#    if !defined(PNG_STATIC)
 #      define PNG_STATIC
 #    endif
-#    if defined(PNG_STATIC)
+#  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)
-#        undef PNG_DLL
+#      if !defined(PNG_DLL)
+#        define PNG_DLL
 #      endif
 #    else
-#      if defined(PNG_USE_DLL)
+#      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
-#      else
-#        if defined(PNG_DLL)
-#           define PNG_USE_DLL
-#        else
-#           define PNG_USE_DLL
-#           define PNG_DLL
-#        endif
-#      endif
-#    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
@@ -306,7 +315,8 @@
 #  include "alloc.h"
 #endif

-#ifdef _MSC_VER
+#if defined(_MSC_VER) && (defined(WIN32) || defined(_Windows) || \
+    defined(_WINDOWS) || defined(_WIN32) || defined(__WIN32__))
 #  include <malloc.h>
 #endif

@@ -578,6 +588,10 @@
 #  define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
 #endif

+#ifndef PNG_NO_ERROR_NUMBERS
+#define PNG_ERROR_NUMBERS_SUPPORTED
+#endif
+
 #ifndef PNG_NO_WRITE_FLUSH
 #  define PNG_WRITE_FLUSH_SUPPORTED
 #endif
@@ -609,21 +623,23 @@
 * png_get_x_offset_microns()
 * png_get_y_offset_microns()
 */
-#ifndef PNG_NO_EASY_ACCESS
+#if !defined(PNG_NO_EASY_ACCESS) && !defined(PNG_EASY_ACCESS_SUPPORTED)
 #  define PNG_EASY_ACCESS_SUPPORTED
 #endif

-/* PNG_ASSEMBLER_CODE will be enabled by default in version 1.2.0 
+/* 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)
-#  if defined(PNG_USE_PNGVCRD) || defined(PNG_USE_PNGGCCRD)
-#    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
+#  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 !defined(PNG_NO_USER_MEM) && !defined(PNG_USER_MEM_SUPPORTED)
+#  define PNG_USER_MEM_SUPPORTED
 #endif

 /* These are currently experimental features, define them if you want */
@@ -635,9 +651,6 @@
 #    define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED
 #  endif
 #endif
-#ifndef PNG_NO_USER_MEM
-#  define PNG_USER_MEM_SUPPORTED
-#endif
 #ifndef PNG_NO_ZALLOC_ZERO
 #  define PNG_ZALLOC_ZERO
 #endif
--- a/pngerror.c
+++ b/pngerror.c
@@ -1,7 +1,7 @@

 /* pngerror.c - stub functions for i/o and memory allocation
 *
- * libpng 1.0.11beta3 - April 15, 2001
+ * libpng 1.2.0beta3 - May 18, 2001
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2001 Glenn Randers-Pehrson
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -31,6 +31,38 @@ png_default_warning PNGARG((png_structp png_ptr,
 void PNGAPI
 png_error(png_structp png_ptr, png_const_charp message)
 {
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+   char msg[16];
+   if (png_ptr->flags&(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
+   {
+     int offset = 0;
+     if (*message == '#')
+     {
+         for (offset=1; offset<15; offset++)
+            if (*(message+offset) == ' ')
+                break;
+         if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
+         {
+            int i;
+            for (i=0; i<offset-1; i++)
+               msg[i]=message[i+1];
+            msg[i]='\0';
+            message=msg;
+         }
+         else
+            message+=offset;
+     }
+     else
+     {
+         if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
+         {
+            msg[0]='0';        
+            msg[1]='\0';
+            message=msg;
+         }
+     }
+   }
+#endif
   if (png_ptr->error_fn != NULL)
      (*(png_ptr->error_fn))(png_ptr, message);

@@ -47,10 +79,22 @@ png_error(png_structp png_ptr, png_const_charp message)
 void PNGAPI
 png_warning(png_structp png_ptr, png_const_charp 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 (*message == '#')
+     {
+         for (offset=1; offset<15; offset++)
+            if (*(message+offset) == ' ')
+                break;
+     }
+   }
   if (png_ptr->warning_fn != NULL)
-      (*(png_ptr->warning_fn))(png_ptr, message);
+      (*(png_ptr->warning_fn))(png_ptr, (png_const_charp)(message+offset));
   else
-      png_default_warning(png_ptr, message);
+      png_default_warning(png_ptr, (png_const_charp)(message+offset));
 }

 /* These utilities are used internally to build an error message that relates
@@ -61,11 +105,12 @@ png_warning(png_structp png_ptr, png_const_charp message)
 */
 #define isnonalpha(c) ((c) < 41 || (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'
-};
+   '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 message)
+png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp
+   message)
 {
   int iout = 0, iin = 0;

@@ -121,6 +166,27 @@ static void /* PRIVATE */
 png_default_error(png_structp png_ptr, png_const_charp message)
 {
 #ifndef PNG_NO_CONSOLE_IO
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+   if (*message == '#')
+   {
+     int offset;
+     char error_number[16];
+     for (offset=0; offset<15; offset++)
+     {
+         error_number[offset] = *(message+offset+1);
+         if (*(message+offset) == ' ')
+             break;
+     }
+     if((offset > 1) && (offset < 15))
+     {
+       error_number[offset-1]='\0';
+       fprintf(stderr, "libpng error no. %s: %s\n", error_number, message+offset);
+     }
+     else
+       fprintf(stderr, "libpng error: %s, offset=%d\n", message,offset);
+   }
+   else
+#endif
   fprintf(stderr, "libpng error: %s\n", message);
 #else
   if (message)
@@ -153,7 +219,29 @@ static void /* PRIVATE */
 png_default_warning(png_structp png_ptr, png_const_charp message)
 {
 #ifndef PNG_NO_CONSOLE_IO
-   fprintf(stderr, "libpng warning: %s\n", message);
+#  ifdef PNG_ERROR_NUMBERS_SUPPORTED
+   if (*message == '#')
+   {
+     int offset;
+     char warning_number[16];
+     for (offset=0; offset<15; offset++)
+     {
+        warning_number[offset]=*(message+offset+1);
+        if (*(message+offset) == ' ')
+            break;
+     }
+     if((offset > 1) && (offset < 15))
+     {
+       warning_number[offset-1]='\0';
+       fprintf(stderr, "libpng warning no. %s: %s\n", warning_number,
+          message+offset);
+     }
+     else
+       fprintf(stderr, "libpng warning: %s\n", message);
+   }
+   else
+#  endif
+     fprintf(stderr, "libpng warning: %s\n", message);
 #else
   if (message)
     /* appease compiler */ ;
@@ -188,4 +276,15 @@ png_get_error_ptr(png_structp png_ptr)
 }


+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+void
+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

--- a/pnggccrd.c
+++ b/pnggccrd.c
@@ -6,7 +6,7 @@
 *     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.0.11beta3 - April 15, 2001
+ * libpng version 1.2.0beta3 - May 18, 2001
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2001 Glenn Randers-Pehrson
 * Copyright (c) 1998, Intel Corporation
@@ -203,9 +203,14 @@
 *     - "_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
+ *     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
@@ -226,15 +231,9 @@
 *     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)
- *     - add support for runtime enable/disable/query of various MMX routines
+ *     x add support for runtime enable/disable/query of various MMX routines
 */

-/*
-#ifndef PNG_DEBUG
-#  define PNG_DEBUG 0
-#endif
-*/
-
 #define PNG_INTERNAL
 #include "png.h"

@@ -333,8 +332,37 @@ static int          _dif;
 static int          _patemp;	// temp variables for Paeth routine
 static int          _pbtemp;
 static int          _pctemp;
+
+static void /* PRIVATE */
+png_squelch_warnings(void)
+{
+   _dif = _dif;
+   _patemp = _patemp;
+   _pbtemp = _pbtemp;
+   _pctemp = _pctemp;
+   _const4  = _const4;
+   _const6  = _const6;
+   _MMXLength = _MMXLength;
+   _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;

 /*===========================================================================*/
@@ -370,9 +398,13 @@ 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) {
+       /* this should have happened in png_init_mmx_flags() already */
+       png_warning(png_ptr, "asm_flags may not have been initialized");
       png_mmx_support();
   }
+#endif

   if (mask == 0xff)
   {
@@ -556,7 +588,8 @@ png_combine_row(png_structp png_ptr, png_bytep row, int mask)
            png_bytep dstptr;

 #if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
-            if ( _mmx_supported  )
+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
+                /* && _mmx_supported */ )
            {
               png_uint_32 len;
               int diff;
@@ -689,7 +722,8 @@ png_combine_row(png_structp png_ptr, png_bytep row, int mask)
            png_bytep dstptr;

 #if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
-            if ( _mmx_supported )
+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
+                /* && _mmx_supported */ )
            {
               png_uint_32 len;
               int diff;
@@ -837,7 +871,8 @@ png_combine_row(png_structp png_ptr, png_bytep row, int mask)
            png_bytep dstptr;

 #if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
-            if ( _mmx_supported )
+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
+                /* && _mmx_supported */ )
            {
               png_uint_32 len;
               int diff;
@@ -1000,7 +1035,8 @@ png_combine_row(png_structp png_ptr, png_bytep row, int mask)
            png_bytep dstptr;

 #if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
-            if ( _mmx_supported )
+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
+                /* && _mmx_supported */ )
            {
               png_uint_32 len;
               int diff;
@@ -1170,7 +1206,8 @@ png_combine_row(png_structp png_ptr, png_bytep row, int mask)
            png_bytep dstptr;

 #if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
-            if ( _mmx_supported )
+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
+                /* && _mmx_supported */ )
            {
               png_uint_32 len;
               int diff;
@@ -1436,9 +1473,13 @@ png_do_read_interlace(png_structp png_ptr)

   png_debug(1, "in png_do_read_interlace (pnggccrd.c)\n");

+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
   if (_mmx_supported == 2) {
+       /* this should have happened in png_init_mmx_flags() already */
+       png_warning(png_ptr, "asm_flags may not have been initialized");
       png_mmx_support();
   }
+#endif

   if (row != NULL && row_info != NULL)
   {
@@ -1644,7 +1685,8 @@ png_do_read_interlace(png_structp png_ptr)
            /* New code by Nirav Chhatrapati - Intel Corporation */

 #if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
-            if ( _mmx_supported )
+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_INTERLACE)
+                /* && _mmx_supported */ )
            {
               //--------------------------------------------------------------
               if (pixel_bytes == 3)
@@ -2665,7 +2707,7 @@ png_do_read_interlace(png_structp png_ptr)



-
+#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
@@ -2678,8 +2720,6 @@ union uAll {
  _HBClearMask = {0x7f7f7f7f7f7f7f7fLL},
  _ActiveMask, _ActiveMask2, _ActiveMaskEnd, _ShiftBpp, _ShiftRem;

-
-
 //===========================================================================//
 //                                                                           //
 //           P N G _ R E A D _ F I L T E R _ R O W _ M M X _ A V G           //
@@ -4884,7 +4924,6 @@ png_read_filter_row_mmx_up(png_row_infop row_info, png_bytep row,
 /*                                                                           */
 /*===========================================================================*/

-#if defined(PNG_HAVE_ASSEMBLER_READ_FILTER_ROW)

 /* Optimized png_read_filter_row routines */

@@ -4904,6 +4943,8 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep
 #define UseMMX_paeth  1   // GRR:  converted 20000828

   if (_mmx_supported == 2) {
+       /* this should have happened in png_init_mmx_flags() already */
+       png_warning(png_ptr, "asm_flags may not have been initialized");
       png_mmx_support();
   }
 #endif /* PNG_ASSEMBLER_CODE_SUPPORTED */
@@ -4914,13 +4955,29 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep
   {
      case 0: sprintf(filnm, "none");
         break;
-      case 1: sprintf(filnm, "sub-%s", "MMX");
+      case 1: sprintf(filnm, "sub-%s",
+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
+        (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)? "MMX" : 
+#endif
+"x86");
         break;
-      case 2: sprintf(filnm, "up-%s", "MMX");
+      case 2: sprintf(filnm, "up-%s",
+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
+        (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP)? "MMX" :
+#endif
+ "x86");
         break;
-      case 3: sprintf(filnm, "avg-%s", "MMX");
+      case 3: sprintf(filnm, "avg-%s",
+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
+        (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)? "MMX" :
+#endif
+ "x86");
         break;
-      case 4: sprintf(filnm, "Paeth-%s", "MMX");
+      case 4: sprintf(filnm, "Paeth-%s",
+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
+        (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)? "MMX":
+#endif
+"x86");
         break;
      default: sprintf(filnm, "unknw");
         break;
@@ -4939,9 +4996,9 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep

      case PNG_FILTER_VALUE_SUB:
 #if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
-         if ( _mmx_supported &&
-             (row_info->pixel_depth >= PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT) &&
-             (row_info->rowbytes >= PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT))
+         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))
         {
            png_read_filter_row_mmx_sub(row_info, row);
         }
@@ -4964,9 +5021,9 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep

      case PNG_FILTER_VALUE_UP:
 #if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
-         if ( _mmx_supported &&
-             (row_info->pixel_depth >= PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT) &&
-             (row_info->rowbytes >= PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT))
+         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))
         {
            png_read_filter_row_mmx_up(row_info, row, prev_row);
         }
@@ -4988,9 +5045,9 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep

      case PNG_FILTER_VALUE_AVG:
 #if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
-         if ( _mmx_supported &&
-             (row_info->pixel_depth >= PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT) &&
-             (row_info->rowbytes >= PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT))
+         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))
         {
            png_read_filter_row_mmx_avg(row_info, row, prev_row);
         }
@@ -5022,9 +5079,9 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep

      case PNG_FILTER_VALUE_PAETH:
 #if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
-         if ( _mmx_supported &&
-             (row_info->pixel_depth >= PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT) &&
-             (row_info->rowbytes >= PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT))
+         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))
         {
            png_read_filter_row_mmx_paeth(row_info, row, prev_row);
         }
@@ -5177,4 +5234,5 @@ png_mmx_support(void)
    return _mmx_supported;
 }

+
 #endif /* PNG_USE_PNGGCCRD */
--- a/pngget.c
+++ b/pngget.c
@@ -1,7 +1,7 @@

 /* pngget.c - retrieval of values from info struct
 *
- * libpng 1.0.11beta3 - April 15, 2001
+ * libpng 1.2.0beta3 - May 18, 2001
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2001 Glenn Randers-Pehrson
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -137,7 +137,7 @@ png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
 #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");
+      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);
@@ -826,3 +826,92 @@ png_get_compression_buffer_size(png_structp png_ptr)
   return (png_uint_32)(png_ptr? png_ptr->zbuf_size : 0L);
 }

+
+#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 */
--- a/pngmem.c
+++ b/pngmem.c
@@ -1,7 +1,7 @@

 /* pngmem.c - stub functions for memory allocation
 *
- * libpng 1.0.11beta3 - April 15, 2001
+ * libpng 1.2.0beta3 - May 18, 2001
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2001 Glenn Randers-Pehrson
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -27,12 +27,12 @@ png_voidp /* PRIVATE */
 png_create_struct(int type)
 {
 #ifdef PNG_USER_MEM_SUPPORTED
-   return (png_create_struct_2(type, NULL));
+   return (png_create_struct_2(type, NULL, 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_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
 {
 #endif /* PNG_USER_MEM_SUPPORTED */
   png_size_t size;
@@ -48,9 +48,18 @@ png_create_struct_2(int type, png_malloc_ptr malloc_fn)
 #ifdef PNG_USER_MEM_SUPPORTED
   if(malloc_fn != NULL)
   {
-      if ((struct_ptr = (*(malloc_fn))(NULL, size)) != NULL)
+      if (mem_ptr != NULL)
+      {
+         png_struct dummy_struct;
+         png_structp png_ptr = &dummy_struct;
+         png_ptr->mem_ptr=mem_ptr;
+         struct_ptr = (*(malloc_fn))(png_ptr, size);
+      }
+      else
+         struct_ptr = (*(malloc_fn))(NULL, size);
+      if (struct_ptr != NULL)
         png_memset(struct_ptr, 0, size);
-         return (struct_ptr);
+      return (struct_ptr);
   }
 #endif /* PNG_USER_MEM_SUPPORTED */
   if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL)
@@ -66,12 +75,13 @@ 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_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_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
+    png_voidp mem_ptr)
 {
 #endif
   if (struct_ptr != NULL)
@@ -81,6 +91,7 @@ png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn)
      {
         png_struct dummy_struct;
         png_structp png_ptr = &dummy_struct;
+         png_ptr->mem_ptr=mem_ptr;
         (*(free_fn))(png_ptr, struct_ptr);
         return;
      }
@@ -119,7 +130,12 @@ png_malloc(png_structp png_ptr, png_uint_32 size)

 #ifdef PNG_USER_MEM_SUPPORTED
   if(png_ptr->malloc_fn != NULL)
-       return ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, size));
+   {
+       ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, size));
+       if (ret == NULL)
+          png_error(png_ptr, "Out of memory!");
+       return (ret);
+   }
   else
       return png_malloc_default(png_ptr, size);
 }
@@ -281,14 +297,14 @@ png_voidp /* PRIVATE */
 png_create_struct(int type)
 {
 #ifdef PNG_USER_MEM_SUPPORTED
-   return (png_create_struct_2(type, NULL));
+   return (png_create_struct_2(type, NULL, 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_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
 {
 #endif /* PNG_USER_MEM_SUPPORTED */
   png_size_t size;
@@ -304,7 +320,16 @@ png_create_struct_2(int type, png_malloc_ptr malloc_fn)
 #ifdef PNG_USER_MEM_SUPPORTED
   if(malloc_fn != NULL)
   {
-      if ((struct_ptr = (*(malloc_fn))(NULL, size)) != NULL)
+      if (mem_ptr != NULL)
+      {
+         png_struct dummy_struct;
+         png_structp png_ptr = &dummy_struct;
+         png_ptr->mem_ptr=mem_ptr;
+         struct_ptr = (*(malloc_fn))(png_ptr, size);
+      }
+      else
+         struct_ptr = (*(malloc_fn))(NULL, size);
+      if (struct_ptr != NULL)
         png_memset(struct_ptr, 0, size);
      return (struct_ptr);
   }
@@ -332,12 +357,13 @@ 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_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_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)
@@ -347,6 +373,7 @@ png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn)
      {
         png_struct dummy_struct;
         png_structp png_ptr = &dummy_struct;
+         png_ptr->mem_ptr=mem_ptr;
         (*(free_fn))(png_ptr, struct_ptr);
         return;
      }
@@ -373,15 +400,18 @@ png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn)
 png_voidp PNGAPI
 png_malloc(png_structp png_ptr, png_uint_32 size)
 {
-#ifndef PNG_USER_MEM_SUPPORTED
   png_voidp ret;
-#endif
   if (png_ptr == NULL || size == 0)
      return ((png_voidp)NULL);

 #ifdef PNG_USER_MEM_SUPPORTED
   if(png_ptr->malloc_fn != NULL)
-       return ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, size));
+   {
+       ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, size));
+       if (ret == NULL)
+          png_error(png_ptr, "Out of Memory!");
+       return (ret);
+   }
   else
       return (png_malloc_default(png_ptr, size));
 }
@@ -407,9 +437,7 @@ png_malloc_default(png_structp png_ptr, png_uint_32 size)
 #endif

   if (ret == NULL)
-   {
      png_error(png_ptr, "Out of Memory");
-   }

   return (ret);
 }
--- a/pngpread.c
+++ b/pngpread.c
@@ -1,7 +1,7 @@

 /* pngpread.c - read a png file in push mode
 *
- * libpng 1.0.11beta3 - April 15, 2001
+ * libpng 1.2.0beta3 - May 18, 2001
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2001 Glenn Randers-Pehrson
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -585,18 +585,9 @@ png_push_save_buffer(png_structp png_ptr)
      old_buffer = png_ptr->save_buffer;
      png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr,
         (png_uint_32)new_max);
-      if (png_ptr->save_buffer == (png_bytep)NULL)
-      {
-        png_warning(png_ptr, "Malloc of save buffer failed");
-        png_ptr->save_buffer=old_buffer;
-        png_ptr->current_buffer_size = 0;
-      }
-      else
-      {
-        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;
-      }
+      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)
   {
@@ -1004,7 +995,8 @@ png_read_push_finish_row(png_structp png_ptr)

 #if defined(PNG_READ_tEXt_SUPPORTED)
 void /* PRIVATE */
-png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+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))
      {
@@ -1016,7 +1008,7 @@ png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length
 #ifdef PNG_MAX_MALLOC_64K
   png_ptr->skip_length = 0;  /* This may not be necessary */

-   if (length > (png_uint_32)65535L) /* Can't hold the entire string in memory */
+   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;
@@ -1026,12 +1018,6 @@ png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length

   png_ptr->current_text = (png_charp)png_malloc(png_ptr,
         (png_uint_32)(length+1));
-   if (png_ptr->current_text == (png_charp)NULL)
-   {
-       png_warning (png_ptr, "malloc of current text failed");
-       png_ptr->skip_length=length;
-       return;
-   }
   png_ptr->current_text[length] = '\0';
   png_ptr->current_text_ptr = png_ptr->current_text;
   png_ptr->current_text_size = (png_size_t)length;
@@ -1083,11 +1069,6 @@ png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
         text++;

      text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text));
-      if (text_ptr == (png_textp)NULL)
-        {
-           png_warning (png_ptr, "malloc of text buffer failed");
-           return;
-        }
      text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;
      text_ptr->key = key;
 #ifdef PNG_iTXt_SUPPORTED
@@ -1106,7 +1087,8 @@ png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)

 #if defined(PNG_READ_zTXt_SUPPORTED)
 void /* PRIVATE */
-png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
+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))
      {
@@ -1130,12 +1112,6 @@ png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length

   png_ptr->current_text = (png_charp)png_malloc(png_ptr,
       (png_uint_32)(length+1));
-   if (png_ptr->current_text == (png_charp)NULL)
-   {
-      png_warning (png_ptr, "malloc of zTXt buffer failed");
-      png_push_crc_skip(png_ptr, length);
-      return;
-   }
   png_ptr->current_text[length] = '\0';
   png_ptr->current_text_ptr = png_ptr->current_text;
   png_ptr->current_text_size = (png_size_t)length;
@@ -1224,19 +1200,14 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
            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));
-               if (text == (png_charp)NULL)
-                 png_warning(png_ptr, "Malloc of text block failed");
-               else
-               {
-                 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';
-               }
+                  (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
            {
@@ -1246,17 +1217,12 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
               text = (png_charp)png_malloc(png_ptr, text_size +
                  (png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out
                   + 1));
-               if (text != (png_charp)NULL)
-                 png_warning(png_ptr, "Malloc of new text block failed");
-               else
-               {
-                 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';
-               }
+               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)
            {
@@ -1288,30 +1254,26 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
      text += key_size;

      text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text));
-      if (text_ptr == (png_textp)NULL)
-         png_warning (png_ptr, "Malloc of iTXt failed");
-      else
-      {
-        text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt;
-        text_ptr->key = key;
+      text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt;
+      text_ptr->key = key;
 #ifdef PNG_iTXt_SUPPORTED
-        text_ptr->lang = (char *)NULL;
-        text_ptr->lang_key = (char *)NULL;
+      text_ptr->lang = (char *)NULL;
+      text_ptr->lang_key = (char *)NULL;
 #endif
-        text_ptr->text = text;
+      text_ptr->text = text;

-        png_set_text(png_ptr, info_ptr, text_ptr, 1);
+      png_set_text(png_ptr, info_ptr, text_ptr, 1);

-        png_free(png_ptr, text_ptr);
-      }
      png_free(png_ptr, key);
+      png_free(png_ptr, text_ptr);
   }
 }
 #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)
+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))
      {
@@ -1323,7 +1285,7 @@ png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length
 #ifdef PNG_MAX_MALLOC_64K
   png_ptr->skip_length = 0;  /* This may not be necessary */

-   if (length > (png_uint_32)65535L) /* Can't hold the entire string in memory */
+   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;
@@ -1333,16 +1295,11 @@ png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length

   png_ptr->current_text = (png_charp)png_malloc(png_ptr,
         (png_uint_32)(length+1));
-   if (png_ptr->current_text == (png_charp)NULL)
-        png_warning (png_ptr, "malloc of iTXt buffer failed");
-   else
-     {
-       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;
-     }
+   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 */
@@ -1406,10 +1363,6 @@ png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
         text++;

      text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text));
-      if(text_ptr == (png_textp)NULL)
-         png_warning (png_ptr, "Malloc of iTXt pointer failed");
-      else
-      {
      text_ptr->compression = comp_flag + 2;
      text_ptr->key = key;
      text_ptr->lang = lang;
@@ -1421,7 +1374,6 @@ png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
      png_set_text(png_ptr, info_ptr, text_ptr, 1);

      png_free(png_ptr, text_ptr);
-      }
   }
 }
 #endif
@@ -1431,7 +1383,8 @@ png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
 * 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_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);
@@ -1442,7 +1395,7 @@ png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 len
      if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
           HANDLE_CHUNK_ALWAYS
 #if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
-           && png_ptr->read_user_chunk_fn == (png_user_chunk_ptr)NULL
+           && png_ptr->read_user_chunk_fn == NULL
 #endif
         )
 #endif
@@ -1469,30 +1422,25 @@ png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 len

       png_strcpy((png_charp)chunk.name, (png_charp)png_ptr->chunk_name);
       chunk.data = (png_bytep)png_malloc(png_ptr, length);
-       if (chunk.data == (png_bytep)NULL)
-          png_warning (png_ptr, "Malloc of unknown chunk data failed");
-       else
-       {
-         png_crc_read(png_ptr, chunk.data, length);
-         chunk.size = 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 != (png_user_chunk_ptr)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) !=
-                       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);
+       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) !=
+                     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
--- a/pngread.c
+++ b/pngread.c
@@ -1,7 +1,7 @@

 /* pngread.c - read a PNG file
 *
- * libpng 1.0.11beta3 - April 15, 2001
+ * libpng 1.2.0beta3 - May 18, 2001
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2001 Glenn Randers-Pehrson
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -46,7 +46,7 @@ png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
   png_debug(1, "in png_create_read_struct\n");
 #ifdef PNG_USER_MEM_SUPPORTED
   if ((png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
-      (png_malloc_ptr)malloc_fn)) == NULL)
+      (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr)) == NULL)
 #else
   if ((png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG)) == NULL)
 #endif
@@ -54,6 +54,10 @@ png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
      return (png_structp)NULL;
   }

+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
+   png_init_mmx_flags(png_ptr);   /* 1.2.0 addition */
+#endif
+
 #ifdef PNG_SETJMP_SUPPORTED
 #ifdef USE_FAR_KEYWORD
   if (setjmp(jmpbuf))
@@ -92,6 +96,7 @@ png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
      * 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'))
     {
        png_error(png_ptr,
@@ -99,15 +104,17 @@ png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
     }

     /* Libpng 1.0.6 was not binary compatible, due to insertion of the
-        info_ptr->free_me member.  Note to maintainer: this test can be
-        removed from version 2.0.0 and beyond because the previous test
-        would have already rejected it. */
+        info_ptr->free_me member.  Libpng-1.0.1 and earlier were not
+        compatible due to insertion of the user transform function. Note
+        to maintainer: this test can be removed from version 1.2.0 and
+        beyond because the previous test would have already rejected it. */

-     if (user_png_ver[4] == '6' && user_png_ver[2] == '0' &&
-         user_png_ver[0] == '1' && user_png_ver[5] == '\0')
+     if (user_png_ver[0] == '1' && user_png_ver[2] == '0' &&
+         (user_png_ver[4] <  '2' || user_png_ver[4] == '6') &&
+         user_png_ver[5] == '\0')
     {
        png_error(png_ptr,
-           "Application must be recompiled; version 1.0.6 was incompatible");
+        "Application must be recompiled; versions <= 1.0.6 were incompatible");
     }
   }

@@ -115,8 +122,6 @@ png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
   png_ptr->zbuf_size = PNG_ZBUF_SIZE;
   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
     (png_uint_32)png_ptr->zbuf_size);
-   if (png_ptr->zbuf == (png_bytep)NULL)
-      png_error(png_ptr, "Could not allocate zbuf");
   png_ptr->zstream.zalloc = png_zalloc;
   png_ptr->zstream.zfree = png_zfree;
   png_ptr->zstream.opaque = (voidpf)png_ptr;
@@ -146,18 +151,42 @@ 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.0", 10000, 10000);
+   png_read_init_2(png_ptr, "1.0.0", 0, 0);
 }

+#undef png_read_init_2
 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(sizeof(png_struct) > png_struct_size)
+     {
+       png_ptr->error_fn=(png_error_ptr)NULL;
+       png_error(png_ptr,
+       "The png struct allocated by the application for reading is too small.");
+     }
+   if(sizeof(png_info) > png_info_size)
+     {
+       png_ptr->error_fn=(png_error_ptr)NULL;
+       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])
@@ -165,28 +194,28 @@ png_read_init_2(png_structp png_ptr, png_const_charp user_png_ver,
 #ifdef PNG_LEGACY_SUPPORTED
       png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
 #else
-       png_ptr->error_fn=(png_error_ptr)NULL;
-       png_error(png_ptr,
-        "Application uses deprecated png_read_init() and must be recompiled.");
+       png_ptr->warning_fn=(png_error_ptr)NULL;
+       png_warning(png_ptr,
+        "Application uses deprecated png_read_init() and should be recompiled.");
+       break;
 #endif
     }
   } while (png_libpng_ver[i++]);

-   if(sizeof(png_struct) > png_struct_size ||
-      sizeof(png_info) > png_info_size)
-     {
-       png_ptr->error_fn=(png_error_ptr)NULL;
-       png_error(png_ptr,
-      "Application and library have different sized structs. Please recompile.");
-     }
-
-   png_debug(1, "in png_read_init_2\n");
+   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, sizeof (jmp_buf));
 #endif

+   if(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, sizeof (png_struct));

@@ -199,8 +228,6 @@ png_read_init_2(png_structp png_ptr, png_const_charp user_png_ver,
   png_ptr->zbuf_size = PNG_ZBUF_SIZE;
   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
     (png_uint_32)png_ptr->zbuf_size);
-   if (png_ptr->zbuf == (png_bytep)NULL)
-      png_error(png_ptr, "Could not allocate zbuf");
   png_ptr->zstream.zalloc = png_zalloc;
   png_ptr->zstream.zfree = png_zfree;
   png_ptr->zstream.opaque = (voidpf)png_ptr;
@@ -719,7 +746,7 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
 * 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.0.11beta3
+ * [*] png_handle_alpha() does not exist yet, as of libpng version 1.2.0beta3
 */

 void PNGAPI
@@ -768,7 +795,7 @@ png_read_rows(png_structp png_ptr, png_bytepp row,
 * 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.0.11beta3
+ * [*] png_handle_alpha() does not exist yet, as of libpng version 1.2.0beta3
 */
 void PNGAPI
 png_read_image(png_structp png_ptr, png_bytepp image)
@@ -998,6 +1025,7 @@ png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
   png_infop info_ptr = NULL, end_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_read_struct\n");
@@ -1013,6 +1041,7 @@ png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp 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);
@@ -1024,7 +1053,8 @@ png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
 #endif

 #ifdef PNG_USER_MEM_SUPPORTED
-      png_destroy_struct_2((png_voidp)info_ptr, free_fn);
+      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
@@ -1037,7 +1067,8 @@ png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
      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, free_fn);
+      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
@@ -1047,7 +1078,8 @@ png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
   if (png_ptr != NULL)
   {
 #ifdef PNG_USER_MEM_SUPPORTED
-      png_destroy_struct_2((png_voidp)png_ptr, free_fn);
+      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
@@ -1322,8 +1354,6 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
   {
      info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,
         info_ptr->height * sizeof(png_bytep));
-      if (info_ptr->row_pointers)
-         png_error(png_ptr, "png_read_png could not allocate row pointers");
 #ifdef PNG_FREE_ME_SUPPORTED
      info_ptr->free_me |= PNG_FREE_ROWS;
 #endif
@@ -1331,15 +1361,6 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
      {
         info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,
            png_get_rowbytes(png_ptr, info_ptr));
-         if (info_ptr->row_pointers)
-         {
-            int allocated_row;
-            for (allocated_row=0; allocated_row < row; allocated_row++)
-               png_free(png_ptr, info_ptr->row_pointers[allocated_row]);
-            if (info_ptr->free_me & !(PNG_FREE_ROWS))
-               png_free (png_ptr, info_ptr->row_pointers);
-            png_error(png_ptr, "png_read_png could not allocate row pointer");
-         }
      }
   }

@@ -1349,7 +1370,7 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
   /* read rest of file, and get additional chunks in info_ptr - REQUIRED */
   png_read_end(png_ptr, info_ptr);

-   if(transforms == 0 || params == (voidp)NULL)
+   if(transforms == 0 || params == NULL)
      /* quiet compiler warnings */ return;

 }
--- a/pngrio.c
+++ b/pngrio.c
@@ -1,7 +1,7 @@

 /* pngrio.c - functions for data input
 *
- * libpng 1.0.11beta3 - April 15, 2001
+ * libpng 1.2.0beta3 - May 18, 2001
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2001 Glenn Randers-Pehrson
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -26,7 +26,7 @@
 void /* PRIVATE */
 png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
 {
-   png_debug1(4,"reading %d bytes\n", 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
--- a/pngrtran.c
+++ b/pngrtran.c
@@ -1,7 +1,7 @@

 /* pngrtran.c - transforms the data in a row for PNG readers
 *
- * libpng 1.0.11beta3 - April 15, 2001
+ * libpng 1.2.0beta3 - May 18, 2001
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2001 Glenn Randers-Pehrson
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -155,11 +155,6 @@ png_set_dither(png_structp png_ptr, png_colorp palette,

      png_ptr->dither_index = (png_bytep)png_malloc(png_ptr,
         (png_uint_32)(num_palette * sizeof (png_byte)));
-      if (png_ptr->dither_index == (png_bytep)NULL)
-      {
-         png_warning (png_ptr, "Malloc of dither index failed");
-         return;
-      }
      for (i = 0; i < num_palette; i++)
         png_ptr->dither_index[i] = (png_byte)i;
   }
@@ -177,12 +172,6 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
         /* initialize an array to sort colors */
         sort = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_palette
            * sizeof (png_byte)));
-         if (sort == (png_bytep)NULL)
-         {
-            png_warning (png_ptr, "Malloc of sort array for dither failed");
-            png_free (png_ptr, png_ptr->dither_index);
-            return;
-         }

         /* initialize the sort array */
         for (i = 0; i < num_palette; i++)
@@ -313,14 +302,6 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
            (png_uint_32)(num_palette * sizeof (png_byte)));
         palette_to_index = (png_bytep)png_malloc(png_ptr,
            (png_uint_32)(num_palette * sizeof (png_byte)));
-         if (index_to_palette == (png_bytep)NULL || palette_to_index ==
-            (png_bytep)NULL)
-         {
-            png_warning (png_ptr, "Malloc of index array for dither failed");
-            png_free (png_ptr, index_to_palette);
-            png_free (png_ptr, png_ptr->dither_index);
-            return;
-         }

         /* initialize the sort array */
         for (i = 0; i < num_palette; i++)
@@ -331,14 +312,6 @@ png_set_dither(png_structp png_ptr, png_colorp palette,

         hash = (png_dsortpp)png_malloc(png_ptr, (png_uint_32)(769 *
            sizeof (png_dsortp)));
-         if (hash == (png_dsortpp)NULL)
-         {
-            png_warning (png_ptr, "Malloc of hash array for dither failed");
-            png_free (png_ptr, palette_to_index);
-            png_free (png_ptr, index_to_palette);
-            png_free (png_ptr, png_ptr->dither_index);
-            return;
-         }
         for (i = 0; i < 769; i++)
            hash[i] = NULL;
 /*         png_memset(hash, 0, 769 * sizeof (png_dsortp)); */
@@ -373,13 +346,10 @@ png_set_dither(png_structp png_ptr, png_colorp palette,

                     t = (png_dsortp)png_malloc(png_ptr, (png_uint_32)(sizeof
                         (png_dsort)));
-                     if (t != (png_dsortp)NULL)
-                     {
                     t->next = hash[d];
                     t->left = (png_byte)i;
                     t->right = (png_byte)j;
                     hash[d] = t;
-                     }
                  }
               }
            }
@@ -486,25 +456,16 @@ png_set_dither(png_structp png_ptr, png_colorp palette,

      png_ptr->palette_lookup = (png_bytep )png_malloc(png_ptr,
         (png_uint_32)(num_entries * sizeof (png_byte)));
-      if (png_ptr->palette_lookup == (png_bytep)NULL)
-      {
-         png_warning(png_ptr, "Malloc of palette_lookup for dither failed");
-      }
-      else
-        png_memset(png_ptr->palette_lookup, 0, num_entries * sizeof (png_byte));
+
+      png_memset(png_ptr->palette_lookup, 0, num_entries * sizeof (png_byte));

      distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries *
         sizeof(png_byte)));
-      if (distance == (png_bytep)NULL)
-      {
-         png_warning(png_ptr, "Malloc of distance array for dither failed");
-      }
-      else
-      {
-        png_memset(distance, 0xff, num_entries * sizeof(png_byte));

-        for (i = 0; i < num_palette; i++)
-        {
+      png_memset(distance, 0xff, num_entries * 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));
@@ -535,12 +496,11 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
                     png_ptr->palette_lookup[d_index] = (png_byte)i;
                  }
               }
-             }
-           }
-        }
+            }
+         }
+      }

      png_free(png_ptr, distance);
-      }
   }
 }
 #endif
@@ -3898,11 +3858,6 @@ png_build_gamma_table(png_structp png_ptr)

      png_ptr->gamma_table = (png_bytep)png_malloc(png_ptr,
         (png_uint_32)256);
-      if (png_ptr->gamma_table == (png_bytep)NULL)
-      {
-         png_warning (png_ptr, "Malloc of gamma table failed");
-         return;
-      }

      for (i = 0; i < 256; i++)
      {
@@ -3919,11 +3874,6 @@ png_build_gamma_table(png_structp png_ptr)

         png_ptr->gamma_to_1 = (png_bytep)png_malloc(png_ptr,
            (png_uint_32)256);
-         if (png_ptr->gamma_to_1 == (png_bytep)NULL)
-         {
-         png_warning (png_ptr, "Malloc of gamma_to_1 table failed");
-         return;
-         }

         for (i = 0; i < 256; i++)
         {
@@ -3934,11 +3884,6 @@ png_build_gamma_table(png_structp png_ptr)

         png_ptr->gamma_from_1 = (png_bytep)png_malloc(png_ptr,
            (png_uint_32)256);
-         if (png_ptr->gamma_from_1 == (png_bytep)NULL)
-         {
-         png_warning (png_ptr, "Malloc of gamma_from_1 table failed");
-         return;
-         }

         if(png_ptr->screen_gamma > 0.000001)
            g = 1.0 / png_ptr->screen_gamma;
@@ -4001,11 +3946,6 @@ png_build_gamma_table(png_structp png_ptr)

      png_ptr->gamma_16_table = (png_uint_16pp)png_malloc(png_ptr,
         (png_uint_32)(num * sizeof (png_uint_16p)));
-      if (png_ptr->gamma_16_table == (png_uint_16pp)NULL)
-      {
-         png_warning (png_ptr, "Malloc of gamma_16 table failed");
-         return;
-      }

      if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND))
      {
@@ -4016,11 +3956,6 @@ png_build_gamma_table(png_structp png_ptr)
         {
            png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,
               (png_uint_32)(256 * sizeof (png_uint_16)));
-           if (png_ptr->gamma_16_table[i] == (png_uint_16p)NULL)
-           {
-              png_warning (png_ptr, "Malloc of gamma_16 table entry failed");
-              return;
-           }
         }

         g = 1.0 / g;
@@ -4051,11 +3986,6 @@ png_build_gamma_table(png_structp png_ptr)
         {
            png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,
               (png_uint_32)(256 * sizeof (png_uint_16)));
-            if (png_ptr->gamma_16_table[i] == (png_uint_16p)NULL)
-            {
-              png_warning (png_ptr, "Malloc of gamma_16 table entry failed");
-              return;
-            }

            ig = (((png_uint_32)i * (png_uint_32)png_gamma_shift[shift]) >> 4);
            for (j = 0; j < 256; j++)
@@ -4076,22 +4006,11 @@ png_build_gamma_table(png_structp png_ptr)

         png_ptr->gamma_16_to_1 = (png_uint_16pp)png_malloc(png_ptr,
            (png_uint_32)(num * sizeof (png_uint_16p )));
-         if (png_ptr->gamma_16_to_1 == (png_uint_16pp)NULL)
-         {
-            png_warning (png_ptr, "Malloc of gamma_16_to_1 table failed");
-            return;
-         }

         for (i = 0; i < num; i++)
         {
            png_ptr->gamma_16_to_1[i] = (png_uint_16p)png_malloc(png_ptr,
               (png_uint_32)(256 * sizeof (png_uint_16)));
-            if (png_ptr->gamma_16_to_1[i] == (png_uint_16p)NULL)
-            {
-               png_warning (png_ptr,
-                 "Malloc of gamma_16_to_1 table entry failed");
-               return;
-            }

            ig = (((png_uint_32)i *
               (png_uint_32)png_gamma_shift[shift]) >> 4);
@@ -4110,23 +4029,11 @@ png_build_gamma_table(png_structp png_ptr)

         png_ptr->gamma_16_from_1 = (png_uint_16pp)png_malloc(png_ptr,
            (png_uint_32)(num * sizeof (png_uint_16p)));
-         if (png_ptr->gamma_16_from_1 == (png_uint_16pp)NULL)
-         {
-            png_warning (png_ptr,
-              "Malloc of gamma_16_from_1 table failed");
-            return;
-         }

         for (i = 0; i < num; i++)
         {
            png_ptr->gamma_16_from_1[i] = (png_uint_16p)png_malloc(png_ptr,
               (png_uint_32)(256 * sizeof (png_uint_16)));
-            if (png_ptr->gamma_16_from_1[i] == (png_uint_16p)NULL)
-            {
-               png_warning (png_ptr,
-                 "Malloc of gamma_16_from_1 table failed");
-               return;
-            }

            ig = (((png_uint_32)i *
               (png_uint_32)png_gamma_shift[shift]) >> 4);
--- a/pngrutil.c
+++ b/pngrutil.c
@@ -1,7 +1,7 @@

 /* pngrutil.c - utilities to read a PNG file
 *
- * libpng 1.0.11beta3 - April 15, 2001
+ * libpng 1.2.0beta3 - May 18, 2001
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2001 Glenn Randers-Pehrson
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -201,19 +201,15 @@ png_decompress_chunk(png_structp png_ptr, int comp_type,
            {
               text_size = prefix_size + sizeof(msg) + 1;
               text = (png_charp)png_malloc(png_ptr, text_size);
-               if (text != NULL)
-                 png_memcpy(text, chunkdata, prefix_size);
+               png_memcpy(text, chunkdata, prefix_size);
            }

-            if (text != NULL)
-            {
-               text[text_size - 1] = 0x00;
+            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 = sizeof(msg) > text_size ? text_size : sizeof(msg);
-               png_memcpy(text + prefix_size, msg, text_size + 1);
-            }
+            /* Copy what we can of the error message into the text chunk */
+            text_size = (png_size_t)(chunklength - (text - chunkdata) - 1);
+            text_size = sizeof(msg) > text_size ? text_size : sizeof(msg);
+            png_memcpy(text + prefix_size, msg, text_size + 1);
            break;
         }
         if (!png_ptr->zstream.avail_out || ret == Z_STREAM_END)
@@ -223,13 +219,10 @@ png_decompress_chunk(png_structp png_ptr, int comp_type,
               text_size = prefix_size +
                   png_ptr->zbuf_size - png_ptr->zstream.avail_out;
               text = (png_charp)png_malloc(png_ptr, text_size + 1);
-               if (text != NULL)
-               {
-                 png_memcpy(text + prefix_size, png_ptr->zbuf,
-                          text_size - prefix_size);
-                 png_memcpy(text, chunkdata, prefix_size);
-                 *(text + text_size) = 0x00;
-               }
+               png_memcpy(text + prefix_size, png_ptr->zbuf,
+                    text_size - prefix_size);
+               png_memcpy(text, chunkdata, prefix_size);
+               *(text + text_size) = 0x00;
            }
            else
            {
@@ -238,20 +231,12 @@ png_decompress_chunk(png_structp png_ptr, int comp_type,
               tmp = text;
               text = (png_charp)png_malloc(png_ptr, (png_uint_32)(text_size +
                  png_ptr->zbuf_size - png_ptr->zstream.avail_out + 1));
-               if (text != NULL)
-               {
               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;
-               }
-               else
-               {
-                  png_warning (png_ptr, "Could not malloc text buffer");
-                  text=tmp;
-               }
            }
            if (ret == Z_STREAM_END)
               break;
@@ -285,13 +270,9 @@ png_decompress_chunk(png_structp png_ptr, int comp_type,
         if (text ==  NULL)
         {
            text = (png_charp)png_malloc(png_ptr, text_size+1);
-            if (text !=  NULL)
-               png_memcpy(text, chunkdata, prefix_size);
-            else
-               png_warning(png_ptr, "Could not malloc text chunkdata");
+            png_memcpy(text, chunkdata, prefix_size);
         }
-         if (text !=  NULL)
-            *(text + text_size) = 0x00;
+         *(text + text_size) = 0x00;
      }

      inflateReset(&png_ptr->zstream);
@@ -358,7 +339,9 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   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

   /* find number of channels */
   switch (png_ptr->color_type)
@@ -415,6 +398,13 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

   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)
   {
@@ -531,9 +521,7 @@ png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   {
      png_error(png_ptr, "No image in file");

-      /* to quiet compiler warnings about unused info_ptr */
-      if (info_ptr == NULL)
-         return;
+      info_ptr = info_ptr; /* quiet compiler warnings about unused info_ptr */
   }

   png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND);
@@ -1002,14 +990,7 @@ png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

   chunkdata = (png_charp)png_malloc(png_ptr, length + 1);
   slength = (png_size_t)length;
-   if (chunkdata != (png_charp)NULL)
-      png_crc_read(png_ptr, (png_bytep)chunkdata, slength);
-   else
-   {
-      png_warning(png_ptr, "Could not allocate memory for iCCP chunk");
-      png_crc_finish(png_ptr, slength);
-      return;
-   }
+   png_crc_read(png_ptr, (png_bytep)chunkdata, slength);

   if (png_crc_finish(png_ptr, skip))
   {
@@ -1105,16 +1086,8 @@ png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 #endif

   chunkdata = (png_bytep)png_malloc(png_ptr, length + 1);
-   if (chunkdata != (png_bytep)NULL)
-   {
-      slength = (png_size_t)length;
-      png_crc_read(png_ptr, (png_bytep)chunkdata, slength);
-   }
-   else
-   {
-      png_warning(png_ptr, "Could not allocate memory for sPLT chunk");
-      skip = (png_size_t)length;
-   }
+   slength = (png_size_t)length;
+   png_crc_read(png_ptr, (png_bytep)chunkdata, slength);

   if (png_crc_finish(png_ptr, skip))
   {
@@ -1151,12 +1124,6 @@ png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   new_palette.nentries = data_length / entry_size;
   new_palette.entries = (png_sPLT_entryp)png_malloc(
       png_ptr, new_palette.nentries * sizeof(png_sPLT_entry));
-   if (new_palette.entries == (png_sPLT_entryp)NULL)
-   {
-       png_free(png_ptr, chunkdata);
-       png_warning (png_ptr, "Could not allocate sPLT entries");
-       return;
-   }

 #ifndef PNG_NO_POINTER_INDEXING
   for (i = 0; i < new_palette.nentries; i++)
@@ -1566,12 +1533,6 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   png_debug1(2, "Allocating and reading pCAL chunk data (%lu bytes)\n",
      length + 1);
   purpose = (png_charp)png_malloc(png_ptr, length + 1);
-   if (purpose == (png_charp)NULL)
-   {
-     png_warning (png_ptr, "Could not allocate memory for pCAL purpose");
-     png_crc_finish(png_ptr, length);
-     return;
-   }
   slength = (png_size_t)length;
   png_crc_read(png_ptr, (png_bytep)purpose, slength);

@@ -1628,11 +1589,6 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   png_debug(3, "Allocating pCAL parameters array\n");
   params = (png_charpp)png_malloc(png_ptr, (png_uint_32)(nparams
      *sizeof(png_charp))) ;
-   if (params == (png_charpp)NULL)
-   {
-      png_warning (png_ptr, "Could not allocate pCAL parameters array");
-      nparams=0;
-   }

   /* Get pointers to the start of each parameter string. */
   for (i = 0; i < (int)nparams; i++)
@@ -1697,12 +1653,6 @@ png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   png_debug1(2, "Allocating and reading sCAL chunk data (%lu bytes)\n",
      length + 1);
   buffer = (png_charp)png_malloc(png_ptr, length + 1);
-   if (buffer == (png_charp)NULL)
-   {
-     png_warning (png_ptr, "Could not allocate memory for sCAL buffer");
-     png_crc_finish(png_ptr, length);
-     return;
-   }
   slength = (png_size_t)length;
   png_crc_read(png_ptr, (png_bytep)buffer, slength);

@@ -1726,8 +1676,7 @@ png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 #else
 #ifdef PNG_FIXED_POINT_SUPPORTED
   swidth = (png_charp)png_malloc(png_ptr, png_strlen(ep) + 1);
-   if (swidth != (png_charp)NULL)
-     png_memcpy(swidth, ep, (png_size_t)png_strlen(ep));
+   png_memcpy(swidth, ep, (png_size_t)png_strlen(ep));
 #endif
 #endif

@@ -1745,8 +1694,7 @@ png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 #else
 #ifdef PNG_FIXED_POINT_SUPPORTED
   sheight = (png_charp)png_malloc(png_ptr, png_strlen(ep) + 1);
-   if (sheight != (png_charp)NULL)
-      png_memcpy(sheight, ep, (png_size_t)png_strlen(ep));
+   png_memcpy(sheight, ep, (png_size_t)png_strlen(ep));
 #endif
 #endif

@@ -1855,14 +1803,7 @@ png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

   key = (png_charp)png_malloc(png_ptr, length + 1);
   slength = (png_size_t)length;
-   if (key == (png_charp)NULL)
-   {
-      png_warning (png_ptr, "Could not allocate memory for tEXt chunk");
-      png_crc_finish(png_ptr, slength);
-      return;
-   }
-   else
-      png_crc_read(png_ptr, (png_bytep)key, slength);
+   png_crc_read(png_ptr, (png_bytep)key, slength);

   if (png_crc_finish(png_ptr, skip))
   {
@@ -1879,8 +1820,6 @@ png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
      text++;

   text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text));
-   if (text_ptr != (png_textp)NULL)
-   {
   text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;
   text_ptr->key = key;
 #ifdef PNG_iTXt_SUPPORTED
@@ -1893,11 +1832,8 @@ png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)

   png_set_text(png_ptr, info_ptr, text_ptr, 1);

-   png_free(png_ptr, text_ptr);
-   }
-   else
-     png_warning(png_ptr, "Could not allocate iTXt pointer");
   png_free(png_ptr, key);
+   png_free(png_ptr, text_ptr);
 }
 #endif

@@ -1931,17 +1867,8 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 #endif

   chunkdata = (png_charp)png_malloc(png_ptr, length + 1);
-   if (chunkdata != (png_charp)NULL)
-   {
     slength = (png_size_t)length;
-     png_crc_read(png_ptr, (png_bytep)chunkdata, slength);
-   }
-   else
-   {
-     png_warning (png_ptr, "Could not allocate memory for zTXt chunk data");
-     png_crc_finish(png_ptr, length);
-     return;
-   }
+   png_crc_read(png_ptr, (png_bytep)chunkdata, slength);
   if (png_crc_finish(png_ptr, 0))
   {
      png_free(png_ptr, chunkdata);
@@ -1975,24 +1902,19 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
                                    (png_size_t)length, prefix_len, &data_len);

   text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text));
-   if (text_ptr != (png_textp)NULL)
-   {
-     text_ptr->compression = comp_type;
-     text_ptr->key = chunkdata;
+   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;
+   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;
+   text_ptr->text = chunkdata + prefix_len;
+   text_ptr->text_length = data_len;

-     png_set_text(png_ptr, info_ptr, text_ptr, 1);
+   png_set_text(png_ptr, info_ptr, text_ptr, 1);

-     png_free(png_ptr, text_ptr);
-   }
-   else
-      png_warning (png_ptr, "Could not allocate memory for zTXt data");
+   png_free(png_ptr, text_ptr);
   png_free(png_ptr, chunkdata);
 }
 #endif
@@ -2029,17 +1951,8 @@ png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 #endif

   chunkdata = (png_charp)png_malloc(png_ptr, length + 1);
-   if (chunkdata != (png_charp)NULL)
-   {
-     slength = (png_size_t)length;
-     png_crc_read(png_ptr, (png_bytep)chunkdata, slength);
-   }
-   else
-   {
-     png_warning (png_ptr, "Could not allocate memory for iTXt chunk data");
-     png_crc_finish(png_ptr, length);
-     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);
@@ -2084,22 +1997,17 @@ png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
   else
       data_len=png_strlen(chunkdata + prefix_len);
   text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text));
-   if (text_ptr != (png_textp)NULL)
-   {
-     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;
+   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;

-     png_set_text(png_ptr, info_ptr, text_ptr, 1);
+   png_set_text(png_ptr, info_ptr, text_ptr, 1);

-     png_free(png_ptr, text_ptr);
-   }
-   else
-     png_warning (png_ptr, "Could not allocate memory for iTXt chunk data");
+   png_free(png_ptr, text_ptr);
   png_free(png_ptr, chunkdata);
 }
 #endif
@@ -2133,7 +2041,7 @@ png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
      if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
           HANDLE_CHUNK_ALWAYS
 #if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
-           && png_ptr->read_user_chunk_fn == (png_user_chunk_ptr)NULL
+           && png_ptr->read_user_chunk_fn == NULL
 #endif
        )
 #endif
@@ -2155,19 +2063,10 @@ png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
 #endif
       png_strcpy((png_charp)chunk.name, (png_charp)png_ptr->chunk_name);
       chunk.data = (png_bytep)png_malloc(png_ptr, length);
-       if (chunk.data != (png_bytep)NULL)
-       {
-         chunk.size = (png_size_t)length;
-         png_crc_read(png_ptr, (png_bytep)chunk.data, length);
-       }
-       else
-       {
-         png_warning (png_ptr, "Could not allocate memory for iTXt chunk data");
-         png_crc_finish(png_ptr, length);
-         return;
-       }
+       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 != (png_user_chunk_ptr)NULL)
+       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)
@@ -2191,8 +2090,7 @@ png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 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 */ ;
+   info_ptr = info_ptr; /* quiet compiler warnings about unused info_ptr */
 #endif
 }

@@ -2653,9 +2551,7 @@ png_do_read_interlace(png_structp png_ptr)
         (png_uint_32)row_info->pixel_depth + 7) >> 3);
   }
 #if !defined(PNG_READ_PACKSWAP_SUPPORTED)
-   /* silence compiler warning */
-   if (transformations)
-      return;
+   transformations = transformations; /* silence compiler warning */
 #endif
 }
 #endif /* !PNG_HAVE_ASSEMBLER_READ_INTERLACE */
@@ -3072,9 +2968,9 @@ defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
      png_error(png_ptr, "This image requires a row greater than 64KB");
 #endif
   png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, row_bytes);
-   if (png_ptr->row_buf == (png_bytep)NULL)
-      png_error (png_ptr, "Could not allocate memory for row buffer");
+#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)
@@ -3082,11 +2978,6 @@ defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
 #endif
   png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)(
      png_ptr->rowbytes + 1));
-   if (png_ptr->prev_row == (png_bytep)NULL)
-   {
-      png_free (png_ptr, png_ptr->row_buf);
-      png_error (png_ptr, "Could not allocate memory for previous row buffer");
-   }

   png_memset_check(png_ptr, png_ptr->prev_row, 0, png_ptr->rowbytes + 1);

--- a/pngset.c
+++ b/pngset.c
@@ -1,7 +1,7 @@

 /* pngset.c - storage of image information into info struct
 *
- * libpng 1.0.11beta3 - April 15, 2001
+ * libpng 1.2.0beta3 - May 18, 2001
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2001 Glenn Randers-Pehrson
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -154,11 +154,6 @@ png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)
 #endif
   png_ptr->hist = (png_uint_16p)png_malloc(png_ptr,
      (png_uint_32)(info_ptr->num_palette * sizeof (png_uint_16)));
-   if (png_ptr->hist == (png_uint_16p)NULL)
-   {
-      png_warning (png_ptr, "Could not allocate memory for histogram");
-      return;
-   }

   for (i = 0; i < info_ptr->num_palette; i++)
       png_ptr->hist[i] = hist[i];
@@ -300,11 +295,6 @@ png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
   length = png_strlen(purpose) + 1;
   png_debug1(3, "allocating purpose for info (%lu bytes)\n", length);
   info_ptr->pcal_purpose = (png_charp)png_malloc(png_ptr, length);
-   if (info_ptr->pcal_purpose == (png_charp)NULL)
-   {
-      png_warning (png_ptr, "Could not allocate memory for pCAL");
-      return;
-   }
   png_memcpy(info_ptr->pcal_purpose, purpose, (png_size_t)length);

   png_debug(3, "storing X0, X1, type, and nparams in info\n");
@@ -316,23 +306,10 @@ png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
   length = png_strlen(units) + 1;
   png_debug1(3, "allocating units for info (%lu bytes)\n", length);
   info_ptr->pcal_units = (png_charp)png_malloc(png_ptr, length);
-   if (info_ptr->pcal_units == (png_charp)NULL)
-   {
-      png_free (png_ptr, info_ptr->pcal_purpose);
-      png_warning (png_ptr, "Could not allocate memory for pCAL units");
-      return;
-   }
   png_memcpy(info_ptr->pcal_units, units, (png_size_t)length);

   info_ptr->pcal_params = (png_charpp)png_malloc(png_ptr,
      (png_uint_32)((nparams + 1) * sizeof(png_charp)));
-   if (info_ptr->pcal_params == (png_charpp)NULL)
-   {
-      png_free (png_ptr, info_ptr->pcal_purpose);
-      png_free (png_ptr, info_ptr->pcal_units);
-      png_warning (png_ptr, "Could not allocate memory for pCAL params");
-      return;
-   }

   info_ptr->pcal_params[nparams] = NULL;

@@ -341,13 +318,7 @@ png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
      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(png_ptr, length);
-      if (info_ptr->pcal_params[i] == (png_charp)NULL)
-      {
-         nparams=i;
-         png_warning (png_ptr, "Could not allocate memory for pCAL params");
-      }
-      else
-         png_memcpy(info_ptr->pcal_params[i], params[i], (png_size_t)length);
+      png_memcpy(info_ptr->pcal_params[i], params[i], (png_size_t)length);
   }

   info_ptr->valid |= PNG_INFO_pCAL;
@@ -390,14 +361,12 @@ png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,
   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(png_ptr, length);
-   if (info_ptr->scal_s_width != (png_charp)NULL)
-      png_memcpy(info_ptr->scal_s_width, swidth, (png_size_t)length);
+   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(png_ptr, length);
-   if (info_ptr->scal_s_height != (png_charp)NULL)
-      png_memcpy(info_ptr->scal_s_height, sheight, (png_size_t)length);
+   png_memcpy(info_ptr->scal_s_height, sheight, (png_size_t)length);

   info_ptr->valid |= PNG_INFO_sCAL;
 #ifdef PNG_FREE_ME_SUPPORTED
@@ -443,11 +412,6 @@ png_set_PLTE(png_structp png_ptr, png_infop info_ptr,
 #endif
   png_ptr->palette = (png_colorp)png_zalloc(png_ptr, (uInt)num_palette,
      sizeof (png_color));
-   if (png_ptr->palette == (png_colorp)NULL)
-   {
-      png_warning(png_ptr, "Unable to allocate palette");
-      return;
-   }
   png_memcpy(png_ptr->palette, palette, num_palette * sizeof (png_color));
   info_ptr->palette = png_ptr->palette;
   info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;
@@ -572,19 +536,8 @@ png_set_iCCP(png_structp png_ptr, png_infop info_ptr,
      return;

   new_iccp_name = (png_charp)png_malloc(png_ptr, png_strlen(name)+1);
-   if (new_iccp_name == (png_charp)NULL) 
-   {
-     png_warning (png_ptr, "Could not allocate memory for ICC profile name");
-     return;
-   }
   png_strcpy(new_iccp_name, name);
   new_iccp_profile = (png_charp)png_malloc(png_ptr, proflen);
-   if (new_iccp_profile == (png_charp)NULL) 
-   {
-     png_warning (png_ptr, "Could not allocate memory for ICC profile");
-     png_free (png_ptr, new_iccp_name);
-     return;
-   }
   png_memcpy(new_iccp_profile, profile, (png_size_t)proflen);

   png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0);
@@ -630,12 +583,6 @@ png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
         old_text = info_ptr->text;
         info_ptr->text = (png_textp)png_malloc(png_ptr,
            (png_uint_32)(info_ptr->max_text * sizeof (png_text)));
-         if (info_ptr->text == (png_textp)NULL)
-         {
-            png_warning (png_ptr, "Could not allocate memory for text");
-            info_ptr->text = old_text;
-            return;
-         }
         png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max *
            sizeof(png_text)));
         png_free(png_ptr, old_text);
@@ -646,11 +593,6 @@ png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
         info_ptr->num_text = 0;
         info_ptr->text = (png_textp)png_malloc(png_ptr,
            (png_uint_32)(info_ptr->max_text * sizeof (png_text)));
-         if (info_ptr->text == (png_textp)NULL)
-         {
-            png_warning (png_ptr, "Could not allocate memory for text");
-            return;
-         }
 #ifdef PNG_FREE_ME_SUPPORTED
         info_ptr->free_me |= PNG_FREE_TEXT;
 #endif
@@ -664,7 +606,7 @@ png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
      png_size_t lang_len,lang_key_len;
      png_textp textp = &(info_ptr->text[info_ptr->num_text]);

-      if (text_ptr[i].key == (png_charp)NULL)
+      if (text_ptr[i].key == NULL)
          continue;

      key_len = png_strlen(text_ptr[i].key);
@@ -678,11 +620,11 @@ png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
 #ifdef PNG_iTXt_SUPPORTED
      {
        /* set iTXt data */
-        if (text_ptr[i].key != (png_charp)NULL)
+        if (text_ptr[i].key != NULL)
          lang_len = png_strlen(text_ptr[i].lang);
        else
          lang_len = 0;
-        if (text_ptr[i].lang_key != (png_charp)NULL)
+        if (text_ptr[i].lang_key != NULL)
          lang_key_len = png_strlen(text_ptr[i].lang_key);
        else
          lang_key_len = 0;
@@ -694,7 +636,7 @@ png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
      }
 #endif

-      if (text_ptr[i].text == (png_charp)NULL || text_ptr[i].text[0] == '\0')
+      if (text_ptr[i].text == NULL || text_ptr[i].text[0] == '\0')
      {
         text_length = 0;
 #ifdef PNG_iTXt_SUPPORTED
@@ -712,13 +654,9 @@ png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,

      textp->key = (png_charp)png_malloc(png_ptr,
         (png_uint_32)(key_len + text_length + lang_len + lang_key_len + 4));
-      if (textp->key == (png_charp)NULL)
-      {
-         png_warning (png_ptr, "Could not allocate memory for text pointer");
-         return;
-      }
-      png_debug2(2, "Allocated %d bytes at %x in png_set_text\n",
-         key_len + lang_len + lang_key_len + text_length + 4, (int)textp->key);
+      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));
@@ -804,11 +742,6 @@ png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
 #endif
       png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr,
           num_trans);
-       if (png_ptr->trans == (png_bytep)NULL)
-       {
-          png_warning (png_ptr, "Could not allocate memory for tRNS array");
-          return;
-       }
       png_memcpy(info_ptr->trans, trans, num_trans);
 #ifdef PNG_FREE_ME_SUPPORTED
       info_ptr->free_me |= PNG_FREE_TRNS;
@@ -839,11 +772,6 @@ png_set_sPLT(png_structp png_ptr,

    np = (png_sPLT_tp)png_malloc(png_ptr,
        (info_ptr->splt_palettes_num + nentries) * sizeof(png_sPLT_t));
-    if (np == (png_sPLT_tp)NULL)
-    {
-       png_warning (png_ptr, "Could not allocate memory for sPLT");
-       return;
-    }

    png_memcpy(np, info_ptr->splt_palettes,
           info_ptr->splt_palettes_num * sizeof(png_sPLT_t));
@@ -860,18 +788,10 @@ png_set_sPLT(png_structp png_ptr,
        png_strcpy(to->name, from->name);
        to->entries = (png_sPLT_entryp)png_malloc(png_ptr,
            from->nentries * sizeof(png_sPLT_t));
-        if (to->entries == (png_sPLT_entryp)NULL)
-        {
-           png_warning(png_ptr, "Could not allocate memory for sPLT entry");
-           nentries=i;
-        }
-        else
-        {
-          png_memcpy(to->entries, from->entries,
-               from->nentries * sizeof(png_sPLT_t));
-          to->nentries = from->nentries;
-          to->depth = from->depth;
-        }
+        png_memcpy(to->entries, from->entries,
+            from->nentries * sizeof(png_sPLT_t));
+        to->nentries = from->nentries;
+        to->depth = from->depth;
    }

    info_ptr->splt_palettes = np;
@@ -897,11 +817,6 @@ png_set_unknown_chunks(png_structp png_ptr,
    np = (png_unknown_chunkp)png_malloc(png_ptr,
        (info_ptr->unknown_chunks_num + num_unknowns) *
        sizeof(png_unknown_chunk));
-    if (np == (png_unknown_chunkp)NULL)
-    {
-       png_warning (png_ptr, "Could not allocate memory for unknown chunk");
-       return;
-    }

    png_memcpy(np, info_ptr->unknown_chunks,
           info_ptr->unknown_chunks_num * sizeof(png_unknown_chunk));
@@ -915,19 +830,11 @@ png_set_unknown_chunks(png_structp png_ptr,

        png_strcpy((png_charp)to->name, (png_charp)from->name);
        to->data = (png_bytep)png_malloc(png_ptr, from->size);
-        if (to->data == (png_bytep)NULL)
-        {
-           png_warning(png_ptr, "Could not allocate memory for unknown entry");
-           num_unknowns=i;
-        }
-        else
-        {
-          png_memcpy(to->data, from->data, from->size);
-          to->size = from->size;
+        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);
-        }
+        /* note our location in the read or write sequence */
+        to->location = (png_byte)(png_ptr->mode & 0xff);
    }

    info_ptr->unknown_chunks = np;
@@ -999,7 +906,7 @@ png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep
      return;
    old_num_chunks=png_ptr->num_chunk_list;
    new_list=(png_bytep)png_malloc(png_ptr,5*(num_chunks+old_num_chunks));
-    if(png_ptr->chunk_list != (png_bytep)NULL)
+    if(png_ptr->chunk_list != NULL)
    {
       png_memcpy(new_list, png_ptr->chunk_list, 5*old_num_chunks);
       png_free(png_ptr, png_ptr->chunk_list);
@@ -1051,8 +958,6 @@ png_set_compression_buffer_size(png_structp png_ptr, png_uint_32 size)
       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);
-    if(!png_ptr->zbuf)
-       png_error(png_ptr,"Unable to malloc zbuf");
    png_ptr->zstream.next_out = png_ptr->zbuf;
    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
 }
@@ -1064,3 +969,58 @@ png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask)
      info_ptr->valid &= ~(mask);
 }

+
+#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 */
--- a/pngtest.c
+++ b/pngtest.c
@@ -1,7 +1,7 @@

 /* pngtest.c - a simple test program to test libpng
 *
- * libpng 1.0.11beta3 - April 15, 2001
+ * libpng 1.2.0beta3 - May 18, 2001
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2001 Glenn Randers-Pehrson
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -710,14 +710,14 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
 #  endif
 #else
   png_set_read_fn(read_ptr, (png_voidp)fpin, pngtest_read_data);
-#ifdef PNG_WRITE_SUPPORTED
+#  ifdef PNG_WRITE_SUPPORTED
   png_set_write_fn(write_ptr, (png_voidp)fpout,  pngtest_write_data,
-#if defined(PNG_WRITE_FLUSH_SUPPORTED)
+#    if defined(PNG_WRITE_FLUSH_SUPPORTED)
      pngtest_flush);
-#else
-#endif
+#    else
      NULL);
-#endif
+#    endif
+#  endif
 #endif
   if(status_dots_requested == 1)
   {
@@ -1028,18 +1028,6 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname)
   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);
-   if (row_buf == NULL)
-   {
-      fprintf(STDERR, "No memory to allocate row buffer\n");
-      png_destroy_read_struct(&read_ptr, &read_info_ptr, (png_infopp)NULL);
-#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);
-   }
 #endif /* SINGLE_ROWBUF_ALLOC */
   png_debug(0, "Writing row data\n");

@@ -1523,4 +1511,4 @@ main(int argc, char *argv[])
 }

 /* Generate a compiler error if there is an old png.h in the search path. */
-typedef version_1_0_11beta3 your_png_h_is_not_version_1_0_11beta3;
+typedef version_1_2_0beta3 your_png_h_is_not_version_1_2_0beta3;
--- a/pngtrans.c
+++ b/pngtrans.c
@@ -1,7 +1,7 @@

 /* pngtrans.c - transforms the data in a row (used by both readers and writers)
 *
- * libpng 1.0.11beta3 - April 15, 2001
+ * libpng 1.2.0beta3 - May 18, 2001
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2001 Glenn Randers-Pehrson
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
--- a/pngvcrd.c
+++ b/pngvcrd.c
@@ -2,14 +2,14 @@
 *
 * For Intel x86 CPU and Microsoft Visual C++ compiler
 *
- * libpng 1.0.11beta3 - April 15, 2001
+ * libpng 1.2.0beta3 - May 18, 2001
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2001 Glenn Randers-Pehrson
 * Copyright (c) 1998, Intel Corporation
 *
 * Contributed by Nirav Chhatrapati, Intel Corporation, 1998
 * Interface to libpng contributed by Gilles Vollant, 1999
- * Debugging and cleanup by Greg Roelofs, 2000, 2001
+ *
 *
 * 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
@@ -19,6 +19,8 @@
 *
 * [png_read_filter_row_mmx_avg() bpp == 2 bugfix, GRR 20000916]
 *
+ * [runtime MMX configuration, GRR 20010102]
+ *
 */

 #define PNG_INTERNAL
@@ -110,6 +112,8 @@ png_combine_row(png_structp png_ptr, png_bytep row, int mask)
   png_debug(1,"in png_combine_row_asm\n");

   if (mmx_supported == 2) {
+       /* this should have happened in png_init_mmx_flags() already */
+       png_warning(png_ptr, "asm_flags may not have been initialized");
       png_mmx_support();
   }

@@ -300,7 +304,8 @@ png_combine_row(png_structp png_ptr, png_bytep row, int mask)

            __int64 mask0=0x0102040810204080;

-            if ( mmx_supported )
+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
+                /* && mmx_supported */ )
            {
               srcptr = png_ptr->row_buf + 1;
               dstptr = row;
@@ -382,8 +387,6 @@ end8:
               incr1 = (disp)*pixel_bytes;
               for (i = initial_val; i < final_val; i += incr1)
               {
-                  if (pixel_bytes > (png_size_t)(final_val-i))
-                    pixel_bytes = (png_size_t)(final_val-i);
                  png_memcpy(dstptr, srcptr, pixel_bytes);
                  srcptr += incr1;
                  dstptr += incr1;
@@ -402,7 +405,8 @@ end8:
            __int64 mask1=0x0101020204040808,
                    mask0=0x1010202040408080;

-            if ( mmx_supported )
+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
+                /* && mmx_supported */ )
            {
               srcptr = png_ptr->row_buf + 1;
               dstptr = row;
@@ -495,8 +499,6 @@ end16:
               incr1 = (disp)*pixel_bytes;
               for (i = initial_val; i < final_val; i += incr1)
               {
-                  if (pixel_bytes > (png_size_t)(final_val-i))
-                    pixel_bytes = (png_size_t)(final_val-i);
                  png_memcpy(dstptr, srcptr, pixel_bytes);
                  srcptr += incr1;
                  dstptr += incr1;
@@ -524,7 +526,8 @@ end16:
            len     = (png_ptr->width)&~7;
            diff = (png_ptr->width)&7;

-            if ( mmx_supported )
+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
+                /* && mmx_supported */ )
            {
               _asm
               {
@@ -627,8 +630,6 @@ end24:
               incr1 = (disp)*pixel_bytes;
               for (i = initial_val; i < final_val; i += incr1)
               {
-                  if (pixel_bytes > (png_size_t)(final_val-i))
-                    pixel_bytes = (png_size_t)(final_val-i);
                  png_memcpy(dstptr, srcptr, pixel_bytes);
                  srcptr += incr1;
                  dstptr += incr1;
@@ -657,7 +658,8 @@ end24:
            len     = (png_ptr->width)&~7;
            diff = (png_ptr->width)&7;

-            if ( mmx_supported )
+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
+                /* && mmx_supported */ )
            {
               _asm
               {
@@ -768,8 +770,6 @@ end32:
               incr1 = (disp)*pixel_bytes;
               for (i = initial_val; i < final_val; i += incr1)
               {
-                  if (pixel_bytes > (png_size_t)(final_val-i))
-                    pixel_bytes = (png_size_t)(final_val-i);
                  png_memcpy(dstptr, srcptr, pixel_bytes);
                  srcptr += incr1;
                  dstptr += incr1;
@@ -793,7 +793,8 @@ end32:
                    mask1=0x2020202040404040,
                    mask0=0x4040808080808080;

-            if ( mmx_supported )
+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
+                /* && mmx_supported */ )
            {
               srcptr = png_ptr->row_buf + 1;
               dstptr = row;
@@ -927,8 +928,6 @@ end48:
               incr1 = (disp)*pixel_bytes;
               for (i = initial_val; i < final_val; i += incr1)
               {
-                  if (pixel_bytes > (png_size_t)(final_val-i))
-                    pixel_bytes = (png_size_t)(final_val-i);
                  png_memcpy(dstptr, srcptr, pixel_bytes);
                  srcptr += incr1;
                  dstptr += incr1;
@@ -957,8 +956,6 @@ end48:
            incr1 = (disp)*pixel_bytes;
            for (i = initial_val; i < final_val; i += incr1)
            {
-               if (pixel_bytes > (png_size_t)(final_val-i))
-                 pixel_bytes = (png_size_t)(final_val-i);
               png_memcpy(dp, sptr, pixel_bytes);
               sptr += incr1;
               dp += incr1;
@@ -987,6 +984,8 @@ png_do_read_interlace(png_structp png_ptr)
   png_debug(1,"in png_do_read_interlace\n");

   if (mmx_supported == 2) {
+       /* this should have happened in png_init_mmx_flags() already */
+       png_warning(png_ptr, "asm_flags may not have been initialized");
       png_mmx_support();
   }

@@ -1187,7 +1186,8 @@ png_do_read_interlace(png_structp png_ptr)
            // NOTE:  there is NO MMX code for 48-bit and 64-bit images

            // use MMX routine if machine supports it
-            if ( mmx_supported )
+            if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_INTERLACE)
+                /* && mmx_supported */ )
            {
               if (pixel_bytes == 3)
               {
@@ -1777,7 +1777,7 @@ loop4_pass4:
            } /* end of mmx_supported */

            else /* MMX not supported:  use modified C code - takes advantage
-                  * of inlining of png_memcpy for a constant */
+                  * of inlining of memcpy for a constant */
            {
               if (pixel_bytes == 1)
               {
@@ -3649,6 +3649,8 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep
 #endif

   if (mmx_supported == 2) {
+       /* this should have happened in png_init_mmx_flags() already */
+       png_warning(png_ptr, "asm_flags may not have been initialized");
       png_mmx_support();
   }

@@ -3658,13 +3660,17 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep
   {
      case 0: sprintf(filnm, "none");
         break;
-      case 1: sprintf(filnm, "sub-%s", "MMX");
+      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", "MMX");
+      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", "MMX");
+      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", "MMX");
+      case 4: sprintf(filnm, "Paeth-%s",
+        (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)? "MMX":"x86");
         break;
      default: sprintf(filnm, "unknw");
         break;
@@ -3682,9 +3688,9 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep

      case PNG_FILTER_VALUE_SUB:
      {
-         if (
-             (row_info->pixel_depth >= PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT) &&
-             (row_info->rowbytes >= PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT))
+         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))
         {
            png_read_filter_row_mmx_sub(row_info, row);
         }
@@ -3707,9 +3713,9 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep

      case PNG_FILTER_VALUE_UP:
      {
-         if (
-             (row_info->pixel_depth >= PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT) &&
-             (row_info->rowbytes >= PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT))
+         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))
         {
            png_read_filter_row_mmx_up(row_info, row, prev_row);
         }
@@ -3731,9 +3737,9 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep

      case PNG_FILTER_VALUE_AVG:
      {
-         if (
-             (row_info->pixel_depth >= PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT) &&
-             (row_info->rowbytes >= PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT))
+         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))
         {
            png_read_filter_row_mmx_avg(row_info, row, prev_row);
         }
@@ -3765,9 +3771,9 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep

      case PNG_FILTER_VALUE_PAETH:
      {
-         if (
-             (row_info->pixel_depth >= PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT) &&
-             (row_info->rowbytes >= PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT))
+         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))
         {
            png_read_filter_row_mmx_paeth(row_info, row, prev_row);
         }
--- a/pngwio.c
+++ b/pngwio.c
@@ -1,7 +1,7 @@

 /* pngwio.c - functions for data output
 *
- * libpng 1.0.11beta3 - April 15, 2001
+ * libpng 1.2.0beta3 - May 18, 2001
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2001 Glenn Randers-Pehrson
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
--- a/pngwrite.c
+++ b/pngwrite.c
@@ -1,7 +1,7 @@

 /* pngwrite.c - general routines to write a PNG file
 *
- * libpng 1.0.11beta3 - April 15, 2001
+ * libpng 1.2.0beta3 - May 18, 2001
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2001 Glenn Randers-Pehrson
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -444,7 +444,7 @@ png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
   png_debug(1, "in png_create_write_struct\n");
 #ifdef PNG_USER_MEM_SUPPORTED
   if ((png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
-      (png_malloc_ptr)malloc_fn)) == NULL)
+      (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr)) == NULL)
 #else
   if ((png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG)) == NULL)
 #endif /* PNG_USER_MEM_SUPPORTED */
@@ -452,6 +452,10 @@ png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
      return ((png_structp)NULL);
   }

+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
+   png_init_mmx_flags(png_ptr);   /* 1.2.0 addition */
+#endif
+
 #ifdef PNG_SETJMP_SUPPORTED
 #ifdef USE_FAR_KEYWORD
   if (setjmp(jmpbuf))
@@ -489,6 +493,7 @@ png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
      * 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'))
     {
        png_error(png_ptr,
@@ -496,15 +501,17 @@ png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
     }

     /* Libpng 1.0.6 was not binary compatible, due to insertion of the
-        info_ptr->free_me member.  Note to maintainer: this test can be
-        removed from version 2.0.0 and beyond because the previous test
-        would have already rejected it. */
+        info_ptr->free_me member.  Libpng-1.0.1 and earlier were not
+        compatible due to insertion of the user transform function. Note
+        to maintainer: this test can be removed from version 1.2.0 and
+        beyond because the previous test would have already rejected it. */

-     if (user_png_ver[4] == '6' && user_png_ver[2] == '0' &&
-         user_png_ver[0] == '1' && user_png_ver[5] == '\0')
+     if (user_png_ver[0] == '1' && user_png_ver[2] == '0' &&
+         (user_png_ver[4] <  '2' || user_png_ver[4] == '6') &&
+         user_png_ver[5] == '\0')
     {
        png_error(png_ptr,
-           "Application must be recompiled; version 1.0.6 was incompatible");
+        "Application must be recompiled; versions <= 1.0.6 were incompatible");
     }
   }

@@ -512,8 +519,6 @@ png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
   png_ptr->zbuf_size = PNG_ZBUF_SIZE;
   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
      (png_uint_32)png_ptr->zbuf_size);
-   if (png_ptr->zbuf == (png_bytep)NULL)
-      png_error(png_ptr, "Could not allocate zbuf for writing");

   png_set_write_fn(png_ptr, NULL, NULL, NULL);

@@ -531,13 +536,36 @@ 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.0", 10000, 10000);
+   png_write_init_2(png_ptr, "1.0.0", 0, 0);
 }

+#undef png_write_init_2
 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(sizeof(png_struct) > png_struct_size)
+     {
+       png_ptr->error_fn=(png_error_ptr)NULL;
+       png_error(png_ptr,
+         "The png struct allocated by the application is too small.");
+     }
+   if(sizeof(png_info) > png_info_size)
+     {
+       png_ptr->error_fn=(png_error_ptr)NULL;
+       png_error(png_ptr,
+         "The info struct allocated by the application 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
@@ -549,43 +577,46 @@ png_write_init_2(png_structp png_ptr, png_const_charp user_png_ver,
 #ifdef PNG_LEGACY_SUPPORTED
       png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
 #else
-       png_ptr->error_fn=(png_error_ptr)NULL;
-       png_error(png_ptr,
-       "Application uses deprecated png_write_init() and must be recompiled.");
+       png_ptr->warning_fn=(png_error_ptr)NULL;
+       png_warning(png_ptr,
+     "Application uses deprecated png_write_init() and should be recompiled.");
+       break;
 #endif
     }
   } while (png_libpng_ver[i++]);

-   if (sizeof(png_struct) > png_struct_size ||
-      sizeof(png_info) > png_info_size)
-     {
-       png_ptr->error_fn=(png_error_ptr)NULL;
-       png_error(png_ptr,
-      "Application and library have different sized structs. Please recompile.");
-     }
-
-   png_debug(1, "in png_write_init_2\n");
+   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, sizeof (jmp_buf));
 #endif

+   if (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, sizeof (png_struct));

+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
+   png_init_mmx_flags(png_ptr);   /* 1.2.0 addition */
+#endif
+
 #ifdef PNG_SETJMP_SUPPORTED
   /* restore jump buffer */
   png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
 #endif

+   png_set_write_fn(png_ptr, NULL, NULL, 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 (png_ptr->zbuf == (png_bytep)NULL)
-      png_error(png_ptr, "Could not allocate zbuf for writing");
-   png_set_write_fn(png_ptr, NULL, NULL, NULL);

 #if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
   png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,
@@ -880,6 +911,7 @@ png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
   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");
@@ -908,7 +940,8 @@ png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
 #endif

 #ifdef PNG_USER_MEM_SUPPORTED
-      png_destroy_struct_2((png_voidp)info_ptr, free_fn);
+      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
@@ -919,7 +952,8 @@ png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
   {
      png_write_destroy(png_ptr);
 #ifdef PNG_USER_MEM_SUPPORTED
-      png_destroy_struct_2((png_voidp)png_ptr, free_fn);
+      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
@@ -1033,8 +1067,6 @@ png_set_filter(png_structp png_ptr, int method, int filters)
         {
            png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,
              (png_ptr->rowbytes + 1));
-           if (png_ptr->sub_row == (png_bytep)NULL)
-              png_error(png_ptr, "Could not allocate sub_row");
            png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
         }

@@ -1049,10 +1081,6 @@ png_set_filter(png_structp png_ptr, int method, int filters)
            {
               png_ptr->up_row = (png_bytep)png_malloc(png_ptr,
                  (png_ptr->rowbytes + 1));
-               if (png_ptr->up_row == (png_bytep)NULL)
-               {
-                 png_error(png_ptr, "Could not allocate sub_row");
-               }
               png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
            }
         }
@@ -1068,8 +1096,6 @@ png_set_filter(png_structp png_ptr, int method, int filters)
            {
               png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
                  (png_ptr->rowbytes + 1));
-               if (png_ptr->avg_row == (png_bytep)NULL)
-                  png_error(png_ptr, "Could not allocate avg_row");
               png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
            }
         }
@@ -1086,8 +1112,6 @@ png_set_filter(png_structp png_ptr, int method, int filters)
            {
               png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,
                  (png_ptr->rowbytes + 1));
-               if (png_ptr->paeth_row == (png_bytep)NULL)
-                 png_error(png_ptr, "Could not allocate avg_row");
               png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
            }
         }
@@ -1143,13 +1167,10 @@ png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,
         png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr,
            (png_uint_32)(sizeof(png_byte) * num_weights));

-         if (png_ptr->prev_filters != (png_bytep)NULL)
+         /* To make sure that the weighting starts out fairly */
+         for (i = 0; i < num_weights; i++)
         {
-           /* To make sure that the weighting starts out fairly */
-           for (i = 0; i < num_weights; i++)
-           {
-              png_ptr->prev_filters[i] = 255;
-           }
+            png_ptr->prev_filters[i] = 255;
         }
      }

@@ -1160,22 +1181,11 @@ png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,

         png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr,
            (png_uint_32)(sizeof(png_uint_16) * num_weights));
-         if (png_ptr->inv_filter_weights == (png_uint_16p)NULL)
+         for (i = 0; i < num_weights; i++)
         {
-            png_free(png_ptr, png_ptr->filter_weights);
-            png_ptr->filter_weights = NULL;
+            png_ptr->inv_filter_weights[i] =
+            png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;
         }
-         if (png_ptr->filter_weights != (png_uint_16p)NULL &&
-             png_ptr->inv_filter_weights != (png_uint_16p)NULL)
-         {
-           for (i = 0; i < num_weights; i++)
-           {
-              png_ptr->inv_filter_weights[i] =
-              png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;
-           }
-         }
-         else
-            num_weights=0;
      }

      for (i = 0; i < num_weights; i++)
@@ -1387,7 +1397,7 @@ png_write_png(png_structp png_ptr, png_infop info_ptr,
   /* 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 == (voidp)NULL)
+   if(transforms == 0 || params == NULL)
      /* quiet compiler warnings */ return;
 }
 #endif
--- a/pngwtran.c
+++ b/pngwtran.c
@@ -1,7 +1,7 @@

 /* pngwtran.c - transforms the data in a row for PNG writers
 *
- * libpng 1.0.11beta3 - April 15, 2001
+ * libpng 1.2.0beta3 - May 18, 2001
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2001 Glenn Randers-Pehrson
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
--- a/pngwutil.c
+++ b/pngwutil.c
@@ -1,7 +1,7 @@

 /* pngwutil.c - utilities to write a PNG file
 *
- * libpng 1.0.11beta3 - April 15, 2001
+ * libpng 1.2.0beta3 - May 18, 2001
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998-2001 Glenn Randers-Pehrson
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -235,11 +235,6 @@ png_text_compress(png_structp png_ptr,
               old_ptr = comp->output_ptr;
               comp->output_ptr = (png_charpp)png_malloc(png_ptr,
                  (png_uint_32)(comp->max_output_ptr * sizeof (png_charpp)));
-               if (comp->output_ptr == (png_charpp)NULL)
-               {
-                  png_warning (png_ptr, "Cannot allocate compression buffer");
-                  comp->output_ptr=old_ptr;
-               }
               png_memcpy(comp->output_ptr, old_ptr, old_max
                  * sizeof (png_charp));
               png_free(png_ptr, old_ptr);
@@ -247,23 +242,14 @@ png_text_compress(png_structp png_ptr,
            else
               comp->output_ptr = (png_charpp)png_malloc(png_ptr,
                  (png_uint_32)(comp->max_output_ptr * sizeof (png_charp)));
-               if (comp->output_ptr == (png_charpp)NULL)
-               {
-                  png_warning (png_ptr, "Cannot allocate compression buffer");
-               }
         }

         /* save the data */
         comp->output_ptr[comp->num_output_ptr] = (png_charp)png_malloc(png_ptr,
            (png_uint_32)png_ptr->zbuf_size);
-         if (comp->output_ptr[comp->num_output_ptr] == (png_charp)NULL)
-            png_warning (png_ptr, "Cannot allocate compression buffer");
-         else
-         {
-            png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,
-               png_ptr->zbuf_size);
-            comp->num_output_ptr++;
-         }
+         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;
@@ -298,9 +284,8 @@ png_text_compress(png_structp png_ptr,
                  /* This could be optimized to realloc() */
                  comp->output_ptr = (png_charpp)png_malloc(png_ptr,
                     (png_uint_32)(comp->max_output_ptr * sizeof (png_charpp)));
-                  if (comp->output_ptr != (png_charpp)NULL)
-                    png_memcpy(comp->output_ptr, old_ptr,
-                       old_max * sizeof (png_charp));
+                  png_memcpy(comp->output_ptr, old_ptr,
+                     old_max * sizeof (png_charp));
                  png_free(png_ptr, old_ptr);
               }
               else
@@ -311,14 +296,9 @@ png_text_compress(png_structp png_ptr,
            /* save off the data */
            comp->output_ptr[comp->num_output_ptr] =
               (png_charp)png_malloc(png_ptr, (png_uint_32)png_ptr->zbuf_size);
-            if (comp->output_ptr[comp->num_output_ptr] == (png_charp)NULL)
-               png_warning (png_ptr, "Cannot allocate compression buffer");
-            else
-            {
-               png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,
-                  png_ptr->zbuf_size);
-               comp->num_output_ptr++;
-            }
+            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;
@@ -455,7 +435,7 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
 #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 ||
       color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
      (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&
 #endif
@@ -480,7 +460,9 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
   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->width = width;
   png_ptr->height = height;

@@ -555,21 +537,27 @@ png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)

   png_debug(1, "in png_write_PLTE\n");
   if ((
-#if defined(PNG_MNG_FEATURES_SUPPORTED) || \
-    defined (PNG_WRITE_EMPTY_PLTE_SUPPORTED)
+#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)
     {
-       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;
-         }
+        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;
@@ -1039,8 +1027,7 @@ png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)
   if (color_type == PNG_COLOR_TYPE_PALETTE)
   {
      if (
-#if defined(PNG_MNG_FEATURES_SUPPORTED) || \
-    defined (PNG_WRITE_EMPTY_PLTE_SUPPORTED)
+#if defined(PNG_MNG_FEATURES_SUPPORTED)
          (png_ptr->num_palette ||
          (!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) &&
 #endif
@@ -1129,12 +1116,6 @@ png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)
   png_debug1(2, "Keyword to be checked is '%s'\n", key);

   *new_key = (png_charp)png_malloc(png_ptr, (png_uint_32)(key_len + 2));
- 
-   if (*new_key == (png_charp)NULL)
-   {
-      png_warning(png_ptr, "Could not allocate new key; keyword not checked");
-      return key_len;
-   }

   /* Replace non-printing characters with a blank and print a warning */
   for (kp = key, dp = *new_key; *kp != '\0'; kp++, dp++)
@@ -1443,20 +1424,14 @@ png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
      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", purpose_len);
+   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", units_len);
+   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
      *sizeof(png_uint_32)));

-   if (params_len == (png_uint_32p)NULL)
-   {
-      png_warning (png_ptr, "Could not allocate params for pCAL");
-      return;
-   }
-
   /* 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++)
@@ -1466,7 +1441,7 @@ png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
      total_len += (png_size_t)params_len[i];
   }

-   png_debug1(3, "pCAL total length = %d\n", total_len);
+   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);
@@ -1518,7 +1493,7 @@ png_write_sCAL(png_structp png_ptr, int unit, double width,double height)
 #endif
   total_len = 1 + png_strlen(wbuf)+1 + png_strlen(hbuf);

-   png_debug1(3, "sCAL total length = %d\n", total_len);
+   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)&unit, 1);
   png_write_chunk_data(png_ptr, (png_bytep)wbuf, png_strlen(wbuf)+1);
@@ -1640,8 +1615,6 @@ png_write_start_row(png_structp png_ptr)

   /* set up row buffer */
   png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size);
-   if (png_ptr->row_buf == (png_bytep)NULL)
-      png_error(png_ptr, "Could not allocate row buffer");
   png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;

   /* set up filtering buffer, if using this filter */
@@ -1649,8 +1622,6 @@ png_write_start_row(png_structp png_ptr)
   {
      png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,
         (png_ptr->rowbytes + 1));
-      if (png_ptr->sub_row == (png_bytep)NULL)
-         png_error(png_ptr, "Could not allocate sub row buffer");
      png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
   }

@@ -1665,8 +1636,6 @@ png_write_start_row(png_structp png_ptr)
      {
         png_ptr->up_row = (png_bytep )png_malloc(png_ptr,
            (png_ptr->rowbytes + 1));
-         if (png_ptr->up_row == (png_bytep)NULL)
-            png_error(png_ptr, "Could not allocate up row buffer");
         png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
      }

@@ -1674,8 +1643,6 @@ png_write_start_row(png_structp png_ptr)
      {
         png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
            (png_ptr->rowbytes + 1));
-         if (png_ptr->avg_row == (png_bytep)NULL)
-            png_error(png_ptr, "Could not allocate avg row buffer");
         png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
      }

@@ -1683,8 +1650,6 @@ png_write_start_row(png_structp png_ptr)
      {
         png_ptr->paeth_row = (png_bytep )png_malloc(png_ptr,
            (png_ptr->rowbytes + 1));
-         if (png_ptr->paeth_row == (png_bytep)NULL)
-            png_error(png_ptr, "Could not allocate paeth row buffer");
         png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
      }
   }
--- a/projects/msvc/README.txt
+++ b/projects/msvc/README.txt
@@ -1,5 +1,5 @@
 Microsoft Developer Studio Build File, Format Version 6.00 for
-libpng 1.0.11beta3 (April 15, 2001) and zlib
+libpng 1.2.0beta3 (May 18, 2001) and zlib

 Copyright (C) 2000 Simon-Pierre Cadieux
 For conditions of distribution and use, see copyright notice in png.h
@@ -24,12 +24,12 @@ To build:
 This project will build the PNG Development Group's "official" versions of
 libpng and zlib libraries:

-   libpng1.dll          (default version, currently C code only)
-   libpng1.dll         (C + Assembler version)
-   libpng1.dll         (C + Assembler debug version)
-   libpng1.dll         (C code debug version)
-   libpng1[c,e-m].dll   (reserved for official versions) 
-   libpng1[n-z].dll     (available for private versions)
+   libpng3.dll          (default version, currently C code only)
+   libpng3.dll         (C + Assembler version)
+   libpng3.dll         (C + Assembler debug version)
+   libpng3.dll         (C code debug version)
+   libpng3[c,e-m].dll   (reserved for official versions) 
+   libpng3[n-z].dll     (available for private versions)
   zlib.dll             (default version, currently C code only)
   zlibd.dll            (debug version)

--- a/projects/msvc/libpng.dsp
+++ b/projects/msvc/libpng.dsp
@@ -56,7 +56,7 @@ BSC32=bscmake.exe
 # ADD BSC32 /nologo
 LINK32=link.exe
 # ADD BASE LINK32 /nologo /dll /machine:I386
-# ADD LINK32 /nologo /dll /machine:I386 /out:".\win32\libpng\dll\libpng1.dll"
+# ADD LINK32 /nologo /dll /machine:I386 /out:".\win32\libpng\dll\libpng3.dll"
 # SUBTRACT LINK32 /pdb:none

 !ELSEIF  "$(CFG)" == "libpng - Win32 DLL Debug"
@@ -84,7 +84,7 @@ BSC32=bscmake.exe
 # ADD BSC32 /nologo
 LINK32=link.exe
 # ADD BASE LINK32 /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 /nologo /dll /debug /machine:I386 /out:".\win32\libpng\dll_dbg\libpng1d.dll"
+# ADD LINK32 /nologo /dll /debug /machine:I386 /out:".\win32\libpng\dll_dbg\libpng3d.dll"

 !ELSEIF  "$(CFG)" == "libpng - Win32 DLL ASM"

@@ -111,7 +111,7 @@ BSC32=bscmake.exe
 # ADD BSC32 /nologo
 LINK32=link.exe
 # ADD BASE LINK32 /nologo /dll /machine:I386
-# ADD LINK32 /nologo /dll /machine:I386 /out:".\win32\libpng\dll_asm\libpng1a.dll"
+# ADD LINK32 /nologo /dll /machine:I386 /out:".\win32\libpng\dll_asm\libpng3a.dll"
 # SUBTRACT LINK32 /pdb:none

 !ELSEIF  "$(CFG)" == "libpng - Win32 DLL Debug ASM"
@@ -139,7 +139,7 @@ BSC32=bscmake.exe
 # ADD BSC32 /nologo
 LINK32=link.exe
 # ADD BASE LINK32 /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 /nologo /dll /debug /machine:I386 /out:".\win32\libpng\dll_dbga\libpng1b.dll"
+# ADD LINK32 /nologo /dll /debug /machine:I386 /out:".\win32\libpng\dll_dbga\libpng3b.dll"

 !ELSEIF  "$(CFG)" == "libpng - Win32 LIB"

--- a/projects/msvc/png32ms.def
+++ b/projects/msvc/png32ms.def
@@ -6,7 +6,7 @@ LIBRARY
 DESCRIPTION "PNG image compression library for Windows"

 EXPORTS
-;Version 1.0.11beta3
+;Version 1.2.0beta3
  png_build_grayscale_palette  @1
  png_check_sig        @2
  png_chunk_error      @3
@@ -77,13 +77,15 @@ EXPORTS
  png_malloc    @68
  png_memcpy_check    @69
  png_memset_check    @70
+; png_permit_empty_plte is deprecated
  png_permit_empty_plte  @71
  png_process_data    @72
  png_progressive_combine_row  @73
  png_read_end    @74
  png_read_image    @75
  png_read_info    @76
-  png_read_init    @77 ; deprecated
+; png_read_init is deprecated
+  png_read_init    @77
  png_read_png    @78
  png_read_row    @79
  png_read_rows    @80
@@ -168,10 +170,12 @@ EXPORTS
  png_write_image    @159
  png_write_info    @160
  png_write_info_before_PLTE  @161
-  png_write_init    @162 ; deprecated
+; png_write_init is deprecated
+  png_write_init    @162
  png_write_png    @163
  png_write_row    @164
  png_write_rows    @165
+; png_read_init_2 and png_write_init_2 are deprecated.
  png_read_init_2    @166
  png_write_init_2    @167
  png_access_version_number  @168
@@ -180,7 +184,30 @@ EXPORTS
  png_init_io    @171
  png_convert_to_rfc1123     @172
  png_set_invalid  @173
-;To be added at version 1.2.0
-; png_permit_mng_features  @174
-;To be added at version 1.2.0
-; png_mmx_support  @175
+; Added at version 1.0.12
+; For compatiblity with 1.0.7-1.0.11
+  png_info_init @174
+  png_read_init_3    @175
+  png_write_init_3    @176
+  png_info_init_3 @177
+  png_destroy_struct  @178
+; Added at version 1.2.0
+; For use with PNG_USER_MEM_SUPPORTED
+  png_destroy_struct_2  @179
+  png_create_read_struct_2 @180
+  png_create_write_struct_2 @181
+  png_malloc_default @182
+  png_free_default @183
+; MNG features
+  png_permit_mng_features  @184
+; MMX support
+  png_mmx_support  @185
+  png_get_mmx_flagmask  @186
+  png_get_asm_flagmask  @187
+  png_get_asm_flags  @188
+  png_get_mmx_bitdepth_threshold  @189
+  png_get_mmx_rowbytes_threshold  @190
+  png_set_asm_flags  @191
+  png_init_mmx_flags  @192
+; Strip error numbers
+  png_set_strip_error_numbers @193
--- a/projects/wince/READMEE.WCE
+++ b/projects/wince/READMEE.WCE
@@ -8,9 +8,9 @@ libpng for WindowsCE Rel.1.0

 Introduction
 ============
-This is libpng 1.0.11beta3 ported to WindowsCE 2.0 and 2.11.
-libpng 1.0.11beta3 is a PNG reference library.
-See README, a document of original libpng 1.0.11beta3.
+This is libpng 1.2.0beta3 ported to WindowsCE 2.0 and 2.11.
+libpng 1.2.0beta3 is a PNG reference library.
+See README, a document of original libpng 1.2.0beta3.

 zlib for WindowsCE
 ==================
@@ -23,7 +23,7 @@ This software is provided 'as-is', without any express or implied
 warranty.  In no event will the authors be held liable for any damages
 arising from the use of this software.

-See README and LICENSE, documents of original libpng 1.0.11beta3, for conditions
+See README and LICENSE, documents of original libpng 1.2.0beta3, for conditions
 of use and distribution.

 Files
--- a/projects/wince/READMEJ.WCE
+++ b/projects/wince/READMEJ.WCE
@@ -24,7 +24,7 @@ libpng
 <EFBFBD>ɂȂ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ȃ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Q<EFBFBD>ɂ<EFBFBD><EFBFBD>Ă<EFBFBD><EFBFBD>A<EFBFBD><EFBFBD><EFBFBD>ҁA<EFBFBD>z<EFBFBD>z<EFBFBD>ҁA<EFBFBD><EFBFBD><EFBFBD>̑<EFBFBD><EFBFBD><EFBFBD><EFBFBD>p<EFBFBD>҈ȊO<EFBFBD>̐l<EFBFBD><EFBFBD><EFBFBD>A
 <EFBFBD>c<EFBFBD>̂ɐӔC<EFBFBD><EFBFBD><EFBFBD>Ƃ<EFBFBD><EFBFBD>`<60><><EFBFBD>͂Ȃ<CD82><C882><EFBFBD><EFBFBD>̂Ƃ<CC82><C682>܂<EFBFBD><DC82>B

-<EFBFBD><EFBFBD><EFBFBD>̑<EFBFBD><EFBFBD>A<EFBFBD><EFBFBD><EFBFBD>̃\<5C>t<EFBFBD>g<EFBFBD>E<EFBFBD>F<EFBFBD>A<EFBFBD>̗<EFBFBD><CC97>p<EFBFBD><70><EFBFBD><EFBFBD><EFBFBD>ɂ<C982><C282>ẮA<CD81><41><EFBFBD>łł<C582><C582><EFBFBD> libpng 1.0.11beta3<EFBFBD><EFBFBD>
+<EFBFBD><EFBFBD><EFBFBD>̑<EFBFBD><EFBFBD>A<EFBFBD><EFBFBD><EFBFBD>̃\<5C>t<EFBFBD>g<EFBFBD>E<EFBFBD>F<EFBFBD>A<EFBFBD>̗<EFBFBD><CC97>p<EFBFBD><70><EFBFBD><EFBFBD><EFBFBD>ɂ<C982><C282>ẮA<CD81><41><EFBFBD>łł<C582><C582><EFBFBD> libpng 1.2.0beta3<EFBFBD><EFBFBD>
 <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̂Ƃ<EFBFBD><EFBFBD>܂<EFBFBD><EFBFBD>B<EFBFBD>ڂ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>́A<EFBFBD>t<EFBFBD><EFBFBD><EFBFBD><EFBFBD> README,LICENSE <20><><EFBFBD><EFBFBD><EFBFBD>ǂ݂<C782><DD82><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>B

 <EFBFBD><EFBFBD><EFBFBD>^<5E><><EFBFBD>e
--- a/projects/wince/png32ce.def
+++ b/projects/wince/png32ce.def
@@ -5,7 +5,7 @@
 LIBRARY lpngce

 EXPORTS
-;Version 1.0.11beta3
+;Version 1.2.0beta3
  png_build_grayscale_palette  @1
  png_check_sig        @2
  png_chunk_error      @3
@@ -82,7 +82,8 @@ EXPORTS
  png_read_end    @74
  png_read_image    @75
  png_read_info    @76
-  png_read_init    @77 ; deprecated
+; png_read_init is deprecated
+  png_read_init    @77
  png_read_png    @78
  png_read_row    @79
  png_read_rows    @80
@@ -167,19 +168,44 @@ EXPORTS
  png_write_image    @159
  png_write_info    @160
  png_write_info_before_PLTE  @161
-  png_write_init    @162 ; deprecated
+; png_write_init is deprecated
+  png_write_init    @162
  png_write_png    @163
  png_write_row    @164
  png_write_rows    @165
+; png_read_init_2 and png_write_init_2 are deprecated.
  png_read_init_2    @166
  png_write_init_2    @167
  png_access_version_number  @168
 ;  png_sig_bytes    @169
-  png_libpng_ver    @170
+;  png_libpng_ver    @170
  png_init_io    @171
  png_convert_to_rfc1123     @172
  png_set_invalid  @173
-;To be added at version 1.2.0
-; png_permit_mng_features  @174
-;To be added at version 1.2.0
-; png_mmx_support  @175
+; Added at version 1.0.12
+; For compatiblity with 1.0.7-1.0.11
+  png_info_init @174
+  png_read_init_3    @175
+  png_write_init_3    @176
+  png_info_init_3 @177
+  png_destroy_struct  @178
+; Added at version 1.2.0
+; For use with PNG_USER_MEM_SUPPORTED
+  png_destroy_struct_2  @179
+  png_create_read_struct_2 @180
+  png_create_write_struct_2 @181
+  png_malloc_default @182
+  png_free_default @183
+; MNG features
+  png_permit_mng_features  @184
+; MMX support
+  png_mmx_support  @185
+  png_get_mmx_flagmask  @186
+  png_get_asm_flagmask  @187
+  png_get_asm_flags  @188
+  png_get_mmx_bitdepth_threshold  @189
+  png_get_mmx_rowbytes_threshold  @190
+  png_set_asm_flags  @191
+  png_init_mmx_flags  @192
+; Strip error numbers
+  png_set_strip_error_numbers @193
--- a/scripts/makefile.aix
+++ b/scripts/makefile.aix
@@ -15,10 +15,10 @@ AR = ar rcs
 RANLIB = ranlib
 RM = rm -f

-# read libpng.txt or png.h to see why PNGMAJ is 2.  You should not
+# read libpng.txt or png.h to see why PNGMAJ is 3.  You should not
 # have to change it.
-PNGMAJ = 2
-PNGMIN = 1.0.11beta3
+PNGMAJ = 3
+PNGMIN = 1.2.0beta3
 PNGVER = $(PNGMAJ).$(PNGMIN)

 prefix=/usr/local
--- a/scripts/makefile.beos
+++ b/scripts/makefile.beos
@@ -10,10 +10,10 @@ CC=gcc
 ZLIBLIB=/usr/local/lib
 ZLIBINC=/usr/local/include

-# read libpng.txt or png.h to see why PNGMAJ is 2.  You should not
+# read libpng.txt or png.h to see why PNGMAJ is 3.  You should not
 # have to change it.
-PNGMAJ = 2
-PNGMIN = 1.0.11beta3
+PNGMAJ = 3
+PNGMIN = 1.2.0beta3
 PNGVER = $(PNGMAJ).$(PNGMIN)

 ALIGN=
--- a/scripts/makefile.cygwin
+++ b/scripts/makefile.cygwin
@@ -35,13 +35,13 @@ WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
 CFLAGS=-I$(ZLIBINC) -Wall -O3 $(ALIGN) -funroll-loops \
 	-fomit-frame-pointer

-# read libpng.txt or png.h to see why PNGMAJ is 2.  You should not
+# read libpng.txt or png.h to see why PNGMAJ is 3.  You should not
 # have to change it.
-PNGMAJ = 2
-#PNGDLL = $1# msvc
-PNGDLL = 2# cygwin 1.0.11beta3
-PNGMIN = 1.0.11beta3
-PNGMIN_BASE = 1.0.11
+PNGMAJ = 3
+#PNGDLL = $3# msvc
+PNGDLL = 2# cygwin 1.2.0beta3
+PNGMIN = 1.2.0beta3
+PNGMIN_BASE = 1.2.0
 PNGVER = $(PNGMAJ).$(PNGMIN)

 SHAREDLIB=cygpng$(PNGDLL).dll
@@ -108,7 +108,8 @@ $(STATLIB): $(OBJS)
 	$(RANLIB) $@

 $(SHAREDDEF): projects/msvc/png32ms.def
-	cat $< | sed -e '1{G;s/^\(.*\)\(\n\)/EXPORTS/;};2,/^EXPORTS/d' > $@
+	cat $< | sed -e '1{G;s/^\(.*\)\(\n\)/EXPORTS/;};2,/^EXPORTS/d' | \
+	sed -e 's/\([^;]*\);/;/' > $@

 $(SHAREDLIB): $(OBJSDLL) $(SHAREDDEF)
 	$(LDSHARED) -o $@ $(LDEXTRA) $(OBJSDLL) -L. -L$(ZLIBLIB) -lz
--- a/scripts/makefile.dec
+++ b/scripts/makefile.dec
@@ -14,10 +14,10 @@ LIBPATH=$(prefix)/lib
 ZLIBLIB=../zlib
 ZLIBINC=../zlib

-# read libpng.txt or png.h to see why PNGMAJ is 2.  You should not
+# read libpng.txt or png.h to see why PNGMAJ is 3.  You should not
 # have to change it.
-PNGMAJ = 2
-PNGMIN = 1.0.11beta3
+PNGMAJ = 3
+PNGMIN = 1.2.0beta3
 PNGVER = $(PNGMAJ).$(PNGMIN)

 CC=cc
--- a/scripts/makefile.gcmmx
+++ b/scripts/makefile.gcmmx
@@ -48,10 +48,10 @@ LDFLAGS_A=-L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) libpng.a -lz -lm
 RANLIB=ranlib
 #RANLIB=echo

-# read libpng.txt or png.h to see why PNGMAJ is 2.  You should not
+# read libpng.txt or png.h to see why PNGMAJ is 3.  You should not
 # have to change it.
-PNGMAJ = 2
-PNGMIN = 1.0.11beta3
+PNGMAJ = 3
+PNGMIN = 1.2.0beta3
 PNGVER = $(PNGMAJ).$(PNGMIN)

 INCPATH=$(prefix)/include
--- a/scripts/makefile.hpgcc
+++ b/scripts/makefile.hpgcc
@@ -31,10 +31,10 @@ LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
 RANLIB=ranlib
 #RANLIB=echo

-# read libpng.txt or png.h to see why PNGMAJ is 2.  You should not
+# read libpng.txt or png.h to see why PNGMAJ is 3.  You should not
 # have to change it.
-PNGMAJ = 2
-PNGMIN = 1.0.11beta3
+PNGMAJ = 3
+PNGMIN = 1.2.0beta3
 PNGVER = $(PNGMAJ).$(PNGMIN)

 INCPATH=$(prefix)/include
--- a/scripts/makefile.hpux
+++ b/scripts/makefile.hpux
@@ -16,10 +16,10 @@ LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm

 RANLIB=ranlib

-# read libpng.txt or png.h to see why PNGMAJ is 2.  You should not
+# read libpng.txt or png.h to see why PNGMAJ is 3.  You should not
 # have to change it.
-PNGMAJ = 2
-PNGMIN = 1.0.11beta3
+PNGMAJ = 3
+PNGMIN = 1.2.0beta3
 PNGVER = $(PNGMAJ).$(PNGMIN)

 # where make install puts libpng.a and png.h
--- a/scripts/makefile.linux
+++ b/scripts/makefile.linux
@@ -31,10 +31,10 @@ LDFLAGS=-L. -Wl,-rpath,. -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) -lpng -lz -lm
 RANLIB=ranlib
 #RANLIB=echo

-# read libpng.txt or png.h to see why PNGMAJ is 2.  You should not
+# read libpng.txt or png.h to see why PNGMAJ is 3.  You should not
 # have to change it.
-PNGMAJ = 2
-PNGMIN = 1.0.11beta3
+PNGMAJ = 3
+PNGMIN = 1.2.0beta3
 PNGVER = $(PNGMAJ).$(PNGMIN)

 INCPATH=$(prefix)/include
--- a/scripts/makefile.netbsd
+++ b/scripts/makefile.netbsd
@@ -0,0 +1,42 @@
+# makefile for libpng for NetBSD for the standard
+# make obj && make depend && make && make test
+# make includes && make install
+# Copyright (C) 2001 Patrick R.L. Welche
+# For conditions of distribution and use, see copyright notice in png.h
+
+LOCALBASE?=/usr/local
+LIBDIR=	${LOCALBASE}/lib
+MANDIR= ${LOCALBASE}/man
+INCSDIR=${LOCALBASE}/include
+
+LIB=png
+SHLIB_MAJOR= 3
+SHLIB_MINOR= 1.2.0beta3
+SRCS=	pnggccrd.c png.c pngset.c pngget.c pngrutil.c pngtrans.c pngwutil.c \
+	pngread.c pngrio.c pngwio.c pngwrite.c pngrtran.c \
+	pngwtran.c pngmem.c pngerror.c pngpread.c
+INCS=	png.h pngconf.h
+MAN=	libpng.3 libpngpf.3 png.5
+
+CPPFLAGS+=-I${.CURDIR} -DPNG_USE_PNGGCCRD
+
+CPPFLAGS+=-DPNG_NO_ASSEMBLER_CODE
+# something like this for mmx assembler, but it core dumps for me at the moment
+# .if ${MACHINE_ARCH} == "i386"
+#   MKLINT= no
+# .else
+#   CPPFLAGS+=-DPNG_NO_ASSEMBLER_CODE
+# .endif
+
+CLEANFILES+=pngtest.o pngtest
+
+pngtest.o:	pngtest.c
+	${CC} -c ${CPPFLAGS} ${CFLAGS} ${.ALLSRC} -o ${.TARGET}
+
+pngtest:	pngtest.o libpng.a
+	${CC} ${LDFLAGS} ${.ALLSRC} -o${.TARGET} -lz -lm
+
+test:	pngtest
+	cd ${.CURDIR} && ${.OBJDIR}/pngtest
+
+.include <bsd.lib.mk>
--- a/scripts/makefile.sco
+++ b/scripts/makefile.sco
@@ -22,10 +22,10 @@ LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
 #RANLIB=ranlib
 RANLIB=echo

-# read libpng.txt or png.h to see why PNGMAJ is 2.  You should not
+# read libpng.txt or png.h to see why PNGMAJ is 3.  You should not
 # have to change it.
-PNGMAJ = 2
-PNGMIN = 1.0.11beta3
+PNGMAJ = 3
+PNGMIN = 1.2.0beta3
 PNGVER = $(PNGMAJ).$(PNGMIN)

 INCPATH=$(prefix)/include
--- a/scripts/makefile.sggcc
+++ b/scripts/makefile.sggcc
@@ -19,8 +19,8 @@ CFLAGS=-I$(ZLIBINC) -O2 $(WARNMORE) -fPIC -mabi=n32
 LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
 LDSHARED=gcc -shared

-VER=1.0.11beta3
-LIBS=libpng.so.1.0.11beta3
+VER=1.2.0beta3
+LIBS=libpng.so.1.2.0beta3
 SHAREDLIB=libpng.so
 libdir=$(prefix)/lib32

--- a/scripts/makefile.sgi
+++ b/scripts/makefile.sgi
@@ -25,7 +25,7 @@ CFLAGS=-I$(ZLIBINC) -O $(WARNMORE) -DPNG_USE_PNGGCCRD -DPNG_NO_ASSEMBLER_CODE
 LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
 LDSHARED=cc -shared

-VER=1.0.11beta3
+VER=1.2.0beta3
 SONUM=2
 SHAREDLIB=libpng.so
 libdir=$(prefix)
--- a/scripts/makefile.solaris
+++ b/scripts/makefile.solaris
@@ -28,10 +28,10 @@ LDFLAGS=-L. -R. -L$(ZLIBLIB) -R$(ZLIBLIB) -lpng -lz -lm
 #RANLIB=ranlib
 RANLIB=echo

-# read libpng.txt or png.h to see why PNGMAJ is 2.  You should not
+# read libpng.txt or png.h to see why PNGMAJ is 3.  You should not
 # have to change it.
-PNGMAJ = 2
-PNGMIN = 1.0.11beta3
+PNGMAJ = 3
+PNGMIN = 1.2.0beta3
 PNGVER = $(PNGMAJ).$(PNGMIN)

 INCPATH=$(prefix)/include
--- a/scripts/pngdef.pas
+++ b/scripts/pngdef.pas
@@ -7,8 +7,8 @@ unit pngdef;
 interface

 const
-  PNG_LIBPNG_VER_STRING = '1.0.11beta3';
-  PNG_LIBPNG_VER        =  10011;
+  PNG_LIBPNG_VER_STRING = '1.2.0beta3';
+  PNG_LIBPNG_VER        =  10200;

 type
  png_uint_32 = Cardinal;
--- a/scripts/pngos2.def
+++ b/scripts/pngos2.def
@@ -2,7 +2,7 @@
 ; PNG.LIB module definition file for OS/2
 ;----------------------------------------

-; Version 1.0.11beta3
+; Version 1.2.0beta3

 LIBRARY		PNG
 DESCRIPTION	"PNG image compression library for OS/2"
@@ -187,8 +187,17 @@ EXPORTS
 ;To be added at version 1.2.0
 ; png_permit_mng_features

-;To be added at version 1.2.0
-; png_mmx_support
+; Added at version 1.2.0:
+  png_mmx_support
+  png_permit_empty_plte
+  png_permit_mng_features
+  png_get_mmx_flagmask
+  png_get_asm_flagmask
+  png_get_asm_flags
+  png_get_mmx_bitdepth_threshold
+  png_get_mmx_rowbytes_threshold
+  png_set_asm_flags
+  png_init_mmx_flags

 ; These are not present when libpng is compiled with PNG_NO_GLOBAL_ARRAYS
  png_libpng_ver
Author	SHA1	Message	Date
Glenn Randers-Pehrson	8b6a889881	Imported from libpng-1.2.0beta3.tar	2009-04-06 16:06:20 -05:00
Glenn Randers-Pehrson	3097f618f2	Imported from libpng-1.2.0beta2.tar	2009-04-06 16:06:18 -05:00
Glenn Randers-Pehrson	1fd5fb33c2	Imported from libpng-1.2.0beta1.tar	2009-04-06 16:06:16 -05:00
Glenn Randers-Pehrson	e68f5a361b	Imported from libpng-1.0.12beta1.tar	2009-04-06 16:06:14 -05:00
Glenn Randers-Pehrson	328353990f	Imported from libpng-1.0.11.tar	2009-04-06 16:06:12 -05:00
Glenn Randers-Pehrson	82ae383331	Imported from libpng-1.0.11rc1.tar	2009-04-06 16:06:10 -05:00