chore: swap out libpng to the version 4J used (Includes custom changes made by 4J to png.h and pngwrite.c)

Windows_Libs/Dev/Render/libpng/pngconf.h

@@ -1,17 +1,19 @@
-/* pngconf.h - machine-configurable file for libpng
+
+/* pngconf.h - machine configurable file for libpng
  *
- * libpng version 1.6.55
+ * libpng version 1.6.2 - April 25, 2013
  *
- * Copyright (c) 2018-2026 Cosmin Truta
+ * Copyright (c) 1998-2013 Glenn Randers-Pehrson
- * Copyright (c) 1998-2002,2004,2006-2016,2018 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * Copyright (c) 1996-1997 Andreas Dilger
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
- * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
  * and license in png.h
  *
- * Any machine specific code is near the front of this file, so if you
+ */
+
+/* Any machine specific code is near the front of this file, so if you
  * are configuring libpng for a machine, you may want to read the section
  * starting here down to where it starts to typedef png_color, png_text,
  * and png_info.
@@ -20,6 +22,26 @@
 #ifndef PNGCONF_H
 #define PNGCONF_H
 
+/* To do: Do all of this in scripts/pnglibconf.dfa */
+#ifdef PNG_SAFE_LIMITS_SUPPORTED
+#  ifdef PNG_USER_WIDTH_MAX
+#    undef PNG_USER_WIDTH_MAX
+#    define PNG_USER_WIDTH_MAX 1000000L
+#  endif
+#  ifdef PNG_USER_HEIGHT_MAX
+#    undef PNG_USER_HEIGHT_MAX
+#    define PNG_USER_HEIGHT_MAX 1000000L
+#  endif
+#  ifdef PNG_USER_CHUNK_MALLOC_MAX
+#    undef PNG_USER_CHUNK_MALLOC_MAX
+#    define PNG_USER_CHUNK_MALLOC_MAX 4000000L
+#  endif
+#  ifdef PNG_USER_CHUNK_CACHE_MAX
+#    undef PNG_USER_CHUNK_CACHE_MAX
+#    define PNG_USER_CHUNK_CACHE_MAX 128
+#  endif
+#endif
+
 #ifndef PNG_BUILDING_SYMBOL_TABLE /* else includes may cause problems */
 
 /* From libpng 1.6.0 libpng requires an ANSI X3.159-1989 ("ISOC90") compliant C
@@ -57,13 +79,14 @@
 
 #endif /* PNG_BUILDING_SYMBOL_TABLE */
 
-/* Prior to 1.6.0, it was possible to turn off 'const' in declarations,
+/* Prior to 1.6.0 it was possible to turn off 'const' in declarations using
- * using PNG_NO_CONST.  This is no longer supported.
+ * PNG_NO_CONST; this is no longer supported except for data declarations which
+ * apparently still cause problems in 2011 on some compilers.
  */
 #define PNG_CONST const /* backward compatibility only */
 
-/* This controls optimization of the reading of 16-bit and 32-bit
+/* This controls optimization of the reading of 16 and 32 bit values
- * values from PNG files.  It can be set on a per-app-file basis: it
+ * from PNG files.  It can be set on a per-app-file basis - it
  * just changes whether a macro is used when the function is called.
  * The library builder sets the default; if read functions are not
  * built into the library the macro implementation is forced on.
@@ -87,7 +110,7 @@
 
 /* The PNGARG macro was used in versions of libpng prior to 1.6.0 to protect
  * against legacy (pre ISOC90) compilers that did not understand function
- * prototypes.  [Deprecated.]
+ * prototypes.  It is not required for modern C compilers.
  */
 #ifndef PNGARG
 #  define PNGARG(arglist) arglist
@@ -126,7 +149,7 @@
  *
  * These cases only differ if the operating system does not use the C
  * calling convention, at present this just means the above cases
- * (x86 DOS/Windows systems) and, even then, this does not apply to
+ * (x86 DOS/Windows sytems) and, even then, this does not apply to
  * Cygwin running on those systems.
  *
  * Note that the value must be defined in pnglibconf.h so that what
@@ -179,35 +202,35 @@
  * compiler-specific macros to the values required to change the calling
  * conventions of the various functions.
  */
-#if defined(_WIN32) || defined(__WIN32__) || defined(__NT__) || \
+#if defined(_Windows) || defined(_WINDOWS) || defined(WIN32) ||\
-    defined(__CYGWIN__)
+    defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
   /* Windows system (DOS doesn't support DLLs).  Includes builds under Cygwin or
    * MinGW on any architecture currently supported by Windows.  Also includes
    * Watcom builds but these need special treatment because they are not
    * compatible with GCC or Visual C because of different calling conventions.
    */
 #  if PNG_API_RULE == 2
-   /* If this line results in an error, either because __watcall is not
+    /* If this line results in an error, either because __watcall is not
-    * understood or because of a redefine just below you cannot use *this*
+     * understood or because of a redefine just below you cannot use *this*
-    * build of the library with the compiler you are using.  *This* build was
+     * build of the library with the compiler you are using.  *This* build was
-    * build using Watcom and applications must also be built using Watcom!
+     * build using Watcom and applications must also be built using Watcom!
-    */
+     */
 #    define PNGCAPI __watcall
 #  endif
 
 #  if defined(__GNUC__) || (defined(_MSC_VER) && (_MSC_VER >= 800))
 #    define PNGCAPI __cdecl
 #    if PNG_API_RULE == 1
-   /* If this line results in an error __stdcall is not understood and
+       /* If this line results in an error __stdcall is not understood and
-    * PNG_API_RULE should not have been set to '1'.
+        * PNG_API_RULE should not have been set to '1'.
-    */
+        */
 #      define PNGAPI __stdcall
 #    endif
 #  else
-   /* An older compiler, or one not detected (erroneously) above,
+    /* An older compiler, or one not detected (erroneously) above,
-    * if necessary override on the command line to get the correct
+     * if necessary override on the command line to get the correct
-    * variants for the compiler.
+     * variants for the compiler.
-    */
+     */
 #    ifndef PNGCAPI
 #      define PNGCAPI _cdecl
 #    endif
@@ -215,25 +238,36 @@
 #      define PNGAPI _stdcall
 #    endif
 #  endif /* compiler/api */
-
   /* NOTE: PNGCBAPI always defaults to PNGCAPI. */
 
 #  if defined(PNGAPI) && !defined(PNG_USER_PRIVATEBUILD)
-#     error PNG_USER_PRIVATEBUILD must be defined if PNGAPI is changed
+#     error "PNG_USER_PRIVATEBUILD must be defined if PNGAPI is changed"
 #  endif
 
-#  define PNG_DLL_EXPORT __declspec(dllexport)
+#  if (defined(_MSC_VER) && _MSC_VER < 800) ||\
-#  ifndef PNG_DLL_IMPORT
+      (defined(__BORLANDC__) && __BORLANDC__ < 0x500)
-#    define PNG_DLL_IMPORT __declspec(dllimport)
+    /* older Borland and MSC
-#  endif
+     * compilers used '__export' and required this to be after
+     * the type.
+     */
+#    ifndef PNG_EXPORT_TYPE
+#      define PNG_EXPORT_TYPE(type) type PNG_IMPEXP
+#    endif
+#    define PNG_DLL_EXPORT __export
+#  else /* newer compiler */
+#    define PNG_DLL_EXPORT __declspec(dllexport)
+#    ifndef PNG_DLL_IMPORT
+#      define PNG_DLL_IMPORT __declspec(dllimport)
+#    endif
+#  endif /* compiler */
 
 #else /* !Windows */
 #  if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__)
 #    define PNGAPI _System
 #  else /* !Windows/x86 && !OS/2 */
-   /* Use the defaults, or define PNG*API on the command line (but
+    /* Use the defaults, or define PNG*API on the command line (but
-    * this will have to be done for every compile!)
+     * this will have to be done for every compile!)
-    */
+     */
 #  endif /* other system, !OS/2 */
 #endif /* !Windows/x86 */
 
@@ -254,7 +288,7 @@
  */
 #ifndef PNG_IMPEXP
 #  if defined(PNG_USE_DLL) && defined(PNG_DLL_IMPORT)
-   /* This forces use of a DLL, disallowing static linking */
+     /* This forces use of a DLL, disallowing static linking */
 #    define PNG_IMPEXP PNG_DLL_IMPORT
 #  endif
 
@@ -282,11 +316,11 @@
     * table entries, so we discard it here.  See the .dfn files in the
     * scripts directory.
     */
-
 #ifndef PNG_EXPORTA
-#  define PNG_EXPORTA(ordinal, type, name, args, attributes) \
+
-      PNG_FUNCTION(PNG_EXPORT_TYPE(type), (PNGAPI name), args, \
+#  define PNG_EXPORTA(ordinal, type, name, args, attributes)\
-      PNG_LINKAGE_API attributes)
+      PNG_FUNCTION(PNG_EXPORT_TYPE(type),(PNGAPI name),PNGARG(args), \
+        extern attributes)
 #endif
 
 /* ANSI-C (C90) does not permit a macro to be invoked with an empty argument,
@@ -294,7 +328,7 @@
  */
 #define PNG_EMPTY /*empty list*/
 
-#define PNG_EXPORT(ordinal, type, name, args) \
+#define PNG_EXPORT(ordinal, type, name, args)\
    PNG_EXPORTA(ordinal, type, name, args, PNG_EMPTY)
 
 /* Use PNG_REMOVED to comment out a removed interface. */
@@ -303,7 +337,7 @@
 #endif
 
 #ifndef PNG_CALLBACK
-#  define PNG_CALLBACK(type, name, args) type (PNGCBAPI name) args
+#  define PNG_CALLBACK(type, name, args) type (PNGCBAPI name) PNGARG(args)
 #endif
 
 /* Support for compiler specific function attributes.  These are used
@@ -326,33 +360,7 @@
    * version 1.2.41.  Disabling these removes the warnings but may also produce
    * less efficient code.
    */
-#  if defined(__clang__) && defined(__has_attribute)
+#  if defined(__GNUC__)
-   /* Clang defines both __clang__ and __GNUC__. Check __clang__ first. */
-#    if !defined(PNG_USE_RESULT) && __has_attribute(__warn_unused_result__)
-#      define PNG_USE_RESULT __attribute__((__warn_unused_result__))
-#    endif
-#    if !defined(PNG_NORETURN) && __has_attribute(__noreturn__)
-#      define PNG_NORETURN __attribute__((__noreturn__))
-#    endif
-#    if !defined(PNG_ALLOCATED) && __has_attribute(__malloc__)
-#      define PNG_ALLOCATED __attribute__((__malloc__))
-#    endif
-#    if !defined(PNG_DEPRECATED) && __has_attribute(__deprecated__)
-#      define PNG_DEPRECATED __attribute__((__deprecated__))
-#    endif
-#    if !defined(PNG_PRIVATE)
-#      ifdef __has_extension
-#        if __has_extension(attribute_unavailable_with_message)
-#          define PNG_PRIVATE __attribute__((__unavailable__(\
-             "This function is not exported by libpng.")))
-#        endif
-#      endif
-#    endif
-#    ifndef PNG_RESTRICT
-#      define PNG_RESTRICT __restrict
-#    endif
-
-#  elif defined(__GNUC__)
 #    ifndef PNG_USE_RESULT
 #      define PNG_USE_RESULT __attribute__((__warn_unused_result__))
 #    endif
@@ -375,12 +383,12 @@
             __attribute__((__deprecated__))
 #        endif
 #      endif
-#      if ((__GNUC__ > 3) || !defined(__GNUC_MINOR__) || (__GNUC_MINOR__ >= 1))
+#      if ((__GNUC__ != 3) || !defined(__GNUC_MINOR__) || (__GNUC_MINOR__ >= 1))
 #        ifndef PNG_RESTRICT
 #          define PNG_RESTRICT __restrict
 #        endif
-#      endif /* __GNUC__.__GNUC_MINOR__ > 3.0 */
+#      endif /*  __GNUC__ == 3.0 */
-#    endif /* __GNUC__ >= 3 */
+#    endif /*  __GNUC__ >= 3 */
 
 #  elif defined(_MSC_VER)  && (_MSC_VER >= 1300)
 #    ifndef PNG_USE_RESULT
@@ -410,7 +418,7 @@
 #    ifndef PNG_RESTRICT
 #      define PNG_RESTRICT __restrict
 #    endif
-#  endif
+#  endif /* _MSC_VER */
 #endif /* PNG_PEDANTIC_WARNINGS */
 
 #ifndef PNG_DEPRECATED
@@ -431,7 +439,6 @@
 #ifndef PNG_RESTRICT
 #  define PNG_RESTRICT    /* The C99 "restrict" feature */
 #endif
-
 #ifndef PNG_FP_EXPORT     /* A floating point API. */
 #  ifdef PNG_FLOATING_POINT_SUPPORTED
 #     define PNG_FP_EXPORT(ordinal, type, name, args)\
@@ -467,7 +474,7 @@
 #if CHAR_BIT == 8 && UCHAR_MAX == 255
    typedef unsigned char png_byte;
 #else
-#  error libpng requires 8-bit bytes
+#  error "libpng requires 8 bit bytes"
 #endif
 
 #if INT_MIN == -32768 && INT_MAX == 32767
@@ -475,7 +482,7 @@
 #elif SHRT_MIN == -32768 && SHRT_MAX == 32767
    typedef short png_int_16;
 #else
-#  error libpng requires a signed 16-bit integer type
+#  error "libpng requires a signed 16 bit type"
 #endif
 
 #if UINT_MAX == 65535
@@ -483,7 +490,7 @@
 #elif USHRT_MAX == 65535
    typedef unsigned short png_uint_16;
 #else
-#  error libpng requires an unsigned 16-bit integer type
+#  error "libpng requires an unsigned 16 bit type"
 #endif
 
 #if INT_MIN < -2147483646 && INT_MAX > 2147483646
@@ -491,21 +498,19 @@
 #elif LONG_MIN < -2147483646 && LONG_MAX > 2147483646
    typedef long int png_int_32;
 #else
-#  error libpng requires a signed 32-bit (or longer) integer type
+#  error "libpng requires a signed 32 bit (or more) type"
 #endif
 
-#if UINT_MAX > 4294967294U
+#if UINT_MAX > 4294967294
    typedef unsigned int png_uint_32;
-#elif ULONG_MAX > 4294967294U
+#elif ULONG_MAX > 4294967294
    typedef unsigned long int png_uint_32;
 #else
-#  error libpng requires an unsigned 32-bit (or longer) integer type
+#  error "libpng requires an unsigned 32 bit (or more) type"
 #endif
 
-/* Prior to 1.6.0, it was possible to disable the use of size_t and ptrdiff_t.
+/* Prior to 1.6.0 it was possible to disable the use of size_t, 1.6.0, however,
- * From 1.6.0 onwards, an ISO C90 compiler, as well as a standard-compliant
+ * requires an ISOC90 compiler and relies on consistent behavior of sizeof.
- * behavior of sizeof and ptrdiff_t are required.
- * The legacy typedefs are provided here for backwards compatibility.
  */
 typedef size_t png_size_t;
 typedef ptrdiff_t png_ptrdiff_t;
@@ -526,12 +531,13 @@ typedef ptrdiff_t png_ptrdiff_t;
 #  endif
 #endif
 
-/* png_alloc_size_t is guaranteed to be no smaller than size_t, and no smaller
+/* png_alloc_size_t is guaranteed to be no smaller than png_size_t, and no
- * than png_uint_32.  Casts from size_t or png_uint_32 to png_alloc_size_t are
+ * smaller than png_uint_32.  Casts from png_size_t or png_uint_32 to
- * not necessary; in fact, it is recommended not to use them at all, so that
+ * png_alloc_size_t are not necessary; in fact, it is recommended not to use
- * the compiler can complain when something turns out to be problematic.
+ * them at all so that the compiler can complain when something turns out to be
+ * problematic.
  *
- * Casts in the other direction (from png_alloc_size_t to size_t or
+ * Casts in the other direction (from png_alloc_size_t to png_size_t or
  * png_uint_32) should be explicitly applied; however, we do not expect to
  * encounter practical situations that require such conversions.
  *
@@ -541,7 +547,7 @@ typedef ptrdiff_t png_ptrdiff_t;
 #ifdef PNG_SMALL_SIZE_T
    typedef png_uint_32 png_alloc_size_t;
 #else
-   typedef size_t png_alloc_size_t;
+   typedef png_size_t png_alloc_size_t;
 #endif
 
 /* Prior to 1.6.0 libpng offered limited support for Microsoft C compiler
@@ -577,8 +583,12 @@ typedef char                  * png_charp;
 typedef const char            * png_const_charp;
 typedef png_fixed_point       * png_fixed_point_p;
 typedef const png_fixed_point * png_const_fixed_point_p;
-typedef size_t                * png_size_tp;
+typedef png_size_t            * png_size_tp;
-typedef const size_t          * png_const_size_tp;
+typedef const png_size_t      * png_const_size_tp;
+
+#ifdef PNG_STDIO_SUPPORTED
+typedef FILE            * png_FILE_p;
+#endif
 
 #ifdef PNG_FLOATING_POINT_SUPPORTED
 typedef double       * png_doublep;
@@ -601,15 +611,6 @@ typedef double          * * png_doublepp;
 /* Pointers to pointers to pointers; i.e., pointer to array */
 typedef char            * * * png_charppp;
 
-#ifdef PNG_STDIO_SUPPORTED
-/* With PNG_STDIO_SUPPORTED it was possible to use I/O streams that were
- * not necessarily stdio FILE streams, to allow building Windows applications
- * before Win32 and Windows CE applications before WinCE 3.0, but that kind
- * of support has long been discontinued.
- */
-typedef FILE            * png_FILE_p; /* [Deprecated] */
-#endif
-
 #endif /* PNG_BUILDING_SYMBOL_TABLE */
 
 #endif /* PNGCONF_H */

Windows_Libs/Dev/Render/libpng/pngdebug.h

@@ -1,19 +1,17 @@
-/* pngdebug.h - internal debugging macros for libpng
+
+/* pngdebug.h - Debugging macros for libpng, also used in pngtest.c
  *
- * Copyright (c) 2018-2025 Cosmin Truta
+ * Copyright (c) 1998-2011 Glenn Randers-Pehrson
- * Copyright (c) 1998-2002,2004,2006-2013 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * Copyright (c) 1996-1997 Andreas Dilger
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
- * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * Last changed in libpng 1.5.0 [January 6, 2011]
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
  * and license in png.h
  */
 
-#ifndef PNGPRIV_H
-#  error This file must not be included by applications; please include <png.h>
-#endif
-
 /* Define PNG_DEBUG at compile time for debugging information.  Higher
  * numbers for PNG_DEBUG mean more debugging information.  This has
  * only been added since version 0.95 so it is not implemented throughout
@@ -27,7 +25,7 @@
  *   (actually ((void)0)).
  *
  *   level: level of detail of message, starting at 0.  A level 'n'
- *          message is preceded by 'n' 3-space indentations (not implemented
+ *          message is preceded by 'n' tab characters (not implemented
  *          on Microsoft compilers unless PNG_DEBUG_FILE is also
  *          defined, to allow debug DLL compilation with no standard IO).
  *   message: a printf(3) style text string.  A trailing '\n' is added
@@ -38,6 +36,9 @@
 #define PNGDEBUG_H
 /* These settings control the formatting of messages in png.c and pngerror.c */
 /* Moved to pngdebug.h at 1.5.0 */
+#  ifndef PNG_LITERAL_SHARP
+#    define PNG_LITERAL_SHARP 0x23
+#  endif
 #  ifndef PNG_LITERAL_LEFT_SQUARE_BRACKET
 #    define PNG_LITERAL_LEFT_SQUARE_BRACKET 0x5b
 #  endif
@@ -76,29 +77,32 @@
 #      endif /* PNG_DEBUG_FILE */
 
 #      if (PNG_DEBUG > 1)
+/* Note: ["%s"m PNG_STRING_NEWLINE] probably does not work on
+ * non-ISO compilers
+ */
 #        ifdef __STDC__
 #          ifndef png_debug
 #            define png_debug(l,m) \
        do { \
        int num_tabs=l; \
-       fprintf(PNG_DEBUG_FILE,"%s" m PNG_STRING_NEWLINE,(num_tabs==1 ? "   " : \
+       fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \
-         (num_tabs==2 ? "      " : (num_tabs>2 ? "         " : "")))); \
+         (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \
        } while (0)
 #          endif
 #          ifndef png_debug1
 #            define png_debug1(l,m,p1) \
        do { \
        int num_tabs=l; \
-       fprintf(PNG_DEBUG_FILE,"%s" m PNG_STRING_NEWLINE,(num_tabs==1 ? "   " : \
+       fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \
-         (num_tabs==2 ? "      " : (num_tabs>2 ? "         " : ""))),p1); \
+         (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \
        } while (0)
 #          endif
 #          ifndef png_debug2
 #            define png_debug2(l,m,p1,p2) \
        do { \
        int num_tabs=l; \
-       fprintf(PNG_DEBUG_FILE,"%s" m PNG_STRING_NEWLINE,(num_tabs==1 ? "   " : \
+       fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \
-         (num_tabs==2 ? "      " : (num_tabs>2 ? "         " : ""))),p1,p2);\
+         (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \
        } while (0)
 #          endif
 #        else /* __STDC __ */

Windows_Libs/Dev/Render/libpng/pngerror.c

@@ -1,9 +1,10 @@
+
 /* pngerror.c - stub functions for i/o and memory allocation
  *
- * Copyright (c) 2018-2025 Cosmin Truta
+ * Last changed in libpng 1.6.1 [March 28, 2013]
- * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 Glenn Randers-Pehrson
- * Copyright (c) 1996-1997 Andreas Dilger
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -19,15 +20,14 @@
 
 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
 
-static PNG_FUNCTION(void /* PRIVATE */,
+static PNG_FUNCTION(void, png_default_error,PNGARG((png_const_structrp png_ptr,
-png_default_error,(png_const_structrp png_ptr, png_const_charp error_message),
+    png_const_charp error_message)),PNG_NORETURN);
-    PNG_NORETURN);
 
 #ifdef PNG_WARNINGS_SUPPORTED
 static void /* PRIVATE */
-png_default_warning(png_const_structrp png_ptr,
+png_default_warning PNGARG((png_const_structrp png_ptr,
-    png_const_charp warning_message);
+   png_const_charp warning_message));
-#endif /* WARNINGS */
+#endif /* PNG_WARNINGS_SUPPORTED */
 
 /* This function is called whenever there is a fatal error.  This function
  * should not be changed.  If there is a need to handle errors differently,
@@ -37,8 +37,48 @@ png_default_warning(png_const_structrp png_ptr,
 #ifdef PNG_ERROR_TEXT_SUPPORTED
 PNG_FUNCTION(void,PNGAPI
 png_error,(png_const_structrp png_ptr, png_const_charp error_message),
-    PNG_NORETURN)
+   PNG_NORETURN)
 {
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+   char msg[16];
+   if (png_ptr != NULL)
+   {
+      if (png_ptr->flags&
+         (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
+      {
+         if (*error_message == PNG_LITERAL_SHARP)
+         {
+            /* Strip "#nnnn " from beginning of error message. */
+            int offset;
+            for (offset = 1; offset<15; offset++)
+               if (error_message[offset] == ' ')
+                  break;
+
+            if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
+            {
+               int i;
+               for (i = 0; i < offset - 1; i++)
+                  msg[i] = error_message[i + 1];
+               msg[i - 1] = '\0';
+               error_message = msg;
+            }
+
+            else
+               error_message += offset;
+      }
+
+      else
+      {
+         if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
+         {
+            msg[0] = '0';
+            msg[1] = '\0';
+            error_message = msg;
+         }
+       }
+     }
+   }
+#endif
    if (png_ptr != NULL && png_ptr->error_fn != NULL)
       (*(png_ptr->error_fn))(png_constcast(png_structrp,png_ptr),
           error_message);
@@ -49,8 +89,7 @@ png_error,(png_const_structrp png_ptr, png_const_charp error_message),
 }
 #else
 PNG_FUNCTION(void,PNGAPI
-png_err,(png_const_structrp png_ptr),
+png_err,(png_const_structrp png_ptr),PNG_NORETURN)
-    PNG_NORETURN)
 {
    /* Prior to 1.5.2 the error_fn received a NULL pointer, expressed
     * erroneously as '\0', instead of the empty string "".  This was
@@ -64,14 +103,14 @@ png_err,(png_const_structrp png_ptr),
       use the default handler, which will not return. */
    png_default_error(png_ptr, "");
 }
-#endif /* ERROR_TEXT */
+#endif /* PNG_ERROR_TEXT_SUPPORTED */
 
 /* Utility to safely appends strings to a buffer.  This never errors out so
  * error checking is not required in the caller.
  */
 size_t
 png_safecat(png_charp buffer, size_t bufsize, size_t pos,
-    png_const_charp string)
+   png_const_charp string)
 {
    if (buffer != NULL && pos < bufsize)
    {
@@ -92,7 +131,7 @@ png_safecat(png_charp buffer, size_t bufsize, size_t pos,
  */
 png_charp
 png_format_number(png_const_charp start, png_charp end, int format,
-    png_alloc_size_t number)
+   png_alloc_size_t number)
 {
    int count = 0;    /* number of digits output */
    int mincount = 1; /* minimum number required */
@@ -113,7 +152,7 @@ png_format_number(png_const_charp start, png_charp end, int format,
          case PNG_NUMBER_FORMAT_fixed:
             /* Needs five digits (the fraction) */
             mincount = 5;
-            if (output != 0 || number % 10 != 0)
+            if (output || number % 10 != 0)
             {
                *--end = digits[number % 10];
                output = 1;
@@ -124,7 +163,7 @@ png_format_number(png_const_charp start, png_charp end, int format,
          case PNG_NUMBER_FORMAT_02u:
             /* Expects at least 2 digits. */
             mincount = 2;
-            /* FALLTHROUGH */
+            /* FALL THROUGH */
 
          case PNG_NUMBER_FORMAT_u:
             *--end = digits[number % 10];
@@ -134,7 +173,7 @@ png_format_number(png_const_charp start, png_charp end, int format,
          case PNG_NUMBER_FORMAT_02x:
             /* This format expects at least two digits */
             mincount = 2;
-            /* FALLTHROUGH */
+            /* FALL THROUGH */
 
          case PNG_NUMBER_FORMAT_x:
             *--end = digits[number & 0xf];
@@ -150,13 +189,13 @@ png_format_number(png_const_charp start, png_charp end, int format,
       ++count;
 
       /* Float a fixed number here: */
-      if ((format == PNG_NUMBER_FORMAT_fixed) && (count == 5) && (end > start))
+      if (format == PNG_NUMBER_FORMAT_fixed) if (count == 5) if (end > start)
       {
          /* End of the fraction, but maybe nothing was output?  In that case
           * drop the decimal point.  If the number is a true zero handle that
           * here.
           */
-         if (output != 0)
+         if (output)
             *--end = '.';
          else if (number == 0) /* and !output */
             *--end = '0';
@@ -177,9 +216,24 @@ void PNGAPI
 png_warning(png_const_structrp png_ptr, png_const_charp warning_message)
 {
    int offset = 0;
+   if (png_ptr != NULL)
+   {
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+   if (png_ptr->flags&
+       (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
+#endif
+      {
+         if (*warning_message == PNG_LITERAL_SHARP)
+         {
+            for (offset = 1; offset < 15; offset++)
+               if (warning_message[offset] == ' ')
+                  break;
+         }
+      }
+   }
    if (png_ptr != NULL && png_ptr->warning_fn != NULL)
       (*(png_ptr->warning_fn))(png_constcast(png_structrp,png_ptr),
-          warning_message + offset);
+         warning_message + offset);
    else
       png_default_warning(png_ptr, warning_message + offset);
 }
@@ -191,7 +245,7 @@ png_warning(png_const_structrp png_ptr, png_const_charp warning_message)
  */
 void
 png_warning_parameter(png_warning_parameters p, int number,
-    png_const_charp string)
+   png_const_charp string)
 {
    if (number > 0 && number <= PNG_WARNING_PARAMETER_COUNT)
       (void)png_safecat(p[number-1], (sizeof p[number-1]), 0, string);
@@ -199,19 +253,19 @@ png_warning_parameter(png_warning_parameters p, int number,
 
 void
 png_warning_parameter_unsigned(png_warning_parameters p, int number, int format,
-    png_alloc_size_t value)
+   png_alloc_size_t value)
 {
-   char buffer[PNG_NUMBER_BUFFER_SIZE] = {0};
+   char buffer[PNG_NUMBER_BUFFER_SIZE];
    png_warning_parameter(p, number, PNG_FORMAT_NUMBER(buffer, format, value));
 }
 
 void
 png_warning_parameter_signed(png_warning_parameters p, int number, int format,
-    png_int_32 value)
+   png_int_32 value)
 {
    png_alloc_size_t u;
    png_charp str;
-   char buffer[PNG_NUMBER_BUFFER_SIZE] = {0};
+   char buffer[PNG_NUMBER_BUFFER_SIZE];
 
    /* Avoid overflow by doing the negate in a png_alloc_size_t: */
    u = (png_alloc_size_t)value;
@@ -228,7 +282,7 @@ png_warning_parameter_signed(png_warning_parameters p, int number, int format,
 
 void
 png_formatted_warning(png_const_structrp png_ptr, png_warning_parameters p,
-    png_const_charp message)
+   png_const_charp message)
 {
    /* The internal buffer is just 192 bytes - enough for all our messages,
     * overflow doesn't happen because this code checks!  If someone figures
@@ -301,13 +355,13 @@ png_formatted_warning(png_const_structrp png_ptr, png_warning_parameters p,
     */
    png_warning(png_ptr, msg);
 }
-#endif /* WARNINGS */
+#endif /* PNG_WARNINGS_SUPPORTED */
 
 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
 void PNGAPI
 png_benign_error(png_const_structrp png_ptr, png_const_charp error_message)
 {
-   if ((png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) != 0)
+   if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
    {
 #     ifdef PNG_READ_SUPPORTED
          if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
@@ -328,57 +382,44 @@ png_benign_error(png_const_structrp png_ptr, png_const_charp error_message)
 #     endif
       png_error(png_ptr, error_message);
    }
-
-#  ifndef PNG_ERROR_TEXT_SUPPORTED
-      PNG_UNUSED(error_message)
-#  endif
 }
 
 void /* PRIVATE */
 png_app_warning(png_const_structrp png_ptr, png_const_charp error_message)
 {
-   if ((png_ptr->flags & PNG_FLAG_APP_WARNINGS_WARN) != 0)
+  if (png_ptr->flags & PNG_FLAG_APP_WARNINGS_WARN)
-      png_warning(png_ptr, error_message);
+     png_warning(png_ptr, error_message);
-   else
+  else
-      png_error(png_ptr, error_message);
+     png_error(png_ptr, error_message);
-
-#  ifndef PNG_ERROR_TEXT_SUPPORTED
-      PNG_UNUSED(error_message)
-#  endif
 }
 
 void /* PRIVATE */
 png_app_error(png_const_structrp png_ptr, png_const_charp error_message)
 {
-   if ((png_ptr->flags & PNG_FLAG_APP_ERRORS_WARN) != 0)
+  if (png_ptr->flags & PNG_FLAG_APP_ERRORS_WARN)
-      png_warning(png_ptr, error_message);
+     png_warning(png_ptr, error_message);
-   else
+  else
-      png_error(png_ptr, error_message);
+     png_error(png_ptr, error_message);
-
-#  ifndef PNG_ERROR_TEXT_SUPPORTED
-      PNG_UNUSED(error_message)
-#  endif
 }
 #endif /* BENIGN_ERRORS */
 
-#define PNG_MAX_ERROR_TEXT 196 /* Currently limited by profile_error in png.c */
-#if defined(PNG_WARNINGS_SUPPORTED) || \
-   (defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED))
 /* These utilities are used internally to build an error message that relates
  * to the current chunk.  The chunk name comes from png_ptr->chunk_name,
- * which is used to prefix the message.  The message is limited in length
+ * this is used to prefix the message.  The message is limited in length
- * to 63 bytes. The name characters are output as hex digits wrapped in []
+ * to 63 bytes, the name characters are output as hex digits wrapped in []
  * if the character is invalid.
  */
 #define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
-static const char png_digit[16] = {
+static PNG_CONST char png_digit[16] = {
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    'A', 'B', 'C', 'D', 'E', 'F'
 };
 
+#define PNG_MAX_ERROR_TEXT 196 /* Currently limited be profile_error in png.c */
+#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)
 static void /* PRIVATE */
-png_format_buffer(png_const_structrp png_ptr, png_charp buffer,
+png_format_buffer(png_const_structrp png_ptr, png_charp buffer, png_const_charp
-    png_const_charp error_message)
+    error_message)
 {
    png_uint_32 chunk_name = png_ptr->chunk_name;
    int iout = 0, ishift = 24;
@@ -388,7 +429,7 @@ png_format_buffer(png_const_structrp png_ptr, png_charp buffer,
       int c = (int)(chunk_name >> ishift) & 0xff;
 
       ishift -= 8;
-      if (isnonalpha(c) != 0)
+      if (isnonalpha(c))
       {
          buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET;
          buffer[iout++] = png_digit[(c & 0xf0) >> 4];
@@ -419,12 +460,12 @@ png_format_buffer(png_const_structrp png_ptr, png_charp buffer,
       buffer[iout] = '\0';
    }
 }
-#endif /* WARNINGS || ERROR_TEXT */
+#endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */
 
 #if defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED)
 PNG_FUNCTION(void,PNGAPI
 png_chunk_error,(png_const_structrp png_ptr, png_const_charp error_message),
-    PNG_NORETURN)
+   PNG_NORETURN)
 {
    char msg[18+PNG_MAX_ERROR_TEXT];
    if (png_ptr == NULL)
@@ -436,7 +477,7 @@ png_chunk_error,(png_const_structrp png_ptr, png_const_charp error_message),
       png_error(png_ptr, msg);
    }
 }
-#endif /* READ && ERROR_TEXT */
+#endif /* PNG_READ_SUPPORTED && PNG_ERROR_TEXT_SUPPORTED */
 
 #ifdef PNG_WARNINGS_SUPPORTED
 void PNGAPI
@@ -452,39 +493,31 @@ png_chunk_warning(png_const_structrp png_ptr, png_const_charp warning_message)
       png_warning(png_ptr, msg);
    }
 }
-#endif /* WARNINGS */
+#endif /* PNG_WARNINGS_SUPPORTED */
 
 #ifdef PNG_READ_SUPPORTED
 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
 void PNGAPI
-png_chunk_benign_error(png_const_structrp png_ptr,
+png_chunk_benign_error(png_const_structrp png_ptr, png_const_charp
-    png_const_charp error_message)
+    error_message)
 {
-   if ((png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) != 0)
+   if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
       png_chunk_warning(png_ptr, error_message);
 
    else
       png_chunk_error(png_ptr, error_message);
-
-#  ifndef PNG_ERROR_TEXT_SUPPORTED
-      PNG_UNUSED(error_message)
-#  endif
 }
 #endif
-#endif /* READ */
+#endif /* PNG_READ_SUPPORTED */
 
 void /* PRIVATE */
 png_chunk_report(png_const_structrp png_ptr, png_const_charp message, int error)
 {
-#  ifndef PNG_WARNINGS_SUPPORTED
-      PNG_UNUSED(message)
-#  endif
-
    /* This is always supported, but for just read or just write it
     * unconditionally does the right thing.
     */
 #  if defined(PNG_READ_SUPPORTED) && defined(PNG_WRITE_SUPPORTED)
-      if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
+      if (png_ptr->mode & PNG_IS_READ_STRUCT)
 #  endif
 
 #  ifdef PNG_READ_SUPPORTED
@@ -498,7 +531,7 @@ png_chunk_report(png_const_structrp png_ptr, png_const_charp message, int error)
 #  endif
 
 #  if defined(PNG_READ_SUPPORTED) && defined(PNG_WRITE_SUPPORTED)
-      else if ((png_ptr->mode & PNG_IS_READ_STRUCT) == 0)
+      else if (!(png_ptr->mode & PNG_IS_READ_STRUCT))
 #  endif
 
 #  ifdef PNG_WRITE_SUPPORTED
@@ -515,21 +548,19 @@ png_chunk_report(png_const_structrp png_ptr, png_const_charp message, int error)
 #ifdef PNG_ERROR_TEXT_SUPPORTED
 #ifdef PNG_FLOATING_POINT_SUPPORTED
 PNG_FUNCTION(void,
-png_fixed_error,(png_const_structrp png_ptr, png_const_charp name),
+png_fixed_error,(png_const_structrp png_ptr, png_const_charp name),PNG_NORETURN)
-    PNG_NORETURN)
 {
 #  define fixed_message "fixed point overflow in "
 #  define fixed_message_ln ((sizeof fixed_message)-1)
-   unsigned int  iin;
+   int  iin;
    char msg[fixed_message_ln+PNG_MAX_ERROR_TEXT];
    memcpy(msg, fixed_message, fixed_message_ln);
    iin = 0;
-   if (name != NULL)
+   if (name != NULL) while (iin < (PNG_MAX_ERROR_TEXT-1) && name[iin] != 0)
-      while (iin < (PNG_MAX_ERROR_TEXT-1) && name[iin] != 0)
+   {
-      {
+      msg[fixed_message_ln + iin] = name[iin];
-         msg[fixed_message_ln + iin] = name[iin];
+      ++iin;
-         ++iin;
+   }
-      }
    msg[fixed_message_ln + iin] = 0;
    png_error(png_ptr, msg);
 }
@@ -567,7 +598,7 @@ png_set_longjmp_fn(png_structrp png_ptr, png_longjmp_ptr longjmp_fn,
       else
       {
          png_ptr->jmp_buf_ptr = png_voidcast(jmp_buf *,
-             png_malloc_warn(png_ptr, jmp_buf_size));
+            png_malloc_warn(png_ptr, jmp_buf_size));
 
          if (png_ptr->jmp_buf_ptr == NULL)
             return NULL; /* new NULL return on OOM */
@@ -656,12 +687,45 @@ png_free_jmpbuf(png_structrp png_ptr)
  */
 static PNG_FUNCTION(void /* PRIVATE */,
 png_default_error,(png_const_structrp png_ptr, png_const_charp error_message),
-    PNG_NORETURN)
+   PNG_NORETURN)
 {
 #ifdef PNG_CONSOLE_IO_SUPPORTED
-   fprintf(stderr, "libpng error: %s", error_message ? error_message :
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
-      "undefined");
+   /* Check on NULL only added in 1.5.4 */
-   fprintf(stderr, PNG_STRING_NEWLINE);
+   if (error_message != NULL && *error_message == PNG_LITERAL_SHARP)
+   {
+      /* Strip "#nnnn " from beginning of error message. */
+      int offset;
+      char error_number[16];
+      for (offset = 0; offset<15; offset++)
+      {
+         error_number[offset] = error_message[offset + 1];
+         if (error_message[offset] == ' ')
+            break;
+      }
+
+      if ((offset > 1) && (offset < 15))
+      {
+         error_number[offset - 1] = '\0';
+         fprintf(stderr, "libpng error no. %s: %s",
+             error_number, error_message + offset + 1);
+         fprintf(stderr, PNG_STRING_NEWLINE);
+      }
+
+      else
+      {
+         fprintf(stderr, "libpng error: %s, offset=%d",
+             error_message, offset);
+         fprintf(stderr, PNG_STRING_NEWLINE);
+      }
+   }
+   else
+#endif
+   {
+      fprintf(stderr, "libpng error: %s", error_message ? error_message :
+         "undefined");
+      fprintf(stderr, PNG_STRING_NEWLINE);
+   }
 #else
    PNG_UNUSED(error_message) /* Make compiler happy */
 #endif
@@ -669,24 +733,14 @@ png_default_error,(png_const_structrp png_ptr, png_const_charp error_message),
 }
 
 PNG_FUNCTION(void,PNGAPI
-png_longjmp,(png_const_structrp png_ptr, int val),
+png_longjmp,(png_const_structrp png_ptr, int val),PNG_NORETURN)
-    PNG_NORETURN)
 {
 #ifdef PNG_SETJMP_SUPPORTED
-   if (png_ptr != NULL && png_ptr->longjmp_fn != NULL &&
+   if (png_ptr && png_ptr->longjmp_fn && png_ptr->jmp_buf_ptr)
-       png_ptr->jmp_buf_ptr != NULL)
       png_ptr->longjmp_fn(*png_ptr->jmp_buf_ptr, val);
-#else
-   PNG_UNUSED(png_ptr)
-   PNG_UNUSED(val)
 #endif
 
-   /* If control reaches this point, png_longjmp() must not return. The only
+   /* Here if not setjmp support or if png_ptr is null. */
-    * choice is to terminate the whole process (or maybe the thread); to do
-    * this the ANSI-C abort() function is used unless a different method is
-    * implemented by overriding the default configuration setting for
-    * PNG_ABORT().
-    */
    PNG_ABORT();
 }
 
@@ -700,14 +754,46 @@ static void /* PRIVATE */
 png_default_warning(png_const_structrp png_ptr, png_const_charp warning_message)
 {
 #ifdef PNG_CONSOLE_IO_SUPPORTED
-   fprintf(stderr, "libpng warning: %s", warning_message);
+#  ifdef PNG_ERROR_NUMBERS_SUPPORTED
-   fprintf(stderr, PNG_STRING_NEWLINE);
+   if (*warning_message == PNG_LITERAL_SHARP)
+   {
+      int offset;
+      char warning_number[16];
+      for (offset = 0; offset < 15; offset++)
+      {
+         warning_number[offset] = warning_message[offset + 1];
+         if (warning_message[offset] == ' ')
+            break;
+      }
+
+      if ((offset > 1) && (offset < 15))
+      {
+         warning_number[offset + 1] = '\0';
+         fprintf(stderr, "libpng warning no. %s: %s",
+             warning_number, warning_message + offset);
+         fprintf(stderr, PNG_STRING_NEWLINE);
+      }
+
+      else
+      {
+         fprintf(stderr, "libpng warning: %s",
+             warning_message);
+         fprintf(stderr, PNG_STRING_NEWLINE);
+      }
+   }
+   else
+#  endif
+
+   {
+      fprintf(stderr, "libpng warning: %s", warning_message);
+      fprintf(stderr, PNG_STRING_NEWLINE);
+   }
 #else
    PNG_UNUSED(warning_message) /* Make compiler happy */
 #endif
    PNG_UNUSED(png_ptr) /* Make compiler happy */
 }
-#endif /* WARNINGS */
+#endif /* PNG_WARNINGS_SUPPORTED */
 
 /* This function is called when the application wants to use another method
  * of handling errors and warnings.  Note that the error function MUST NOT
@@ -741,7 +827,7 @@ png_get_error_ptr(png_const_structrp png_ptr)
    if (png_ptr == NULL)
       return NULL;
 
-   return (png_voidp)png_ptr->error_ptr;
+   return ((png_voidp)png_ptr->error_ptr);
 }
 
 
@@ -749,8 +835,12 @@ png_get_error_ptr(png_const_structrp png_ptr)
 void PNGAPI
 png_set_strip_error_numbers(png_structrp png_ptr, png_uint_32 strip_mode)
 {
-   PNG_UNUSED(png_ptr)
+   if (png_ptr != NULL)
-   PNG_UNUSED(strip_mode)
+   {
+      png_ptr->flags &=
+         ((~(PNG_FLAG_STRIP_ERROR_NUMBERS |
+         PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);
+   }
 }
 #endif
 
@@ -760,11 +850,11 @@ png_set_strip_error_numbers(png_structrp png_ptr, png_uint_32 strip_mode)
     * possible to implement without setjmp support just so long as there is some
     * way to handle the error return here:
     */
-PNG_FUNCTION(void /* PRIVATE */, (PNGCBAPI
+PNG_FUNCTION(void /* PRIVATE */,
-png_safe_error),(png_structp png_nonconst_ptr, png_const_charp error_message),
+png_safe_error,(png_structp png_nonconst_ptr, png_const_charp error_message),
-    PNG_NORETURN)
+   PNG_NORETURN)
 {
-   png_const_structrp png_ptr = png_nonconst_ptr;
+   const png_const_structrp png_ptr = png_nonconst_ptr;
    png_imagep image = png_voidcast(png_imagep, png_ptr->error_ptr);
 
    /* An error is always logged here, overwriting anything (typically a warning)
@@ -785,7 +875,7 @@ png_safe_error),(png_structp png_nonconst_ptr, png_const_charp error_message),
       /* Missing longjmp buffer, the following is to help debugging: */
       {
          size_t pos = png_safecat(image->message, (sizeof image->message), 0,
-             "bad longjmp: ");
+            "bad longjmp: ");
          png_safecat(image->message, (sizeof image->message), pos,
              error_message);
       }
@@ -796,10 +886,10 @@ png_safe_error),(png_structp png_nonconst_ptr, png_const_charp error_message),
 }
 
 #ifdef PNG_WARNINGS_SUPPORTED
-void /* PRIVATE */ PNGCBAPI
+void /* PRIVATE */
 png_safe_warning(png_structp png_nonconst_ptr, png_const_charp warning_message)
 {
-   png_const_structrp png_ptr = png_nonconst_ptr;
+   const png_const_structrp png_ptr = png_nonconst_ptr;
    png_imagep image = png_voidcast(png_imagep, png_ptr->error_ptr);
 
    /* A warning is only logged if there is no prior warning or error. */
@@ -812,39 +902,31 @@ png_safe_warning(png_structp png_nonconst_ptr, png_const_charp warning_message)
 #endif
 
 int /* PRIVATE */
-png_safe_execute(png_imagep image, int (*function)(png_voidp), png_voidp arg)
+png_safe_execute(png_imagep image_in, int (*function)(png_voidp), png_voidp arg)
 {
-   const png_voidp saved_error_buf = image->opaque->error_buf;
+   volatile png_imagep image = image_in;
+   volatile int result;
+   volatile png_voidp saved_error_buf;
    jmp_buf safe_jmpbuf;
 
-   /* Safely execute function(arg), with png_error returning back here. */
+   /* Safely execute function(arg) with png_error returning to this function. */
-   if (setjmp(safe_jmpbuf) == 0)
+   saved_error_buf = image->opaque->error_buf;
+   result = setjmp(safe_jmpbuf) == 0;
+
+   if (result)
    {
-      int result;
 
       image->opaque->error_buf = safe_jmpbuf;
       result = function(arg);
-      image->opaque->error_buf = saved_error_buf;
-
-      if (result)
-         return 1; /* success */
    }
 
-   /* The function failed either because of a caught png_error and a regular
-    * return of false above or because of an uncaught png_error from the
-    * function itself.  Ensure that the error_buf is always set back to the
-    * value saved above:
-    */
    image->opaque->error_buf = saved_error_buf;
 
-   /* On the final false return, when about to return control to the caller, the
+   /* And do the cleanup prior to any failure return. */
-    * image is freed (png_image_free does this check but it is duplicated here
+   if (!result)
-    * for clarity:
-    */
-   if (saved_error_buf == NULL)
       png_image_free(image);
 
-   return 0; /* failure */
+   return result;
 }
-#endif /* SIMPLIFIED READ || SIMPLIFIED_WRITE */
+#endif /* SIMPLIFIED READ/WRITE */
-#endif /* READ || WRITE */
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

Windows_Libs/Dev/Render/libpng/pnginfo.h

@@ -1,29 +1,54 @@
-/* pnginfo.h - internal structures for libpng
+
+/* pnginfo.h - header file for PNG reference library
  *
- * Copyright (c) 2018-2025 Cosmin Truta
+ * Copyright (c) 1998-2013 Glenn Randers-Pehrson
- * Copyright (c) 1998-2002,2004,2006-2013,2018 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * Copyright (c) 1996-1997 Andreas Dilger
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
- * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * Last changed in libpng 1.6.1 [March 28, 2013]
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
  * and license in png.h
  */
 
-#ifndef PNGPRIV_H
+ /* png_info is a structure that holds the information in a PNG file so
-#  error This file must not be included by applications; please include <png.h>
+ * that the application can find out the characteristics of the image.
-#endif
+ * If you are reading the file, this structure will tell you what is
-
+ * in the PNG file.  If you are writing the file, fill in the information
-/* INTERNAL, PRIVATE definition of a PNG.
+ * you want to put into the PNG file, using png_set_*() functions, then
+ * call png_write_info().
  *
- * png_info is a modifiable description of a PNG datastream.  The fields inside
+ * The names chosen should be very close to the PNG specification, so
- * this structure are accessed through png_get_<CHUNK>() functions and modified
+ * consult that document for information about the meaning of each field.
- * using png_set_<CHUNK>() functions.
  *
- * Some functions in libpng do directly access members of png_info.  However,
+ * With libpng < 0.95, it was only possible to directly set and read the
- * this should be avoided.  png_struct objects contain members which hold
+ * the values in the png_info_struct, which meant that the contents and
- * caches, sometimes optimised, of the values from png_info objects, and
+ * order of the values had to remain fixed.  With libpng 0.95 and later,
- * png_info is not passed to the functions which read and write image data.
+ * however, there are now functions that abstract the contents of
+ * png_info_struct from the application, so this makes it easier to use
+ * libpng with dynamic libraries, and even makes it possible to use
+ * libraries that don't have all of the libpng ancillary chunk-handing
+ * functionality.  In libpng-1.5.0 this was moved into a separate private
+ * file that is not visible to applications.
+ *
+ * The following members may have allocated storage attached that should be
+ * cleaned up before the structure is discarded: palette, trans, text,
+ * pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile,
+ * splt_palettes, scal_unit, row_pointers, and unknowns.   By default, these
+ * are automatically freed when the info structure is deallocated, if they were
+ * allocated internally by libpng.  This behavior can be changed by means
+ * of the png_data_freer() function.
+ *
+ * More allocation details: all the chunk-reading functions that
+ * change these members go through the corresponding png_set_*
+ * functions.  A function to clear these members is available: see
+ * png_free_data().  The png_set_* functions do not depend on being
+ * able to point info structure members to any of the storage they are
+ * passed (they make their own copies), EXCEPT that the png_set_text
+ * functions use the same storage passed to them in the text_ptr or
+ * itxt_ptr structure argument, and the png_set_rows and png_set_unknowns
+ * functions do not make their own copies.
  */
 #ifndef PNGINFO_H
 #define PNGINFO_H
@@ -31,10 +56,10 @@
 struct png_info_def
 {
    /* The following are necessary for every PNG file */
-   png_uint_32 width;       /* width of image in pixels (from IHDR) */
+   png_uint_32 width;  /* width of image in pixels (from IHDR) */
-   png_uint_32 height;      /* height of image in pixels (from IHDR) */
+   png_uint_32 height; /* height of image in pixels (from IHDR) */
-   png_uint_32 valid;       /* valid chunk data (see PNG_INFO_ below) */
+   png_uint_32 valid;  /* valid chunk data (see PNG_INFO_ below) */
-   size_t rowbytes;         /* bytes needed to hold an untransformed row */
+   png_size_t rowbytes; /* bytes needed to hold an untransformed row */
    png_colorp palette;      /* array of color values (valid & PNG_INFO_PLTE) */
    png_uint_16 num_palette; /* number of color entries in "palette" (PLTE) */
    png_uint_16 num_trans;   /* number of transparent palette color (tRNS) */
@@ -63,12 +88,18 @@ struct png_info_def
     * and initialize the appropriate fields below.
     */
 
-#ifdef PNG_cICP_SUPPORTED
+#if defined(PNG_COLORSPACE_SUPPORTED) || defined(PNG_GAMMA_SUPPORTED)
-   /* cICP chunk data */
+   /* png_colorspace only contains 'flags' if neither GAMMA or COLORSPACE are
-   png_byte cicp_colour_primaries;
+    * defined.  When COLORSPACE is switched on all the colorspace-defining
-   png_byte cicp_transfer_function;
+    * chunks should be enabled, when GAMMA is switched on all the gamma-defining
-   png_byte cicp_matrix_coefficients;
+    * chunks should be enabled.  If this is not done it becomes possible to read
-   png_byte cicp_video_full_range_flag;
+    * inconsistent PNG files and assign a probably incorrect interpretation to
+    * the information.  (In other words, by carefully choosing which chunks to
+    * recognize the system configuration can select an interpretation for PNG
+    * files containing ambiguous data and this will result in inconsistent
+    * behavior between different libpng builds!)
+    */
+   png_colorspace colorspace;
 #endif
 
 #ifdef PNG_iCCP_SUPPORTED
@@ -78,24 +109,6 @@ struct png_info_def
    png_uint_32 iccp_proflen;  /* ICC profile data length */
 #endif
 
-#ifdef PNG_cLLI_SUPPORTED
-   png_uint_32 maxCLL;  /* cd/m2 (nits) * 10,000 */
-   png_uint_32 maxFALL;
-#endif
-
-#ifdef PNG_mDCV_SUPPORTED
-   png_uint_16 mastering_red_x;  /* CIE (xy) x * 50,000 */
-   png_uint_16 mastering_red_y;
-   png_uint_16 mastering_green_x;
-   png_uint_16 mastering_green_y;
-   png_uint_16 mastering_blue_x;
-   png_uint_16 mastering_blue_y;
-   png_uint_16 mastering_white_x;
-   png_uint_16 mastering_white_y;
-   png_uint_32 mastering_maxDL; /* cd/m2 (nits) * 10,000 */
-   png_uint_32 mastering_minDL;
-#endif
-
 #ifdef PNG_TEXT_SUPPORTED
    /* The tEXt, and zTXt chunks contain human-readable textual data in
     * uncompressed, compressed, and optionally compressed forms, respectively.
@@ -108,7 +121,7 @@ struct png_info_def
    int num_text; /* number of comments read or comments to write */
    int max_text; /* current size of text array */
    png_textp text; /* array of comments read or comments to write */
-#endif /* TEXT */
+#endif /* PNG_TEXT_SUPPORTED */
 
 #ifdef PNG_tIME_SUPPORTED
    /* The tIME chunk holds the last time the displayed image data was
@@ -173,11 +186,6 @@ defined(PNG_READ_BACKGROUND_SUPPORTED)
    png_byte phys_unit_type; /* resolution type (see PNG_RESOLUTION_ below) */
 #endif
 
-#ifdef PNG_eXIf_SUPPORTED
-   png_uint_32 num_exif;  /* Added at libpng-1.6.31 */
-   png_bytep exif;
-#endif
-
 #ifdef PNG_hIST_SUPPORTED
    /* The hIST chunk contains the relative frequency or importance of the
     * various palette entries, so that a viewer can intelligently select a
@@ -216,7 +224,7 @@ defined(PNG_READ_BACKGROUND_SUPPORTED)
    /* Storage for unknown chunks that the library doesn't recognize. */
    png_unknown_chunkp unknown_chunks;
 
-   /* The type of this field is limited by the type of
+   /* The type of this field is limited by the type of 
     * png_struct::user_chunk_cache_max, else overflow can occur.
     */
    int                unknown_chunks_num;
@@ -232,7 +240,7 @@ defined(PNG_READ_BACKGROUND_SUPPORTED)
    /* The sCAL chunk describes the actual physical dimensions of the
     * subject matter of the graphic.  The chunk contains a unit specification
     * a byte value, and two ASCII strings representing floating-point
-    * values.  The values are width and height corresponding to one pixel
+    * values.  The values are width and height corresponsing to one pixel
     * in the image.  Data values are valid if (valid & PNG_INFO_sCAL) is
     * non-zero.
     */
@@ -248,16 +256,5 @@ defined(PNG_READ_BACKGROUND_SUPPORTED)
    png_bytepp row_pointers;        /* the image bits */
 #endif
 
-#ifdef PNG_cHRM_SUPPORTED
-   png_xy cHRM;
-#endif
-
-#ifdef PNG_gAMA_SUPPORTED
-   png_fixed_point gamma;
-#endif
-
-#ifdef PNG_sRGB_SUPPORTED
-   int rendering_intent;
-#endif
 };
 #endif /* PNGINFO_H */

Windows_Libs/Dev/Render/libpng/pnglibconf.h

@@ -1,9 +1,10 @@
+/* libpng 1.6.2 STANDARD API DEFINITION */
+
 /* pnglibconf.h - library build configuration */
 
-/* libpng version 1.6.55 */
+/* Libpng version 1.6.2 - April 25, 2013 */
 
-/* Copyright (c) 2018-2026 Cosmin Truta */
+/* Copyright (c) 1998-2013 Glenn Randers-Pehrson */
-/* Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson */
 
 /* This code is released under the libpng license. */
 /* For conditions of distribution and use, see the disclaimer */
@@ -19,6 +20,7 @@
 #define PNG_ALIGNED_MEMORY_SUPPORTED
 /*#undef PNG_ARM_NEON_API_SUPPORTED*/
 /*#undef PNG_ARM_NEON_CHECK_SUPPORTED*/
+/*#undef PNG_ARM_NEON_SUPPORTED*/
 #define PNG_BENIGN_ERRORS_SUPPORTED
 #define PNG_BENIGN_READ_ERRORS_SUPPORTED
 /*#undef PNG_BENIGN_WRITE_ERRORS_SUPPORTED*/
@@ -27,7 +29,6 @@
 #define PNG_COLORSPACE_SUPPORTED
 #define PNG_CONSOLE_IO_SUPPORTED
 #define PNG_CONVERT_tIME_SUPPORTED
-/*#undef PNG_DISABLE_ADLER32_CHECK_SUPPORTED*/
 #define PNG_EASY_ACCESS_SUPPORTED
 /*#undef PNG_ERROR_NUMBERS_SUPPORTED*/
 #define PNG_ERROR_TEXT_SUPPORTED
@@ -42,14 +43,8 @@
 #define PNG_INCH_CONVERSIONS_SUPPORTED
 #define PNG_INFO_IMAGE_SUPPORTED
 #define PNG_IO_STATE_SUPPORTED
-/*#undef PNG_MIPS_MMI_API_SUPPORTED*/
-/*#undef PNG_MIPS_MMI_CHECK_SUPPORTED*/
-/*#undef PNG_MIPS_MSA_API_SUPPORTED*/
-/*#undef PNG_MIPS_MSA_CHECK_SUPPORTED*/
 #define PNG_MNG_FEATURES_SUPPORTED
 #define PNG_POINTER_INDEXING_SUPPORTED
-/*#undef PNG_POWERPC_VSX_API_SUPPORTED*/
-/*#undef PNG_POWERPC_VSX_CHECK_SUPPORTED*/
 #define PNG_PROGRESSIVE_READ_SUPPORTED
 #define PNG_READ_16BIT_SUPPORTED
 #define PNG_READ_ALPHA_MODE_SUPPORTED
@@ -88,14 +83,10 @@
 #define PNG_READ_USER_TRANSFORM_SUPPORTED
 #define PNG_READ_bKGD_SUPPORTED
 #define PNG_READ_cHRM_SUPPORTED
-#define PNG_READ_cICP_SUPPORTED
-#define PNG_READ_cLLI_SUPPORTED
-#define PNG_READ_eXIf_SUPPORTED
 #define PNG_READ_gAMA_SUPPORTED
 #define PNG_READ_hIST_SUPPORTED
 #define PNG_READ_iCCP_SUPPORTED
 #define PNG_READ_iTXt_SUPPORTED
-#define PNG_READ_mDCV_SUPPORTED
 #define PNG_READ_oFFs_SUPPORTED
 #define PNG_READ_pCAL_SUPPORTED
 #define PNG_READ_pHYs_SUPPORTED
@@ -107,11 +98,14 @@
 #define PNG_READ_tIME_SUPPORTED
 #define PNG_READ_tRNS_SUPPORTED
 #define PNG_READ_zTXt_SUPPORTED
+/*#undef PNG_SAFE_LIMITS_SUPPORTED*/
 #define PNG_SAVE_INT_32_SUPPORTED
 #define PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
 #define PNG_SEQUENTIAL_READ_SUPPORTED
 #define PNG_SETJMP_SUPPORTED
-#define PNG_SET_OPTION_SUPPORTED
+#define PNG_SET_CHUNK_CACHE_LIMIT_SUPPORTED
+#define PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED
+/*#undef PNG_SET_OPTION_SUPPORTED*/
 #define PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
 #define PNG_SET_USER_LIMITS_SUPPORTED
 #define PNG_SIMPLIFIED_READ_AFIRST_SUPPORTED
@@ -119,7 +113,6 @@
 #define PNG_SIMPLIFIED_READ_SUPPORTED
 #define PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
 #define PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED
-#define PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
 #define PNG_SIMPLIFIED_WRITE_SUPPORTED
 #define PNG_STDIO_SUPPORTED
 #define PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
@@ -137,7 +130,6 @@
 #define PNG_WRITE_BGR_SUPPORTED
 #define PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED
 #define PNG_WRITE_COMPRESSED_TEXT_SUPPORTED
-#define PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
 #define PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
 #define PNG_WRITE_FILLER_SUPPORTED
 #define PNG_WRITE_FILTER_SUPPORTED
@@ -161,14 +153,10 @@
 #define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
 #define PNG_WRITE_bKGD_SUPPORTED
 #define PNG_WRITE_cHRM_SUPPORTED
-#define PNG_WRITE_cICP_SUPPORTED
-#define PNG_WRITE_cLLI_SUPPORTED
-#define PNG_WRITE_eXIf_SUPPORTED
 #define PNG_WRITE_gAMA_SUPPORTED
 #define PNG_WRITE_hIST_SUPPORTED
 #define PNG_WRITE_iCCP_SUPPORTED
 #define PNG_WRITE_iTXt_SUPPORTED
-#define PNG_WRITE_mDCV_SUPPORTED
 #define PNG_WRITE_oFFs_SUPPORTED
 #define PNG_WRITE_pCAL_SUPPORTED
 #define PNG_WRITE_pHYs_SUPPORTED
@@ -182,14 +170,10 @@
 #define PNG_WRITE_zTXt_SUPPORTED
 #define PNG_bKGD_SUPPORTED
 #define PNG_cHRM_SUPPORTED
-#define PNG_cICP_SUPPORTED
-#define PNG_cLLI_SUPPORTED
-#define PNG_eXIf_SUPPORTED
 #define PNG_gAMA_SUPPORTED
 #define PNG_hIST_SUPPORTED
 #define PNG_iCCP_SUPPORTED
 #define PNG_iTXt_SUPPORTED
-#define PNG_mDCV_SUPPORTED
 #define PNG_oFFs_SUPPORTED
 #define PNG_pCAL_SUPPORTED
 #define PNG_pHYs_SUPPORTED
@@ -204,30 +188,24 @@
 /* end of options */
 /* settings */
 #define PNG_API_RULE 0
+#define PNG_CALLOC_SUPPORTED
+#define PNG_COST_SHIFT 3
 #define PNG_DEFAULT_READ_MACROS 1
 #define PNG_GAMMA_THRESHOLD_FIXED 5000
 #define PNG_IDAT_READ_SIZE PNG_ZBUF_SIZE
 #define PNG_INFLATE_BUF_SIZE 1024
-#define PNG_LINKAGE_API extern
-#define PNG_LINKAGE_CALLBACK extern
-#define PNG_LINKAGE_DATA extern
-#define PNG_LINKAGE_FUNCTION extern
 #define PNG_MAX_GAMMA_8 11
 #define PNG_QUANTIZE_BLUE_BITS 5
 #define PNG_QUANTIZE_GREEN_BITS 5
 #define PNG_QUANTIZE_RED_BITS 5
 #define PNG_TEXT_Z_DEFAULT_COMPRESSION (-1)
 #define PNG_TEXT_Z_DEFAULT_STRATEGY 0
-#define PNG_USER_CHUNK_CACHE_MAX 1000
+#define PNG_WEIGHT_SHIFT 8
-#define PNG_USER_CHUNK_MALLOC_MAX 8000000
-#define PNG_USER_HEIGHT_MAX 1000000
-#define PNG_USER_WIDTH_MAX 1000000
 #define PNG_ZBUF_SIZE 8192
-#define PNG_ZLIB_VERNUM 0 /* unknown */
 #define PNG_Z_DEFAULT_COMPRESSION (-1)
 #define PNG_Z_DEFAULT_NOFILTER_STRATEGY 0
 #define PNG_Z_DEFAULT_STRATEGY 1
 #define PNG_sCAL_PRECISION 5
 #define PNG_sRGB_PROFILE_CHECKS 2
 /* end of settings */
-#endif /* PNGLCONF_H */
+#endif /* PNGLCONF_H */

Windows_Libs/Dev/Render/libpng/pngmem.c

@@ -1,9 +1,10 @@
+
 /* pngmem.c - stub functions for memory allocation
  *
- * Copyright (c) 2018-2025 Cosmin Truta
+ * Last changed in libpng 1.6.0 [February 14, 2013]
- * Copyright (c) 1998-2002,2004,2006-2014,2016 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 Glenn Randers-Pehrson
- * Copyright (c) 1996-1997 Andreas Dilger
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -40,14 +41,13 @@ png_destroy_png_struct(png_structrp png_ptr)
 }
 
 /* Allocate memory.  For reasonable files, size should never exceed
- * 64K.  However, zlib may allocate more than 64K if you don't tell
+ * 64K.  However, zlib may allocate more then 64K if you don't tell
  * it not to.  See zconf.h and png.h for more information.  zlib does
  * need to allocate exactly 64K, so whatever you call here must
  * have the ability to do that.
  */
 PNG_FUNCTION(png_voidp,PNGAPI
-png_calloc,(png_const_structrp png_ptr, png_alloc_size_t size),
+png_calloc,(png_const_structrp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
-    PNG_ALLOCATED)
 {
    png_voidp ret;
 
@@ -66,49 +66,44 @@ png_calloc,(png_const_structrp png_ptr, png_alloc_size_t size),
  */
 PNG_FUNCTION(png_voidp /* PRIVATE */,
 png_malloc_base,(png_const_structrp png_ptr, png_alloc_size_t size),
-    PNG_ALLOCATED)
+   PNG_ALLOCATED)
 {
    /* Moved to png_malloc_base from png_malloc_default in 1.6.0; the DOS
     * allocators have also been removed in 1.6.0, so any 16-bit system now has
     * to implement a user memory handler.  This checks to be sure it isn't
     * called with big numbers.
     */
-#  ifdef PNG_MAX_MALLOC_64K
+#ifdef PNG_USER_MEM_SUPPORTED
-      /* This is support for legacy systems which had segmented addressing
+   PNG_UNUSED(png_ptr)
-       * limiting the maximum allocation size to 65536.  It takes precedence
+#endif
-       * over PNG_SIZE_MAX which is set to 65535 on true 16-bit systems.
+   if (size > 0 && size <= PNG_SIZE_MAX
-       *
+#     ifdef PNG_MAX_MALLOC_64K
-       * TODO: libpng-1.8: finally remove both cases.
+         && size <= 65536U
-       */
+#     endif
-      if (size > 65536U) return NULL;
+      )
-#  endif
+   {
-
+#ifdef PNG_USER_MEM_SUPPORTED
-   /* This is checked too because the system malloc call below takes a (size_t).
-    */
-   if (size > PNG_SIZE_MAX) return NULL;
-
-#  ifdef PNG_USER_MEM_SUPPORTED
       if (png_ptr != NULL && png_ptr->malloc_fn != NULL)
          return png_ptr->malloc_fn(png_constcast(png_structrp,png_ptr), size);
-#  else
-      PNG_UNUSED(png_ptr)
-#  endif
 
-   /* Use the system malloc */
+      else
-   return malloc((size_t)/*SAFE*/size); /* checked for truncation above */
+#endif
+         return malloc((size_t)size); /* checked for truncation above */
+   }
+
+   else
+      return NULL;
 }
 
-#if defined(PNG_TEXT_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) ||\
-   defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED)
 /* This is really here only to work round a spurious warning in GCC 4.6 and 4.7
  * that arises because of the checks in png_realloc_array that are repeated in
  * png_malloc_array.
  */
 static png_voidp
 png_malloc_array_checked(png_const_structrp png_ptr, int nelements,
-    size_t element_size)
+   size_t element_size)
 {
-   png_alloc_size_t req = (png_alloc_size_t)nelements; /* known to be > 0 */
+   png_alloc_size_t req = nelements; /* known to be > 0 */
 
    if (req <= PNG_SIZE_MAX/element_size)
       return png_malloc_base(png_ptr, req * element_size);
@@ -119,8 +114,7 @@ png_malloc_array_checked(png_const_structrp png_ptr, int nelements,
 
 PNG_FUNCTION(png_voidp /* PRIVATE */,
 png_malloc_array,(png_const_structrp png_ptr, int nelements,
-    size_t element_size),
+   size_t element_size),PNG_ALLOCATED)
-    PNG_ALLOCATED)
 {
    if (nelements <= 0 || element_size == 0)
       png_error(png_ptr, "internal error: array alloc");
@@ -130,8 +124,7 @@ png_malloc_array,(png_const_structrp png_ptr, int nelements,
 
 PNG_FUNCTION(png_voidp /* PRIVATE */,
 png_realloc_array,(png_const_structrp png_ptr, png_const_voidp old_array,
-    int old_elements, int add_elements, size_t element_size),
+   int old_elements, int add_elements, size_t element_size),PNG_ALLOCATED)
-    PNG_ALLOCATED)
 {
    /* These are internal errors: */
    if (add_elements <= 0 || element_size == 0 || old_elements < 0 ||
@@ -144,7 +137,7 @@ png_realloc_array,(png_const_structrp png_ptr, png_const_voidp old_array,
    if (add_elements <= INT_MAX - old_elements)
    {
       png_voidp new_array = png_malloc_array_checked(png_ptr,
-          old_elements+add_elements, element_size);
+         old_elements+add_elements, element_size);
 
       if (new_array != NULL)
       {
@@ -155,7 +148,7 @@ png_realloc_array,(png_const_structrp png_ptr, png_const_voidp old_array,
             memcpy(new_array, old_array, element_size*(unsigned)old_elements);
 
          memset((char*)new_array + element_size*(unsigned)old_elements, 0,
-             element_size*(unsigned)add_elements);
+            element_size*(unsigned)add_elements);
 
          return new_array;
       }
@@ -163,15 +156,13 @@ png_realloc_array,(png_const_structrp png_ptr, png_const_voidp old_array,
 
    return NULL; /* error */
 }
-#endif /* TEXT || sPLT || STORE_UNKNOWN_CHUNKS */
 
 /* Various functions that have different error handling are derived from this.
  * png_malloc always exists, but if PNG_USER_MEM_SUPPORTED is defined a separate
  * function png_malloc_default is also provided.
  */
 PNG_FUNCTION(png_voidp,PNGAPI
-png_malloc,(png_const_structrp png_ptr, png_alloc_size_t size),
+png_malloc,(png_const_structrp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
-    PNG_ALLOCATED)
 {
    png_voidp ret;
 
@@ -189,7 +180,7 @@ png_malloc,(png_const_structrp png_ptr, png_alloc_size_t size),
 #ifdef PNG_USER_MEM_SUPPORTED
 PNG_FUNCTION(png_voidp,PNGAPI
 png_malloc_default,(png_const_structrp png_ptr, png_alloc_size_t size),
-    PNG_ALLOCATED PNG_DEPRECATED)
+   PNG_ALLOCATED PNG_DEPRECATED)
 {
    png_voidp ret;
 
@@ -204,7 +195,7 @@ png_malloc_default,(png_const_structrp png_ptr, png_alloc_size_t size),
 
    return ret;
 }
-#endif /* USER_MEM */
+#endif /* PNG_USER_MEM_SUPPORTED */
 
 /* This function was added at libpng version 1.2.3.  The png_malloc_warn()
  * function will issue a png_warning and return NULL instead of issuing a
@@ -212,7 +203,7 @@ png_malloc_default,(png_const_structrp png_ptr, png_alloc_size_t size),
  */
 PNG_FUNCTION(png_voidp,PNGAPI
 png_malloc_warn,(png_const_structrp png_ptr, png_alloc_size_t size),
-    PNG_ALLOCATED)
+   PNG_ALLOCATED)
 {
    if (png_ptr != NULL)
    {
@@ -245,12 +236,11 @@ png_free(png_const_structrp png_ptr, png_voidp ptr)
 }
 
 PNG_FUNCTION(void,PNGAPI
-png_free_default,(png_const_structrp png_ptr, png_voidp ptr),
+png_free_default,(png_const_structrp png_ptr, png_voidp ptr),PNG_DEPRECATED)
-    PNG_DEPRECATED)
 {
    if (png_ptr == NULL || ptr == NULL)
       return;
-#endif /* USER_MEM */
+#endif /* PNG_USER_MEM_SUPPORTED */
 
    free(ptr);
 }
@@ -260,8 +250,8 @@ png_free_default,(png_const_structrp png_ptr, png_voidp ptr),
  * of allocating and freeing memory.
  */
 void PNGAPI
-png_set_mem_fn(png_structrp png_ptr, png_voidp mem_ptr,
+png_set_mem_fn(png_structrp png_ptr, png_voidp mem_ptr, png_malloc_ptr
-    png_malloc_ptr malloc_fn, png_free_ptr free_fn)
+  malloc_fn, png_free_ptr free_fn)
 {
    if (png_ptr != NULL)
    {
@@ -283,5 +273,5 @@ png_get_mem_ptr(png_const_structrp png_ptr)
 
    return png_ptr->mem_ptr;
 }
-#endif /* USER_MEM */
+#endif /* PNG_USER_MEM_SUPPORTED */
-#endif /* READ || WRITE */
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

Windows_Libs/Dev/Render/libpng/pngpread.c

@@ -1,9 +1,10 @@
+
 /* pngpread.c - read a png file in push mode
  *
- * Copyright (c) 2018-2025 Cosmin Truta
+ * Last changed in libpng 1.6.0 [February 14, 2013]
- * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 Glenn Randers-Pehrson
- * Copyright (c) 1996-1997 Andreas Dilger
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -18,37 +19,16 @@
 #define PNG_READ_SIG_MODE   0
 #define PNG_READ_CHUNK_MODE 1
 #define PNG_READ_IDAT_MODE  2
+#define PNG_SKIP_MODE       3
 #define PNG_READ_tEXt_MODE  4
 #define PNG_READ_zTXt_MODE  5
 #define PNG_READ_DONE_MODE  6
 #define PNG_READ_iTXt_MODE  7
 #define PNG_ERROR_MODE      8
 
-#define PNG_PUSH_SAVE_BUFFER_IF_FULL \
-if (png_ptr->push_length + 4 > png_ptr->buffer_size) \
-   { png_push_save_buffer(png_ptr); return; }
-#define PNG_PUSH_SAVE_BUFFER_IF_LT(N) \
-if (png_ptr->buffer_size < N) \
-   { png_push_save_buffer(png_ptr); return; }
-
-#ifdef PNG_READ_INTERLACING_SUPPORTED
-/* Arrays to facilitate interlacing - use pass (0 - 6) as index. */
-
-/* Start of interlace block */
-static const png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
-/* Offset to next interlace block */
-static const png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
-/* Start of interlace block in the y direction */
-static const png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
-/* Offset to next interlace block in the y direction */
-static const png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
-
-/* TODO: Move these arrays to a common utility module to avoid duplication. */
-#endif
-
 void PNGAPI
 png_process_data(png_structrp png_ptr, png_inforp info_ptr,
-    png_bytep buffer, size_t buffer_size)
+    png_bytep buffer, png_size_t buffer_size)
 {
    if (png_ptr == NULL || info_ptr == NULL)
       return;
@@ -61,20 +41,20 @@ png_process_data(png_structrp png_ptr, png_inforp info_ptr,
    }
 }
 
-size_t PNGAPI
+png_size_t PNGAPI
 png_process_data_pause(png_structrp png_ptr, int save)
 {
    if (png_ptr != NULL)
    {
-      /* It's easiest for the caller if we do the save; then the caller doesn't
+      /* It's easiest for the caller if we do the save, then the caller doesn't
        * have to supply the same data again:
        */
-      if (save != 0)
+      if (save)
          png_push_save_buffer(png_ptr);
       else
       {
          /* This includes any pending saved bytes: */
-         size_t remaining = png_ptr->buffer_size;
+         png_size_t remaining = png_ptr->buffer_size;
          png_ptr->buffer_size = 0;
 
          /* So subtract the saved buffer size, unless all the data
@@ -91,14 +71,32 @@ png_process_data_pause(png_structrp png_ptr, int save)
 png_uint_32 PNGAPI
 png_process_data_skip(png_structrp png_ptr)
 {
-/* TODO: Deprecate and remove this API.
+   png_uint_32 remaining = 0;
- * Somewhere the implementation of this seems to have been lost,
+
- * or abandoned.  It was only to support some internal back-door access
+   if (png_ptr != NULL && png_ptr->process_mode == PNG_SKIP_MODE &&
- * to png_struct) in libpng-1.4.x.
+      png_ptr->skip_length > 0)
- */
+   {
-   png_app_warning(png_ptr,
+      /* At the end of png_process_data the buffer size must be 0 (see the loop
-"png_process_data_skip is not implemented in any current version of libpng");
+       * above) so we can detect a broken call here:
-   return 0;
+       */
+      if (png_ptr->buffer_size != 0)
+         png_error(png_ptr,
+            "png_process_data_skip called inside png_process_data");
+
+      /* If is impossible for there to be a saved buffer at this point -
+       * otherwise we could not be in SKIP mode.  This will also happen if
+       * png_process_skip is called inside png_process_data (but only very
+       * rarely.)
+       */
+      if (png_ptr->save_buffer_size != 0)
+         png_error(png_ptr, "png_process_data_skip called with saved data");
+
+      remaining = png_ptr->skip_length;
+      png_ptr->skip_length = 0;
+      png_ptr->process_mode = PNG_READ_CHUNK_MODE;
+   }
+
+   return remaining;
 }
 
 /* What we do with the incoming data depends on what we were previously
@@ -130,6 +128,12 @@ png_process_some_data(png_structrp png_ptr, png_inforp info_ptr)
          break;
       }
 
+      case PNG_SKIP_MODE:
+      {
+         png_push_crc_finish(png_ptr);
+         break;
+      }
+
       default:
       {
          png_ptr->buffer_size = 0;
@@ -147,8 +151,8 @@ png_process_some_data(png_structrp png_ptr, png_inforp info_ptr)
 void /* PRIVATE */
 png_push_read_sig(png_structrp png_ptr, png_inforp info_ptr)
 {
-   size_t num_checked = png_ptr->sig_bytes; /* SAFE, does not exceed 8 */
+   png_size_t num_checked = png_ptr->sig_bytes,
-   size_t num_to_check = 8 - num_checked;
+             num_to_check = 8 - num_checked;
 
    if (png_ptr->buffer_size < num_to_check)
    {
@@ -159,10 +163,10 @@ png_push_read_sig(png_structrp png_ptr, png_inforp info_ptr)
        num_to_check);
    png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check);
 
-   if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check) != 0)
+   if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
    {
       if (num_checked < 4 &&
-          png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4) != 0)
+          png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))
          png_error(png_ptr, "Not a PNG file");
 
       else
@@ -185,16 +189,29 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
    int keep; /* unknown handling method */
 #endif
 
-   /* First we make sure we have enough data for the 4-byte chunk name
+   /* First we make sure we have enough data for the 4 byte chunk name
-    * and the 4-byte chunk length before proceeding with decoding the
+    * and the 4 byte chunk length before proceeding with decoding the
     * chunk data.  To fully decode each of these chunks, we also make
-    * sure we have enough data in the buffer for the 4-byte CRC at the
+    * sure we have enough data in the buffer for the 4 byte CRC at the
     * end of every chunk (except IDAT, which is handled separately).
     */
-   if ((png_ptr->mode & PNG_HAVE_CHUNK_HEADER) == 0)
+   if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
    {
-      PNG_PUSH_SAVE_BUFFER_IF_LT(8)
+      png_byte chunk_length[4];
-      png_ptr->push_length = png_read_chunk_header(png_ptr);
+      png_byte chunk_tag[4];
+
+      if (png_ptr->buffer_size < 8)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_push_fill_buffer(png_ptr, chunk_length, 4);
+      png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
+      png_reset_crc(png_ptr);
+      png_crc_read(png_ptr, chunk_tag, 4);
+      png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(chunk_tag);
+      png_check_chunk_name(png_ptr, png_ptr->chunk_name);
       png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
    }
 
@@ -202,39 +219,28 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 
    if (chunk_name == png_IDAT)
    {
-      if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
+      if (png_ptr->mode & PNG_AFTER_IDAT)
          png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
 
       /* If we reach an IDAT chunk, this means we have read all of the
        * header chunks, and we can start reading the image (or if this
        * is called after the image has been read - we have an error).
        */
-      if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
+      if (!(png_ptr->mode & PNG_HAVE_IHDR))
          png_error(png_ptr, "Missing IHDR before IDAT");
 
       else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
-          (png_ptr->mode & PNG_HAVE_PLTE) == 0)
+          !(png_ptr->mode & PNG_HAVE_PLTE))
          png_error(png_ptr, "Missing PLTE before IDAT");
 
-      png_ptr->process_mode = PNG_READ_IDAT_MODE;
-
-      if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
-         if ((png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) == 0)
-            if (png_ptr->push_length == 0)
-               return;
-
       png_ptr->mode |= PNG_HAVE_IDAT;
 
-      if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
+      if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
-         png_benign_error(png_ptr, "Too many IDATs found");
+         if (png_ptr->push_length == 0)
-   }
+            return;
 
-   else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
+      if (png_ptr->mode & PNG_AFTER_IDAT)
-   {
+         png_benign_error(png_ptr, "Too many IDATs found");
-      /* These flags must be set consistently for all non-IDAT chunks,
-       * including the unknown chunks.
-       */
-      png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT | PNG_AFTER_IDAT;
    }
 
    if (chunk_name == png_IHDR)
@@ -242,14 +248,24 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
       if (png_ptr->push_length != 13)
          png_error(png_ptr, "Invalid IHDR length");
 
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
-      png_handle_chunk(png_ptr, info_ptr, png_ptr->push_length);
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);
    }
 
    else if (chunk_name == png_IEND)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
-      png_handle_chunk(png_ptr, info_ptr, png_ptr->push_length);
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);
 
       png_ptr->process_mode = PNG_READ_DONE_MODE;
       png_push_have_end(png_ptr, info_ptr);
@@ -258,13 +274,28 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
    else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length, keep);
 
       if (chunk_name == png_PLTE)
          png_ptr->mode |= PNG_HAVE_PLTE;
    }
+
 #endif
+   else if (chunk_name == png_PLTE)
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+      png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);
+   }
 
    else if (chunk_name == png_IDAT)
    {
@@ -278,17 +309,311 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
       return;
    }
 
+#ifdef PNG_READ_gAMA_SUPPORTED
+   else if (png_ptr->chunk_name == png_gAMA)
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_sBIT_SUPPORTED
+   else if (png_ptr->chunk_name == png_sBIT)
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_cHRM_SUPPORTED
+   else if (png_ptr->chunk_name == png_cHRM)
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_sRGB_SUPPORTED
+   else if (chunk_name == png_sRGB)
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_iCCP_SUPPORTED
+   else if (png_ptr->chunk_name == png_iCCP)
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_sPLT_SUPPORTED
+   else if (chunk_name == png_sPLT)
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_tRNS_SUPPORTED
+   else if (chunk_name == png_tRNS)
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_bKGD_SUPPORTED
+   else if (chunk_name == png_bKGD)
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_hIST_SUPPORTED
+   else if (chunk_name == png_hIST)
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_pHYs_SUPPORTED
+   else if (chunk_name == png_pHYs)
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_oFFs_SUPPORTED
+   else if (chunk_name == png_oFFs)
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);
+   }
+#endif
+
+#ifdef PNG_READ_pCAL_SUPPORTED
+   else if (chunk_name == png_pCAL)
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_sCAL_SUPPORTED
+   else if (chunk_name == png_sCAL)
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_tIME_SUPPORTED
+   else if (chunk_name == png_tIME)
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_tEXt_SUPPORTED
+   else if (chunk_name == png_tEXt)
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_zTXt_SUPPORTED
+   else if (chunk_name == png_zTXt)
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
+#ifdef PNG_READ_iTXt_SUPPORTED
+   else if (chunk_name == png_iTXt)
+   {
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);
+   }
+
+#endif
    else
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
-      png_handle_chunk(png_ptr, info_ptr, png_ptr->push_length);
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+      png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length,
+         PNG_HANDLE_CHUNK_AS_DEFAULT);
    }
 
    png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
 }
 
+void /* PRIVATE */
+png_push_crc_skip(png_structrp png_ptr, png_uint_32 skip)
+{
+   png_ptr->process_mode = PNG_SKIP_MODE;
+   png_ptr->skip_length = skip;
+}
+
+void /* PRIVATE */
+png_push_crc_finish(png_structrp png_ptr)
+{
+   if (png_ptr->skip_length && png_ptr->save_buffer_size)
+   {
+      png_size_t save_size = png_ptr->save_buffer_size;
+      png_uint_32 skip_length = png_ptr->skip_length;
+
+      /* We want the smaller of 'skip_length' and 'save_buffer_size', but
+       * they are of different types and we don't know which variable has the
+       * fewest bits.  Carefully select the smaller and cast it to the type of
+       * the larger - this cannot overflow.  Do not cast in the following test
+       * - it will break on either 16 or 64 bit platforms.
+       */
+      if (skip_length < save_size)
+         save_size = (png_size_t)skip_length;
+
+      else
+         skip_length = (png_uint_32)save_size;
+
+      png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
+
+      png_ptr->skip_length -= skip_length;
+      png_ptr->buffer_size -= save_size;
+      png_ptr->save_buffer_size -= save_size;
+      png_ptr->save_buffer_ptr += save_size;
+   }
+   if (png_ptr->skip_length && png_ptr->current_buffer_size)
+   {
+      png_size_t save_size = png_ptr->current_buffer_size;
+      png_uint_32 skip_length = png_ptr->skip_length;
+
+      /* We want the smaller of 'skip_length' and 'current_buffer_size', here,
+       * the same problem exists as above and the same solution.
+       */
+      if (skip_length < save_size)
+         save_size = (png_size_t)skip_length;
+
+      else
+         skip_length = (png_uint_32)save_size;
+
+      png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
+
+      png_ptr->skip_length -= skip_length;
+      png_ptr->buffer_size -= save_size;
+      png_ptr->current_buffer_size -= save_size;
+      png_ptr->current_buffer_ptr += save_size;
+   }
+   if (!png_ptr->skip_length)
+   {
+      if (png_ptr->buffer_size < 4)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      png_crc_finish(png_ptr, 0);
+      png_ptr->process_mode = PNG_READ_CHUNK_MODE;
+   }
+}
+
 void PNGCBAPI
-png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, size_t length)
+png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
 {
    png_bytep ptr;
 
@@ -296,9 +621,9 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, size_t length)
       return;
 
    ptr = buffer;
-   if (png_ptr->save_buffer_size != 0)
+   if (png_ptr->save_buffer_size)
    {
-      size_t save_size;
+      png_size_t save_size;
 
       if (length < png_ptr->save_buffer_size)
          save_size = length;
@@ -313,9 +638,9 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, size_t length)
       png_ptr->save_buffer_size -= save_size;
       png_ptr->save_buffer_ptr += save_size;
    }
-   if (length != 0 && png_ptr->current_buffer_size != 0)
+   if (length && png_ptr->current_buffer_size)
    {
-      size_t save_size;
+      png_size_t save_size;
 
       if (length < png_ptr->current_buffer_size)
          save_size = length;
@@ -333,11 +658,11 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, size_t length)
 void /* PRIVATE */
 png_push_save_buffer(png_structrp png_ptr)
 {
-   if (png_ptr->save_buffer_size != 0)
+   if (png_ptr->save_buffer_size)
    {
       if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)
       {
-         size_t i, istop;
+         png_size_t i, istop;
          png_bytep sp;
          png_bytep dp;
 
@@ -352,7 +677,7 @@ png_push_save_buffer(png_structrp png_ptr)
    if (png_ptr->save_buffer_size + png_ptr->current_buffer_size >
        png_ptr->save_buffer_max)
    {
-      size_t new_max;
+      png_size_t new_max;
       png_bytep old_buffer;
 
       if (png_ptr->save_buffer_size > PNG_SIZE_MAX -
@@ -364,7 +689,7 @@ png_push_save_buffer(png_structrp png_ptr)
       new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;
       old_buffer = png_ptr->save_buffer;
       png_ptr->save_buffer = (png_bytep)png_malloc_warn(png_ptr,
-          (size_t)new_max);
+          (png_size_t)new_max);
 
       if (png_ptr->save_buffer == NULL)
       {
@@ -372,10 +697,7 @@ png_push_save_buffer(png_structrp png_ptr)
          png_error(png_ptr, "Insufficient memory for save_buffer");
       }
 
-      if (old_buffer)
+      memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);
-         memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);
-      else if (png_ptr->save_buffer_size)
-         png_error(png_ptr, "save_buffer error");
       png_free(png_ptr, old_buffer);
       png_ptr->save_buffer_max = new_max;
    }
@@ -392,7 +714,7 @@ png_push_save_buffer(png_structrp png_ptr)
 
 void /* PRIVATE */
 png_push_restore_buffer(png_structrp png_ptr, png_bytep buffer,
-    size_t buffer_length)
+   png_size_t buffer_length)
 {
    png_ptr->current_buffer = buffer;
    png_ptr->current_buffer_size = buffer_length;
@@ -403,13 +725,18 @@ png_push_restore_buffer(png_structrp png_ptr, png_bytep buffer,
 void /* PRIVATE */
 png_push_read_IDAT(png_structrp png_ptr)
 {
-   if ((png_ptr->mode & PNG_HAVE_CHUNK_HEADER) == 0)
+   if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
    {
       png_byte chunk_length[4];
       png_byte chunk_tag[4];
 
       /* TODO: this code can be commoned up with the same code in push_read */
-      PNG_PUSH_SAVE_BUFFER_IF_LT(8)
+      if (png_ptr->buffer_size < 8)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_push_fill_buffer(png_ptr, chunk_length, 4);
       png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
       png_reset_crc(png_ptr);
@@ -421,7 +748,7 @@ png_push_read_IDAT(png_structrp png_ptr)
       {
          png_ptr->process_mode = PNG_READ_CHUNK_MODE;
 
-         if ((png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED) == 0)
+         if (!(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
             png_error(png_ptr, "Not enough compressed data");
 
          return;
@@ -430,19 +757,19 @@ png_push_read_IDAT(png_structrp png_ptr)
       png_ptr->idat_size = png_ptr->push_length;
    }
 
-   if (png_ptr->idat_size != 0 && png_ptr->save_buffer_size != 0)
+   if (png_ptr->idat_size && png_ptr->save_buffer_size)
    {
-      size_t save_size = png_ptr->save_buffer_size;
+      png_size_t save_size = png_ptr->save_buffer_size;
       png_uint_32 idat_size = png_ptr->idat_size;
 
       /* We want the smaller of 'idat_size' and 'current_buffer_size', but they
        * are of different types and we don't know which variable has the fewest
        * bits.  Carefully select the smaller and cast it to the type of the
        * larger - this cannot overflow.  Do not cast in the following test - it
-       * will break on either 16-bit or 64-bit platforms.
+       * will break on either 16 or 64 bit platforms.
        */
       if (idat_size < save_size)
-         save_size = (size_t)idat_size;
+         save_size = (png_size_t)idat_size;
 
       else
          idat_size = (png_uint_32)save_size;
@@ -457,9 +784,9 @@ png_push_read_IDAT(png_structrp png_ptr)
       png_ptr->save_buffer_ptr += save_size;
    }
 
-   if (png_ptr->idat_size != 0 && png_ptr->current_buffer_size != 0)
+   if (png_ptr->idat_size && png_ptr->current_buffer_size)
    {
-      size_t save_size = png_ptr->current_buffer_size;
+      png_size_t save_size = png_ptr->current_buffer_size;
       png_uint_32 idat_size = png_ptr->idat_size;
 
       /* We want the smaller of 'idat_size' and 'current_buffer_size', but they
@@ -468,7 +795,7 @@ png_push_read_IDAT(png_structrp png_ptr)
        * larger - this cannot overflow.
        */
       if (idat_size < save_size)
-         save_size = (size_t)idat_size;
+         save_size = (png_size_t)idat_size;
 
       else
          idat_size = (png_uint_32)save_size;
@@ -482,10 +809,14 @@ png_push_read_IDAT(png_structrp png_ptr)
       png_ptr->current_buffer_size -= save_size;
       png_ptr->current_buffer_ptr += save_size;
    }
-
+   if (!png_ptr->idat_size)
-   if (png_ptr->idat_size == 0)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_LT(4)
+      if (png_ptr->buffer_size < 4)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_crc_finish(png_ptr, 0);
       png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
       png_ptr->mode |= PNG_AFTER_IDAT;
@@ -495,7 +826,7 @@ png_push_read_IDAT(png_structrp png_ptr)
 
 void /* PRIVATE */
 png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer,
-    size_t buffer_length)
+   png_size_t buffer_length)
 {
    /* The caller checks for a non-zero buffer length. */
    if (!(buffer_length > 0) || buffer == NULL)
@@ -513,7 +844,7 @@ png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer,
     * or the stream marked as finished.
     */
    while (png_ptr->zstream.avail_in > 0 &&
-      (png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED) == 0)
+      !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
    {
       int ret;
 
@@ -538,7 +869,7 @@ png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer,
        * change the current behavior (see comments in inflate.c
        * for why this doesn't happen at present with zlib 1.2.5).
        */
-      ret = PNG_INFLATE(png_ptr, Z_SYNC_FLUSH);
+      ret = inflate(&png_ptr->zstream, Z_SYNC_FLUSH);
 
       /* Check for any failure before proceeding. */
       if (ret != Z_OK && ret != Z_STREAM_END)
@@ -555,12 +886,7 @@ png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer,
             png_warning(png_ptr, "Truncated compressed data in IDAT");
 
          else
-         {
+            png_error(png_ptr, "Decompression error in IDAT");
-            if (ret == Z_DATA_ERROR)
-               png_benign_error(png_ptr, "IDAT: ADLER32 checksum mismatch");
-            else
-               png_error(png_ptr, "Decompression error in IDAT");
-         }
 
          /* Skip the check on unprocessed input */
          return;
@@ -635,7 +961,7 @@ png_push_process_row(png_structrp png_ptr)
    memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);
 
 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
-   if (png_ptr->transformations != 0)
+   if (png_ptr->transformations)
       png_do_read_transformations(png_ptr, &row_info);
 #endif
 
@@ -652,16 +978,15 @@ png_push_process_row(png_structrp png_ptr)
 
 
 #ifdef PNG_READ_INTERLACING_SUPPORTED
-   /* Expand interlaced rows to full size */
+   /* Blow up interlaced rows to full size */
-   if (png_ptr->interlaced != 0 &&
+   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
-       (png_ptr->transformations & PNG_INTERLACE) != 0)
    {
       if (png_ptr->pass < 6)
          png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,
-             png_ptr->transformations);
+            png_ptr->transformations);
 
-      switch (png_ptr->pass)
+    switch (png_ptr->pass)
-      {
+    {
          case 0:
          {
             int i;
@@ -838,12 +1163,33 @@ png_push_process_row(png_structrp png_ptr)
 void /* PRIVATE */
 png_read_push_finish_row(png_structrp png_ptr)
 {
+#ifdef PNG_READ_INTERLACING_SUPPORTED
+   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+   /* Start of interlace block */
+   static PNG_CONST png_byte png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
+
+   /* Offset to next interlace block */
+   static PNG_CONST png_byte png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
+
+   /* Start of interlace block in the y direction */
+   static PNG_CONST png_byte png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
+
+   /* Offset to next interlace block in the y direction */
+   static PNG_CONST png_byte png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
+
+   /* Height of interlace block.  This is not currently used - if you need
+    * it, uncomment it here and in png.h
+   static PNG_CONST png_byte png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
+   */
+#endif
+
    png_ptr->row_number++;
    if (png_ptr->row_number < png_ptr->num_rows)
       return;
 
 #ifdef PNG_READ_INTERLACING_SUPPORTED
-   if (png_ptr->interlaced != 0)
+   if (png_ptr->interlaced)
    {
       png_ptr->row_number = 0;
       memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
@@ -867,7 +1213,7 @@ png_read_push_finish_row(png_structrp png_ptr)
              png_pass_start[png_ptr->pass]) /
              png_pass_inc[png_ptr->pass];
 
-         if ((png_ptr->transformations & PNG_INTERLACE) != 0)
+         if (png_ptr->transformations & PNG_INTERLACE)
             break;
 
          png_ptr->num_rows = (png_ptr->height +
@@ -877,7 +1223,7 @@ png_read_push_finish_row(png_structrp png_ptr)
 
       } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);
    }
-#endif /* READ_INTERLACING */
+#endif /* PNG_READ_INTERLACING_SUPPORTED */
 }
 
 void /* PRIVATE */
@@ -899,7 +1245,7 @@ png_push_have_row(png_structrp png_ptr, png_bytep row)
 {
    if (png_ptr->row_fn != NULL)
       (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,
-          (int)png_ptr->pass);
+         (int)png_ptr->pass);
 }
 
 #ifdef PNG_READ_INTERLACING_SUPPORTED
@@ -915,9 +1261,9 @@ png_progressive_combine_row(png_const_structrp png_ptr, png_bytep old_row,
     * it must be png_ptr->row_buf+1
     */
    if (new_row != NULL)
-      png_combine_row(png_ptr, old_row, 1/*blocky display*/);
+      png_combine_row(png_ptr, old_row, 1/*display*/);
 }
-#endif /* READ_INTERLACING */
+#endif /* PNG_READ_INTERLACING_SUPPORTED */
 
 void PNGAPI
 png_set_progressive_read_fn(png_structrp png_ptr, png_voidp progressive_ptr,
@@ -938,8 +1284,8 @@ png_voidp PNGAPI
 png_get_progressive_ptr(png_const_structrp png_ptr)
 {
    if (png_ptr == NULL)
-      return NULL;
+      return (NULL);
 
    return png_ptr->io_ptr;
 }
-#endif /* PROGRESSIVE_READ */
+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

Windows_Libs/Dev/Render/libpng/pngrio.c

@@ -1,9 +1,10 @@
+
 /* pngrio.c - functions for data input
  *
- * Copyright (c) 2018-2025 Cosmin Truta
+ * Last changed in libpng 1.6.0 [February 14, 2013]
- * Copyright (c) 1998-2002,2004,2006-2016,2018 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 Glenn Randers-Pehrson
- * Copyright (c) 1996-1997 Andreas Dilger
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -25,10 +26,10 @@
  * reads from a file pointer.  Note that this routine sometimes gets called
  * with very small lengths, so you should implement some kind of simple
  * buffering if you are using unbuffered reads.  This should never be asked
- * to read more than 64K on a 16-bit machine.
+ * to read more then 64K on a 16 bit machine.
  */
 void /* PRIVATE */
-png_read_data(png_structrp png_ptr, png_bytep data, size_t length)
+png_read_data(png_structrp png_ptr, png_bytep data, png_size_t length)
 {
    png_debug1(4, "reading %d bytes", (int)length);
 
@@ -46,17 +47,17 @@ png_read_data(png_structrp png_ptr, png_bytep data, size_t length)
  * than changing the library.
  */
 void PNGCBAPI
-png_default_read_data(png_structp png_ptr, png_bytep data, size_t length)
+png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
 {
-   size_t check;
+   png_size_t check;
 
    if (png_ptr == NULL)
       return;
 
-   /* fread() returns 0 on error, so it is OK to store this in a size_t
+   /* fread() returns 0 on error, so it is OK to store this in a png_size_t
     * instead of an int, which is what fread() actually returns.
     */
-   check = fread(data, 1, length, png_voidcast(FILE *, png_ptr->io_ptr));
+   check = fread(data, 1, length, png_voidcast(png_FILE_p, png_ptr->io_ptr));
 
    if (check != length)
       png_error(png_ptr, "Read Error");
@@ -84,7 +85,7 @@ png_default_read_data(png_structp png_ptr, png_bytep data, size_t length)
  */
 void PNGAPI
 png_set_read_fn(png_structrp png_ptr, png_voidp io_ptr,
-    png_rw_ptr read_data_fn)
+   png_rw_ptr read_data_fn)
 {
    if (png_ptr == NULL)
       return;
@@ -101,7 +102,6 @@ png_set_read_fn(png_structrp png_ptr, png_voidp io_ptr,
    png_ptr->read_data_fn = read_data_fn;
 #endif
 
-#ifdef PNG_WRITE_SUPPORTED
    /* It is an error to write to a read device */
    if (png_ptr->write_data_fn != NULL)
    {
@@ -110,10 +110,9 @@ png_set_read_fn(png_structrp png_ptr, png_voidp io_ptr,
           "Can't set both read_data_fn and write_data_fn in the"
           " same structure");
    }
-#endif
 
 #ifdef PNG_WRITE_FLUSH_SUPPORTED
    png_ptr->output_flush_fn = NULL;
 #endif
 }
-#endif /* READ */
+#endif /* PNG_READ_SUPPORTED */

Windows_Libs/Dev/Render/libpng/pngstruct.h

@@ -1,18 +1,22 @@
-/* pngstruct.h - internal structures for libpng
+
+/* pngstruct.h - header file for PNG reference library
  *
- * Copyright (c) 2018-2025 Cosmin Truta
+ * Copyright (c) 1998-2013 Glenn Randers-Pehrson
- * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * Copyright (c) 1996-1997 Andreas Dilger
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
- * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ *
+ * Last changed in libpng 1.6.1 [March 28, 2013]
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
  * and license in png.h
  */
 
-#ifndef PNGPRIV_H
+/* The structure that holds the information to read and write PNG files.
-#  error This file must not be included by applications; please include <png.h>
+ * The only people who need to care about what is inside of this are the
-#endif
+ * people who will be modifying the library for their own special needs.
+ * It should NOT be accessed directly by an application.
+ */
 
 #ifndef PNGSTRUCT_H
 #define PNGSTRUCT_H
@@ -44,7 +48,7 @@
 /* zlib.h declares a magic type 'uInt' that limits the amount of data that zlib
  * can handle at once.  This type need be no larger than 16 bits (so maximum of
  * 65535), this define allows us to discover how big it is, but limited by the
- * maximum for size_t.  The value can be overridden in a library build
+ * maximuum for png_size_t.  The value can be overriden in a library build
  * (pngusr.h, or set it in CPPFLAGS) and it works to set it to a considerably
  * lower value (e.g. 255 works).  A lower value may help memory usage (slightly)
  * and may even improve performance on some systems (and degrade it on others.)
@@ -67,7 +71,13 @@ typedef struct png_compression_buffer
 
 /* Colorspace support; structures used in png_struct, png_info and in internal
  * functions to hold and communicate information about the color space.
+ *
+ * PNG_COLORSPACE_SUPPORTED is only required if the application will perform
+ * colorspace corrections, otherwise all the colorspace information can be
+ * skipped and the size of libpng can be reduced (significantly) by compiling
+ * out the colorspace support.
  */
+#ifdef PNG_COLORSPACE_SUPPORTED
 /* The chromaticities of the red, green and blue colorants and the chromaticity
  * of the corresponding white point (i.e. of rgb(1.0,1.0,1.0)).
  */
@@ -88,36 +98,48 @@ typedef struct png_XYZ
    png_fixed_point green_X, green_Y, green_Z;
    png_fixed_point blue_X, blue_Y, blue_Z;
 } png_XYZ;
+#endif /* COLORSPACE */
 
-/* Chunk index values as an enum, PNG_INDEX_unknown is also a count of the
+#if defined(PNG_COLORSPACE_SUPPORTED) || defined(PNG_GAMMA_SUPPORTED)
- * number of chunks.
+/* A colorspace is all the above plus, potentially, profile information,
- */
+ * however at present libpng does not use the profile internally so it is only
-#define PNG_CHUNK(cHNK, i) PNG_INDEX_ ## cHNK = (i),
+ * stored in the png_info struct (if iCCP is supported.)  The rendering intent
-typedef enum
+ * is retained here and is checked.
-{
-   PNG_KNOWN_CHUNKS
-   PNG_INDEX_unknown
-} png_index;
-#undef PNG_CHUNK
-
-/* Chunk flag values.  These are (png_uint_32 values) with exactly one bit set
- * and can be combined into a flag set with bitwise 'or'.
  *
- * TODO: C23: convert these macros to C23 inlines (which are static).
+ * The file gamma encoding information is also stored here and gamma correction
+ * is done by libpng, whereas color correction must currently be done by the
+ * application.
  */
-#define png_chunk_flag_from_index(i) (0x80000000U >> (31 - (i)))
+typedef struct png_colorspace
-   /* The flag coresponding to the given png_index enum value.  This is defined
+{
-    * for png_unknown as well (until it reaches the value 32) but this should
+#ifdef PNG_GAMMA_SUPPORTED
-    * not be relied on.
+   png_fixed_point gamma;        /* File gamma */
-    */
+#endif
 
-#define png_file_has_chunk(png_ptr, i)\
+#ifdef PNG_COLORSPACE_SUPPORTED
-   (((png_ptr)->chunks & png_chunk_flag_from_index(i)) != 0)
+   png_xy      end_points_xy;    /* End points as chromaticities */
-   /* The chunk has been recorded in png_struct */
+   png_XYZ     end_points_XYZ;   /* End points as CIE XYZ colorant values */
+   png_uint_16 rendering_intent; /* Rendering intent of a profile */
+#endif
 
-#define png_file_add_chunk(pnt_ptr, i)\
+   /* Flags are always defined to simplify the code. */
-   ((void)((png_ptr)->chunks |= png_chunk_flag_from_index(i)))
+   png_uint_16 flags;            /* As defined below */
-   /* Record the chunk in the png_struct */
+} png_colorspace, * PNG_RESTRICT png_colorspacerp;
+
+typedef const png_colorspace * PNG_RESTRICT png_const_colorspacerp;
+
+/* General flags for the 'flags' field */
+#define PNG_COLORSPACE_HAVE_GAMMA           0x0001
+#define PNG_COLORSPACE_HAVE_ENDPOINTS       0x0002
+#define PNG_COLORSPACE_HAVE_INTENT          0x0004
+#define PNG_COLORSPACE_FROM_gAMA            0x0008
+#define PNG_COLORSPACE_FROM_cHRM            0x0010
+#define PNG_COLORSPACE_FROM_sRGB            0x0020
+#define PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB 0x0040
+#define PNG_COLORSPACE_MATCHES_sRGB         0x0080 /* exact match on profile */
+#define PNG_COLORSPACE_INVALID              0x8000
+#define PNG_COLORSPACE_CANCEL(flags)        (0xffff ^ (flags))
+#endif /* COLORSPACE || GAMMA */
 
 struct png_struct_def
 {
@@ -189,34 +211,27 @@ struct png_struct_def
    int zlib_set_strategy;
 #endif
 
-   png_uint_32 chunks; /* PNG_CF_ for every chunk read or (NYI) written */
-#  define png_has_chunk(png_ptr, cHNK)\
-      png_file_has_chunk(png_ptr, PNG_INDEX_ ## cHNK)
-      /* Convenience accessor - use this to check for a known chunk by name */
-
    png_uint_32 width;         /* width of image in pixels */
    png_uint_32 height;        /* height of image in pixels */
    png_uint_32 num_rows;      /* number of rows in current pass */
    png_uint_32 usr_width;     /* width of row at start of write */
-   size_t rowbytes;           /* size of row in bytes */
+   png_size_t rowbytes;       /* size of row in bytes */
    png_uint_32 iwidth;        /* width of current interlaced row in pixels */
    png_uint_32 row_number;    /* current row in interlace pass */
    png_uint_32 chunk_name;    /* PNG_CHUNK() id of current chunk */
    png_bytep prev_row;        /* buffer to save previous (unfiltered) row.
-                               * While reading this is a pointer into
+                               * This is a pointer into big_prev_row
-                               * big_prev_row; while writing it is separately
-                               * allocated if needed.
                                */
    png_bytep row_buf;         /* buffer to save current (unfiltered) row.
-                               * While reading, this is a pointer into
+                               * This is a pointer into big_row_buf
-                               * big_row_buf; while writing it is separately
-                               * allocated.
                                */
-#ifdef PNG_WRITE_FILTER_SUPPORTED
+#ifdef PNG_WRITE_SUPPORTED
-   png_bytep try_row;    /* buffer to save trial row when filtering */
+   png_bytep sub_row;         /* buffer to save "sub" row when filtering */
-   png_bytep tst_row;    /* buffer to save best trial row when filtering */
+   png_bytep up_row;          /* buffer to save "up" row when filtering */
+   png_bytep avg_row;         /* buffer to save "avg" row when filtering */
+   png_bytep paeth_row;       /* buffer to save "Paeth" row when filtering */
 #endif
-   size_t info_rowbytes;      /* Added in 1.5.4: cache of updated row bytes */
+   png_size_t info_rowbytes;  /* Added in 1.5.4: cache of updated row bytes */
 
    png_uint_32 idat_size;     /* current IDAT size for read */
    png_uint_32 crc;           /* current chunk CRC value */
@@ -233,7 +248,7 @@ struct png_struct_def
    png_byte filter;           /* file filter type (always 0) */
    png_byte interlaced;       /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */
    png_byte pass;             /* current interlace pass (0 - 6) */
-   png_byte do_filter;        /* row filter flags (see PNG_FILTER_ in png.h ) */
+   png_byte do_filter;        /* row filter flags (see PNG_FILTER_ below ) */
    png_byte color_type;       /* color type of file */
    png_byte bit_depth;        /* bit depth of file */
    png_byte usr_bit_depth;    /* bit depth of users row: write only */
@@ -247,9 +262,6 @@ struct png_struct_def
                               /* pixel depth used for the row buffers */
    png_byte transformed_pixel_depth;
                               /* pixel depth after read/write transforms */
-#if ZLIB_VERNUM >= 0x1240
-   png_byte zstream_start;    /* at start of an input zlib stream */
-#endif /* Zlib >= 1.2.4 */
 #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
    png_uint_16 filler;           /* filler bytes for pixel expansion */
 #endif
@@ -262,7 +274,7 @@ struct png_struct_def
 #ifdef PNG_READ_GAMMA_SUPPORTED
    png_color_16 background_1; /* background normalized to gamma 1.0 */
 #endif
-#endif /* bKGD */
+#endif /* PNG_bKGD_SUPPORTED */
 
 #ifdef PNG_WRITE_FLUSH_SUPPORTED
    png_flush_ptr output_flush_fn; /* Function for flushing output */
@@ -270,16 +282,9 @@ struct png_struct_def
    png_uint_32 flush_rows;    /* number of rows written since last flush */
 #endif
 
-#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
-   png_xy          chromaticities; /* From mDVC, cICP, [iCCP], sRGB or cHRM */
-#endif
-
 #ifdef PNG_READ_GAMMA_SUPPORTED
    int gamma_shift;      /* number of "insignificant" bits in 16-bit gamma */
-   png_fixed_point screen_gamma; /* screen gamma value (display exponent) */
+   png_fixed_point screen_gamma; /* screen gamma value (display_exponent) */
-   png_fixed_point file_gamma;   /* file gamma value (encoding exponent) */
-   png_fixed_point chunk_gamma;  /* from cICP, iCCP, sRGB or gAMA */
-   png_fixed_point default_gamma;/* from png_set_alpha_mode */
 
    png_bytep gamma_table;     /* gamma table for 8-bit depth files */
    png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */
@@ -291,14 +296,14 @@ struct png_struct_def
    png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */
    png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */
 #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
-#endif /* READ_GAMMA */
+#endif
 
 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED)
    png_color_8 sig_bit;       /* significant bits in each available channel */
 #endif
 
 #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
-   png_color_8 shift;         /* shift for significant bit transformation */
+   png_color_8 shift;         /* shift for significant bit tranformation */
 #endif
 
 #if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \
@@ -319,30 +324,50 @@ struct png_struct_def
    png_bytep current_buffer;         /* buffer for recently used data */
    png_uint_32 push_length;          /* size of current input chunk */
    png_uint_32 skip_length;          /* bytes to skip in input data */
-   size_t save_buffer_size;          /* amount of data now in save_buffer */
+   png_size_t save_buffer_size;      /* amount of data now in save_buffer */
-   size_t save_buffer_max;           /* total size of save_buffer */
+   png_size_t save_buffer_max;       /* total size of save_buffer */
-   size_t buffer_size;               /* total amount of available input data */
+   png_size_t buffer_size;           /* total amount of available input data */
-   size_t current_buffer_size;       /* amount of data now in current_buffer */
+   png_size_t current_buffer_size;   /* amount of data now in current_buffer */
    int process_mode;                 /* what push library is currently doing */
    int cur_palette;                  /* current push library palette index */
-#endif /* PROGRESSIVE_READ */
+
+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
+
+#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
+/* For the Borland special 64K segment handler */
+   png_bytepp offset_table_ptr;
+   png_bytep offset_table;
+   png_uint_16 offset_table_number;
+   png_uint_16 offset_table_count;
+   png_uint_16 offset_table_count_free;
+#endif
 
 #ifdef PNG_READ_QUANTIZE_SUPPORTED
    png_bytep palette_lookup; /* lookup table for quantizing */
    png_bytep quantize_index; /* index translation for palette files */
 #endif
 
-/* Options */
+#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
+   png_byte heuristic_method;        /* heuristic for row filter selection */
+   png_byte num_prev_filters;        /* number of weights for previous rows */
+   png_bytep prev_filters;           /* filter type(s) of previous row(s) */
+   png_uint_16p filter_weights;      /* weight(s) for previous line(s) */
+   png_uint_16p inv_filter_weights;  /* 1/weight(s) for previous line(s) */
+   png_uint_16p filter_costs;        /* relative filter calculation cost */
+   png_uint_16p inv_filter_costs;    /* 1/relative filter calculation cost */
+#endif
+
+   /* Options */
 #ifdef PNG_SET_OPTION_SUPPORTED
-   png_uint_32 options;           /* On/off state (up to 16 options) */
+   png_byte options;           /* On/off state (up to 4 options) */
 #endif
 
 #if PNG_LIBPNG_VER < 10700
 /* To do: remove this from libpng-1.7 */
 #ifdef PNG_TIME_RFC1123_SUPPORTED
    char time_buffer[29]; /* String to hold RFC 1123 time text */
-#endif /* TIME_RFC1123 */
+#endif
-#endif /* LIBPNG_VER < 10700 */
+#endif
 
 /* New members added in libpng-1.0.6 */
 
@@ -352,8 +377,8 @@ struct png_struct_def
    png_voidp user_chunk_ptr;
 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
    png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */
-#endif /* READ_USER_CHUNKS */
+#endif
-#endif /* USER_CHUNKS */
+#endif
 
 #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
    int          unknown_default; /* As PNG_HANDLE_* */
@@ -373,13 +398,6 @@ struct png_struct_def
    /* deleted in 1.5.5: rgb_to_gray_blue_coeff; */
 #endif
 
-/* New member added in libpng-1.6.36 */
-#if defined(PNG_READ_EXPAND_SUPPORTED) && \
-    (defined(PNG_ARM_NEON_IMPLEMENTATION) || \
-     defined(PNG_RISCV_RVV_IMPLEMENTATION))
-   png_bytep riffled_palette; /* buffer for accelerated palette expansion */
-#endif
-
 /* New member added in libpng-1.0.4 (renamed in 1.0.9) */
 #if defined(PNG_MNG_FEATURES_SUPPORTED)
 /* Changed from png_byte to png_uint_32 at version 1.2.0 */
@@ -405,6 +423,7 @@ struct png_struct_def
 
 #ifdef PNG_READ_QUANTIZE_SUPPORTED
 /* The following three members were added at version 1.0.14 and 1.2.4 */
+   png_bytep quantize_sort;          /* working sort array */
    png_bytep index_to_palette;       /* where the original index currently is
                                         in the palette */
    png_bytep palette_to_index;       /* which original index points to this
@@ -438,7 +457,7 @@ struct png_struct_def
 #endif
 
 /* New member added in libpng-1.2.26 */
-   size_t old_big_row_buf_size;
+  png_size_t old_big_row_buf_size;
 
 #ifdef PNG_READ_SUPPORTED
 /* New member added in libpng-1.2.30 */
@@ -460,5 +479,11 @@ struct png_struct_def
 /* New member added in libpng-1.5.7 */
    void (*read_filter[PNG_FILTER_VALUE_LAST-1])(png_row_infop row_info,
       png_bytep row, png_const_bytep prev_row);
+
+#ifdef PNG_READ_SUPPORTED
+#if defined(PNG_COLORSPACE_SUPPORTED) || defined(PNG_GAMMA_SUPPORTED)
+   png_colorspace   colorspace;
+#endif
+#endif
 };
 #endif /* PNGSTRUCT_H */

Windows_Libs/Dev/Render/libpng/pngtrans.c

@@ -1,9 +1,10 @@
+
 /* pngtrans.c - transforms the data in a row (used by both readers and writers)
  *
- * Copyright (c) 2018-2024 Cosmin Truta
+ * Last changed in libpng 1.6.2 [April 25, 2013]
- * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 Glenn Randers-Pehrson
- * Copyright (c) 1996-1997 Andreas Dilger
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -29,7 +30,7 @@ png_set_bgr(png_structrp png_ptr)
 #endif
 
 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
-/* Turn on 16-bit byte swapping */
+/* Turn on 16 bit byte swapping */
 void PNGAPI
 png_set_swap(png_structrp png_ptr)
 {
@@ -56,9 +57,7 @@ png_set_packing(png_structrp png_ptr)
    if (png_ptr->bit_depth < 8)
    {
       png_ptr->transformations |= PNG_PACK;
-#     ifdef PNG_WRITE_SUPPORTED
+      png_ptr->usr_bit_depth = 8;
-         png_ptr->usr_bit_depth = 8;
-#     endif
    }
 }
 #endif
@@ -99,13 +98,13 @@ png_set_interlace_handling(png_structrp png_ptr)
 {
    png_debug(1, "in png_set_interlace handling");
 
-   if (png_ptr != 0 && png_ptr->interlaced != 0)
+   if (png_ptr && png_ptr->interlaced)
    {
       png_ptr->transformations |= PNG_INTERLACE;
-      return 7;
+      return (7);
    }
 
-   return 1;
+   return (1);
 }
 #endif
 
@@ -126,7 +125,7 @@ png_set_filler(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
    /* In libpng 1.6 it is possible to determine whether this is a read or write
     * operation and therefore to do more checking here for a valid call.
     */
-   if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
+   if (png_ptr->mode & PNG_IS_READ_STRUCT)
    {
 #     ifdef PNG_READ_FILLER_SUPPORTED
          /* On read png_set_filler is always valid, regardless of the base PNG
@@ -171,14 +170,13 @@ png_set_filler(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
                    * size!
                    */
                   png_app_error(png_ptr,
-                      "png_set_filler is invalid for"
+                     "png_set_filler is invalid for low bit depth gray output");
-                      " low bit depth gray output");
                   return;
                }
 
             default:
                png_app_error(png_ptr,
-                   "png_set_filler: inappropriate color type");
+                  "png_set_filler: inappropriate color type");
                return;
          }
 #     else
@@ -210,7 +208,7 @@ png_set_add_alpha(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
 
    png_set_filler(png_ptr, filler, filler_loc);
    /* The above may fail to do anything. */
-   if ((png_ptr->transformations & PNG_FILLER) != 0)
+   if (png_ptr->transformations & PNG_FILLER)
       png_ptr->transformations |= PNG_ADD_ALPHA;
 }
 
@@ -268,8 +266,8 @@ png_do_invert(png_row_infop row_info, png_bytep row)
    if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
    {
       png_bytep rp = row;
-      size_t i;
+      png_size_t i;
-      size_t istop = row_info->rowbytes;
+      png_size_t istop = row_info->rowbytes;
 
       for (i = 0; i < istop; i++)
       {
@@ -282,8 +280,8 @@ png_do_invert(png_row_infop row_info, png_bytep row)
       row_info->bit_depth == 8)
    {
       png_bytep rp = row;
-      size_t i;
+      png_size_t i;
-      size_t istop = row_info->rowbytes;
+      png_size_t istop = row_info->rowbytes;
 
       for (i = 0; i < istop; i += 2)
       {
@@ -297,8 +295,8 @@ png_do_invert(png_row_infop row_info, png_bytep row)
       row_info->bit_depth == 16)
    {
       png_bytep rp = row;
-      size_t i;
+      png_size_t i;
-      size_t istop = row_info->rowbytes;
+      png_size_t istop = row_info->rowbytes;
 
       for (i = 0; i < istop; i += 4)
       {
@@ -313,7 +311,7 @@ png_do_invert(png_row_infop row_info, png_bytep row)
 
 #ifdef PNG_16BIT_SUPPORTED
 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
-/* Swaps byte order on 16-bit depth images */
+/* Swaps byte order on 16 bit depth images */
 void /* PRIVATE */
 png_do_swap(png_row_infop row_info, png_bytep row)
 {
@@ -327,16 +325,9 @@ png_do_swap(png_row_infop row_info, png_bytep row)
 
       for (i = 0; i < istop; i++, rp += 2)
       {
-#ifdef PNG_BUILTIN_BSWAP16_SUPPORTED
-         /* Feature added to libpng-1.6.11 for testing purposes, not
-          * enabled by default.
-          */
-         *(png_uint_16*)rp = __builtin_bswap16(*(png_uint_16*)rp);
-#else
          png_byte t = *rp;
          *rp = *(rp + 1);
          *(rp + 1) = t;
-#endif
       }
    }
 }
@@ -344,7 +335,7 @@ png_do_swap(png_row_infop row_info, png_bytep row)
 #endif
 
 #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
-static const png_byte onebppswaptable[256] = {
+static PNG_CONST png_byte onebppswaptable[256] = {
    0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
    0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
    0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
@@ -379,7 +370,7 @@ static const png_byte onebppswaptable[256] = {
    0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
 };
 
-static const png_byte twobppswaptable[256] = {
+static PNG_CONST png_byte twobppswaptable[256] = {
    0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
    0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
    0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
@@ -414,7 +405,7 @@ static const png_byte twobppswaptable[256] = {
    0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
 };
 
-static const png_byte fourbppswaptable[256] = {
+static PNG_CONST png_byte fourbppswaptable[256] = {
    0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
    0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
    0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
@@ -478,7 +469,7 @@ png_do_packswap(png_row_infop row_info, png_bytep row)
          *rp = table[*rp];
    }
 }
-#endif /* PACKSWAP || WRITE_PACKSWAP */
+#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */
 
 #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
     defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
@@ -497,8 +488,6 @@ png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)
    png_bytep dp = row; /* destination pointer */
    png_bytep ep = row + row_info->rowbytes; /* One beyond end of row */
 
-   png_debug(1, "in png_do_strip_channel");
-
    /* At the start sp will point to the first byte to copy and dp to where
     * it is copied to.  ep always points just beyond the end of the row, so
     * the loop simply copies (channels-1) channels until sp reaches ep.
@@ -512,35 +501,27 @@ png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)
    {
       if (row_info->bit_depth == 8)
       {
-         if (at_start != 0) /* Skip initial filler */
+         if (at_start) /* Skip initial filler */
             ++sp;
          else          /* Skip initial channel and, for sp, the filler */
-         {
+            sp += 2, ++dp;
-            sp += 2; ++dp;
-         }
 
          /* For a 1 pixel wide image there is nothing to do */
          while (sp < ep)
-         {
+            *dp++ = *sp, sp += 2;
-            *dp++ = *sp; sp += 2;
-         }
 
          row_info->pixel_depth = 8;
       }
 
       else if (row_info->bit_depth == 16)
       {
-         if (at_start != 0) /* Skip initial filler */
+         if (at_start) /* Skip initial filler */
             sp += 2;
          else          /* Skip initial channel and, for sp, the filler */
-         {
+            sp += 4, dp += 2;
-            sp += 4; dp += 2;
-         }
 
          while (sp < ep)
-         {
+            *dp++ = *sp++, *dp++ = *sp, sp += 3;
-            *dp++ = *sp++; *dp++ = *sp; sp += 3;
-         }
 
          row_info->pixel_depth = 16;
       }
@@ -560,37 +541,31 @@ png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)
    {
       if (row_info->bit_depth == 8)
       {
-         if (at_start != 0) /* Skip initial filler */
+         if (at_start) /* Skip initial filler */
             ++sp;
          else          /* Skip initial channels and, for sp, the filler */
-         {
+            sp += 4, dp += 3;
-            sp += 4; dp += 3;
-         }
 
          /* Note that the loop adds 3 to dp and 4 to sp each time. */
          while (sp < ep)
-         {
+            *dp++ = *sp++, *dp++ = *sp++, *dp++ = *sp, sp += 2;
-            *dp++ = *sp++; *dp++ = *sp++; *dp++ = *sp; sp += 2;
-         }
 
          row_info->pixel_depth = 24;
       }
 
       else if (row_info->bit_depth == 16)
       {
-         if (at_start != 0) /* Skip initial filler */
+         if (at_start) /* Skip initial filler */
             sp += 2;
          else          /* Skip initial channels and, for sp, the filler */
-         {
+            sp += 8, dp += 6;
-            sp += 8; dp += 6;
-         }
 
          while (sp < ep)
          {
             /* Copy 6 bytes, skip 2 */
-            *dp++ = *sp++; *dp++ = *sp++;
+            *dp++ = *sp++, *dp++ = *sp++;
-            *dp++ = *sp++; *dp++ = *sp++;
+            *dp++ = *sp++, *dp++ = *sp++;
-            *dp++ = *sp++; *dp++ = *sp; sp += 3;
+            *dp++ = *sp++, *dp++ = *sp, sp += 3;
          }
 
          row_info->pixel_depth = 48;
@@ -610,7 +585,7 @@ png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)
       return; /* The filler channel has gone already */
 
    /* Fix the rowbytes value. */
-   row_info->rowbytes = (size_t)(dp-row);
+   row_info->rowbytes = dp-row;
 }
 #endif
 
@@ -621,7 +596,7 @@ png_do_bgr(png_row_infop row_info, png_bytep row)
 {
    png_debug(1, "in png_do_bgr");
 
-   if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
+   if ((row_info->color_type & PNG_COLOR_MASK_COLOR))
    {
       png_uint_32 row_width = row_info->width;
       if (row_info->bit_depth == 8)
@@ -691,7 +666,7 @@ png_do_bgr(png_row_infop row_info, png_bytep row)
 #endif
    }
 }
-#endif /* READ_BGR || WRITE_BGR */
+#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */
 
 #if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \
     defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED)
@@ -699,8 +674,6 @@ png_do_bgr(png_row_infop row_info, png_bytep row)
 void /* PRIVATE */
 png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)
 {
-   png_debug(1, "in png_do_check_palette_indexes");
-
    if (png_ptr->num_palette < (1 << row_info->bit_depth) &&
       png_ptr->num_palette > 0) /* num_palette can be 0 in MNG files */
    {
@@ -710,7 +683,7 @@ png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)
        * and this calculation is used because it avoids warnings that other
        * forms produced on either GCC or MSVC.
        */
-      int padding = PNG_PADBITS(row_info->pixel_depth, row_info->width);
+      int padding = (-row_info->pixel_depth * row_info->width) & 7;
       png_bytep rp = png_ptr->row_buf + row_info->rowbytes;
 
       switch (row_info->bit_depth)
@@ -722,7 +695,7 @@ png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)
              */
             for (; rp > png_ptr->row_buf; rp--)
             {
-              if ((*rp >> padding) != 0)
+              if (*rp >> padding != 0)
                  png_ptr->num_palette_max = 1;
               padding = 0;
             }
@@ -796,14 +769,14 @@ png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)
       }
    }
 }
-#endif /* CHECK_FOR_INVALID_INDEX */
+#endif /* PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED */
 
 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
     defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
 void PNGAPI
-png_set_user_transform_info(png_structrp png_ptr, png_voidp user_transform_ptr,
+png_set_user_transform_info(png_structrp png_ptr, png_voidp
-    int user_transform_depth, int user_transform_channels)
+   user_transform_ptr, int user_transform_depth, int user_transform_channels)
 {
    png_debug(1, "in png_set_user_transform_info");
 
@@ -815,7 +788,7 @@ png_set_user_transform_info(png_structrp png_ptr, png_voidp user_transform_ptr,
       (png_ptr->flags & PNG_FLAG_ROW_INIT) != 0)
    {
       png_app_error(png_ptr,
-          "info change after png_start_read_image or png_read_update_info");
+            "info change after png_start_read_image or png_read_update_info");
       return;
    }
 #endif
@@ -836,7 +809,7 @@ png_voidp PNGAPI
 png_get_user_transform_ptr(png_const_structrp png_ptr)
 {
    if (png_ptr == NULL)
-      return NULL;
+      return (NULL);
 
    return png_ptr->user_transform_ptr;
 }
@@ -846,7 +819,7 @@ png_get_user_transform_ptr(png_const_structrp png_ptr)
 png_uint_32 PNGAPI
 png_get_current_row_number(png_const_structrp png_ptr)
 {
-   /* See the comments in png.h - this is the sub-image row when reading an
+   /* See the comments in png.h - this is the sub-image row when reading and
     * interlaced image.
     */
    if (png_ptr != NULL)
@@ -862,6 +835,7 @@ png_get_current_pass_number(png_const_structrp png_ptr)
       return png_ptr->pass;
    return 8; /* invalid */
 }
-#endif /* USER_TRANSFORM_INFO */
+#endif /* PNG_USER_TRANSFORM_INFO_SUPPORTED */
-#endif /* READ_USER_TRANSFORM || WRITE_USER_TRANSFORM */
+#endif /* PNG_READ_USER_TRANSFORM_SUPPORTED ||
-#endif /* READ || WRITE */
+          PNG_WRITE_USER_TRANSFORM_SUPPORTED */
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

Windows_Libs/Dev/Render/libpng/pngwio.c

@@ -1,9 +1,10 @@
+
 /* pngwio.c - functions for data output
  *
- * Copyright (c) 2018-2025 Cosmin Truta
+ * Last changed in libpng 1.6.0 [February 14, 2013]
- * Copyright (c) 1998-2002,2004,2006-2014,2016,2018 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 Glenn Randers-Pehrson
- * Copyright (c) 1996-1997 Andreas Dilger
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -25,16 +26,16 @@
  * writes to a file pointer.  Note that this routine sometimes gets called
  * with very small lengths, so you should implement some kind of simple
  * buffering if you are using unbuffered writes.  This should never be asked
- * to write more than 64K on a 16-bit machine.
+ * to write more than 64K on a 16 bit machine.
  */
 
 void /* PRIVATE */
-png_write_data(png_structrp png_ptr, png_const_bytep data, size_t length)
+png_write_data(png_structrp png_ptr, png_const_bytep data, png_size_t length)
 {
    /* NOTE: write_data_fn must not change the buffer! */
    if (png_ptr->write_data_fn != NULL )
       (*(png_ptr->write_data_fn))(png_ptr, png_constcast(png_bytep,data),
-          length);
+         length);
 
    else
       png_error(png_ptr, "Call to NULL write function");
@@ -47,14 +48,14 @@ png_write_data(png_structrp png_ptr, png_const_bytep data, size_t length)
  * than changing the library.
  */
 void PNGCBAPI
-png_default_write_data(png_structp png_ptr, png_bytep data, size_t length)
+png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
 {
-   size_t check;
+   png_size_t check;
 
    if (png_ptr == NULL)
       return;
 
-   check = fwrite(data, 1, length, (FILE *)png_ptr->io_ptr);
+   check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr));
 
    if (check != length)
       png_error(png_ptr, "Write Error");
@@ -77,12 +78,12 @@ png_flush(png_structrp png_ptr)
 void PNGCBAPI
 png_default_flush(png_structp png_ptr)
 {
-   FILE *io_ptr;
+   png_FILE_p io_ptr;
 
    if (png_ptr == NULL)
       return;
 
-   io_ptr = png_voidcast(FILE *, png_ptr->io_ptr);
+   io_ptr = png_voidcast(png_FILE_p, (png_ptr->io_ptr));
    fflush(io_ptr);
 }
 #  endif
@@ -148,11 +149,8 @@ png_set_write_fn(png_structrp png_ptr, png_voidp io_ptr,
 #  else
    png_ptr->output_flush_fn = output_flush_fn;
 #  endif
-#else
+#endif /* PNG_WRITE_FLUSH_SUPPORTED */
-   PNG_UNUSED(output_flush_fn)
-#endif /* WRITE_FLUSH */
 
-#ifdef PNG_READ_SUPPORTED
    /* It is an error to read while writing a png file */
    if (png_ptr->read_data_fn != NULL)
    {
@@ -162,6 +160,5 @@ png_set_write_fn(png_structrp png_ptr, png_voidp io_ptr,
           "Can't set both read_data_fn and write_data_fn in the"
           " same structure");
    }
-#endif
 }
-#endif /* WRITE */
+#endif /* PNG_WRITE_SUPPORTED */

Windows_Libs/Dev/Render/libpng/pngwtran.c

@@ -1,9 +1,10 @@
+
 /* pngwtran.c - transforms the data in a row for PNG writers
  *
- * Copyright (c) 2018 Cosmin Truta
+ * Last changed in libpng 1.6.0 [February 14, 2013]
- * Copyright (c) 1998-2002,2004,2006-2016,2018 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 Glenn Randers-Pehrson
- * Copyright (c) 1996-1997 Andreas Dilger
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -13,14 +14,90 @@
 #include "pngpriv.h"
 
 #ifdef PNG_WRITE_SUPPORTED
+
 #ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
+/* Transform the data according to the user's wishes.  The order of
+ * transformations is significant.
+ */
+void /* PRIVATE */
+png_do_write_transformations(png_structrp png_ptr, png_row_infop row_info)
+{
+   png_debug(1, "in png_do_write_transformations");
+
+   if (png_ptr == NULL)
+      return;
+
+#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
+   if (png_ptr->transformations & PNG_USER_TRANSFORM)
+      if (png_ptr->write_user_transform_fn != NULL)
+         (*(png_ptr->write_user_transform_fn)) /* User write transform
+                                                 function */
+             (png_ptr,  /* png_ptr */
+             row_info,  /* row_info: */
+                /*  png_uint_32 width;       width of row */
+                /*  png_size_t rowbytes;     number of bytes in row */
+                /*  png_byte color_type;     color type of pixels */
+                /*  png_byte bit_depth;      bit depth of samples */
+                /*  png_byte channels;       number of channels (1-4) */
+                /*  png_byte pixel_depth;    bits per pixel (depth*channels) */
+             png_ptr->row_buf + 1);      /* start of pixel data for row */
+#endif
+
+#ifdef PNG_WRITE_FILLER_SUPPORTED
+   if (png_ptr->transformations & PNG_FILLER)
+      png_do_strip_channel(row_info, png_ptr->row_buf + 1,
+         !(png_ptr->flags & PNG_FLAG_FILLER_AFTER));
+#endif
+
+#ifdef PNG_WRITE_PACKSWAP_SUPPORTED
+   if (png_ptr->transformations & PNG_PACKSWAP)
+      png_do_packswap(row_info, png_ptr->row_buf + 1);
+#endif
+
+#ifdef PNG_WRITE_PACK_SUPPORTED
+   if (png_ptr->transformations & PNG_PACK)
+      png_do_pack(row_info, png_ptr->row_buf + 1,
+          (png_uint_32)png_ptr->bit_depth);
+#endif
+
+#ifdef PNG_WRITE_SWAP_SUPPORTED
+   if (png_ptr->transformations & PNG_SWAP_BYTES)
+      png_do_swap(row_info, png_ptr->row_buf + 1);
+#endif
+
+#ifdef PNG_WRITE_SHIFT_SUPPORTED
+   if (png_ptr->transformations & PNG_SHIFT)
+      png_do_shift(row_info, png_ptr->row_buf + 1,
+          &(png_ptr->shift));
+#endif
+
+#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
+   if (png_ptr->transformations & PNG_SWAP_ALPHA)
+      png_do_write_swap_alpha(row_info, png_ptr->row_buf + 1);
+#endif
+
+#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
+   if (png_ptr->transformations & PNG_INVERT_ALPHA)
+      png_do_write_invert_alpha(row_info, png_ptr->row_buf + 1);
+#endif
+
+#ifdef PNG_WRITE_BGR_SUPPORTED
+   if (png_ptr->transformations & PNG_BGR)
+      png_do_bgr(row_info, png_ptr->row_buf + 1);
+#endif
+
+#ifdef PNG_WRITE_INVERT_SUPPORTED
+   if (png_ptr->transformations & PNG_INVERT_MONO)
+      png_do_invert(row_info, png_ptr->row_buf + 1);
+#endif
+}
 
 #ifdef PNG_WRITE_PACK_SUPPORTED
 /* Pack pixels into bytes.  Pass the true bit depth in bit_depth.  The
  * row_info bit depth should be 8 (one pixel per byte).  The channels
  * should be 1 (this only happens on grayscale and paletted images).
  */
-static void
+void /* PRIVATE */
 png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
 {
    png_debug(1, "in png_do_pack");
@@ -70,8 +147,7 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
          case 2:
          {
             png_bytep sp, dp;
-            unsigned int shift;
+            int shift, v;
-            int v;
             png_uint_32 i;
             png_uint_32 row_width = row_info->width;
 
@@ -110,8 +186,7 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
          case 4:
          {
             png_bytep sp, dp;
-            unsigned int shift;
+            int shift, v;
-            int v;
             png_uint_32 i;
             png_uint_32 row_width = row_info->width;
 
@@ -167,7 +242,7 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
  * would pass 3 as bit_depth, and this routine would translate the
  * data to 0 to 15.
  */
-static void
+void /* PRIVATE */
 png_do_shift(png_row_infop row_info, png_bytep row,
     png_const_color_8p bit_depth)
 {
@@ -176,9 +251,9 @@ png_do_shift(png_row_infop row_info, png_bytep row,
    if (row_info->color_type != PNG_COLOR_TYPE_PALETTE)
    {
       int shift_start[4], shift_dec[4];
-      unsigned int channels = 0;
+      int channels = 0;
 
-      if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
+      if (row_info->color_type & PNG_COLOR_MASK_COLOR)
       {
          shift_start[channels] = row_info->bit_depth - bit_depth->red;
          shift_dec[channels] = bit_depth->red;
@@ -200,7 +275,7 @@ png_do_shift(png_row_infop row_info, png_bytep row,
          channels++;
       }
 
-      if ((row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0)
+      if (row_info->color_type & PNG_COLOR_MASK_ALPHA)
       {
          shift_start[channels] = row_info->bit_depth - bit_depth->alpha;
          shift_dec[channels] = bit_depth->alpha;
@@ -211,9 +286,9 @@ png_do_shift(png_row_infop row_info, png_bytep row,
       if (row_info->bit_depth < 8)
       {
          png_bytep bp = row;
-         size_t i;
+         png_size_t i;
          unsigned int mask;
-         size_t row_bytes = row_info->rowbytes;
+         png_size_t row_bytes = row_info->rowbytes;
 
          if (bit_depth->gray == 1 && row_info->bit_depth == 2)
             mask = 0x55;
@@ -253,7 +328,8 @@ png_do_shift(png_row_infop row_info, png_bytep row,
 
          for (i = 0; i < istop; i++, bp++)
          {
-            unsigned int c = i%channels;
+
+            const unsigned int c = i%channels;
             int j;
             unsigned int v, out;
 
@@ -281,7 +357,7 @@ png_do_shift(png_row_infop row_info, png_bytep row,
 
          for (bp = row, i = 0; i < istop; i++)
          {
-            unsigned int c = i%channels;
+            const unsigned int c = i%channels;
             int j;
             unsigned int value, v;
 
@@ -305,7 +381,7 @@ png_do_shift(png_row_infop row_info, png_bytep row,
 #endif
 
 #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
-static void
+void /* PRIVATE */
 png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
 {
    png_debug(1, "in png_do_write_swap_alpha");
@@ -353,7 +429,7 @@ png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
                *(dp++) = save[1];
             }
          }
-#endif /* WRITE_16BIT */
+#endif /* PNG_WRITE_16BIT_SUPPORTED */
       }
 
       else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
@@ -392,14 +468,14 @@ png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
                *(dp++) = save[1];
             }
          }
-#endif /* WRITE_16BIT */
+#endif /* PNG_WRITE_16BIT_SUPPORTED */
       }
    }
 }
 #endif
 
 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
-static void
+void /* PRIVATE */
 png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
 {
    png_debug(1, "in png_do_write_invert_alpha");
@@ -422,7 +498,7 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
                *(dp++) = *(sp++);
                */
                sp+=3; dp = sp;
-               *dp = (png_byte)(255 - *(sp++));
+               *(dp++) = (png_byte)(255 - *(sp++));
             }
          }
 
@@ -446,10 +522,10 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
                */
                sp+=6; dp = sp;
                *(dp++) = (png_byte)(255 - *(sp++));
-               *dp     = (png_byte)(255 - *(sp++));
+               *(dp++) = (png_byte)(255 - *(sp++));
             }
          }
-#endif /* WRITE_16BIT */
+#endif /* PNG_WRITE_16BIT_SUPPORTED */
       }
 
       else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
@@ -484,91 +560,78 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
                */
                sp+=2; dp = sp;
                *(dp++) = (png_byte)(255 - *(sp++));
-               *dp     = (png_byte)(255 - *(sp++));
+               *(dp++) = (png_byte)(255 - *(sp++));
             }
          }
-#endif /* WRITE_16BIT */
+#endif /* PNG_WRITE_16BIT_SUPPORTED */
       }
    }
 }
 #endif
+#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */
 
-/* Transform the data according to the user's wishes.  The order of
+#ifdef PNG_MNG_FEATURES_SUPPORTED
- * transformations is significant.
+/* Undoes intrapixel differencing  */
- */
 void /* PRIVATE */
-png_do_write_transformations(png_structrp png_ptr, png_row_infop row_info)
+png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
 {
-   png_debug(1, "in png_do_write_transformations");
+   png_debug(1, "in png_do_write_intrapixel");
 
-   if (png_ptr == NULL)
+   if ((row_info->color_type & PNG_COLOR_MASK_COLOR))
-      return;
+   {
+      int bytes_per_pixel;
+      png_uint_32 row_width = row_info->width;
+      if (row_info->bit_depth == 8)
+      {
+         png_bytep rp;
+         png_uint_32 i;
 
-#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
+         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
-   if ((png_ptr->transformations & PNG_USER_TRANSFORM) != 0)
+            bytes_per_pixel = 3;
-      if (png_ptr->write_user_transform_fn != NULL)
-         (*(png_ptr->write_user_transform_fn)) /* User write transform
-                                                 function */
-             (png_ptr,  /* png_ptr */
-             row_info,  /* row_info: */
-                /*  png_uint_32 width;       width of row */
-                /*  size_t rowbytes;         number of bytes in row */
-                /*  png_byte color_type;     color type of pixels */
-                /*  png_byte bit_depth;      bit depth of samples */
-                /*  png_byte channels;       number of channels (1-4) */
-                /*  png_byte pixel_depth;    bits per pixel (depth*channels) */
-             png_ptr->row_buf + 1);      /* start of pixel data for row */
-#endif
 
-#ifdef PNG_WRITE_FILLER_SUPPORTED
+         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
-   if ((png_ptr->transformations & PNG_FILLER) != 0)
+            bytes_per_pixel = 4;
-      png_do_strip_channel(row_info, png_ptr->row_buf + 1,
-          !(png_ptr->flags & PNG_FLAG_FILLER_AFTER));
-#endif
 
-#ifdef PNG_WRITE_PACKSWAP_SUPPORTED
+         else
-   if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
+            return;
-      png_do_packswap(row_info, png_ptr->row_buf + 1);
-#endif
 
-#ifdef PNG_WRITE_PACK_SUPPORTED
+         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
-   if ((png_ptr->transformations & PNG_PACK) != 0)
+         {
-      png_do_pack(row_info, png_ptr->row_buf + 1,
+            *(rp)     = (png_byte)((*rp       - *(rp + 1)) & 0xff);
-          (png_uint_32)png_ptr->bit_depth);
+            *(rp + 2) = (png_byte)((*(rp + 2) - *(rp + 1)) & 0xff);
-#endif
+         }
+      }
 
-#ifdef PNG_WRITE_SWAP_SUPPORTED
+#ifdef PNG_WRITE_16BIT_SUPPORTED
-#  ifdef PNG_16BIT_SUPPORTED
+      else if (row_info->bit_depth == 16)
-   if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
+      {
-      png_do_swap(row_info, png_ptr->row_buf + 1);
+         png_bytep rp;
-#  endif
+         png_uint_32 i;
-#endif
 
-#ifdef PNG_WRITE_SHIFT_SUPPORTED
+         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
-   if ((png_ptr->transformations & PNG_SHIFT) != 0)
+            bytes_per_pixel = 6;
-      png_do_shift(row_info, png_ptr->row_buf + 1,
-           &(png_ptr->shift));
-#endif
 
-#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
+         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
-   if ((png_ptr->transformations & PNG_SWAP_ALPHA) != 0)
+            bytes_per_pixel = 8;
-      png_do_write_swap_alpha(row_info, png_ptr->row_buf + 1);
-#endif
 
-#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
+         else
-   if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0)
+            return;
-      png_do_write_invert_alpha(row_info, png_ptr->row_buf + 1);
-#endif
 
-#ifdef PNG_WRITE_BGR_SUPPORTED
+         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
-   if ((png_ptr->transformations & PNG_BGR) != 0)
+         {
-      png_do_bgr(row_info, png_ptr->row_buf + 1);
+            png_uint_32 s0   = (*(rp    ) << 8) | *(rp + 1);
-#endif
+            png_uint_32 s1   = (*(rp + 2) << 8) | *(rp + 3);
-
+            png_uint_32 s2   = (*(rp + 4) << 8) | *(rp + 5);
-#ifdef PNG_WRITE_INVERT_SUPPORTED
+            png_uint_32 red  = (png_uint_32)((s0 - s1) & 0xffffL);
-   if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
+            png_uint_32 blue = (png_uint_32)((s2 - s1) & 0xffffL);
-      png_do_invert(row_info, png_ptr->row_buf + 1);
+            *(rp    ) = (png_byte)((red >> 8) & 0xff);
-#endif
+            *(rp + 1) = (png_byte)(red & 0xff);
+            *(rp + 4) = (png_byte)((blue >> 8) & 0xff);
+            *(rp + 5) = (png_byte)(blue & 0xff);
+         }
+      }
+#endif /* PNG_WRITE_16BIT_SUPPORTED */
+   }
 }
-#endif /* WRITE_TRANSFORMS */
+#endif /* PNG_MNG_FEATURES_SUPPORTED */
-#endif /* WRITE */
+#endif /* PNG_WRITE_SUPPORTED */