Backport PNG output format to origin/master branch.
authorTom Sepez <tsepez@chromium.org>
Mon, 23 Feb 2015 23:59:57 +0000 (15:59 -0800)
committerTom Sepez <tsepez@chromium.org>
Mon, 23 Feb 2015 23:59:57 +0000 (15:59 -0800)
The pdfium library itself does not support the format, but the test utility
can convert to this output format.

GN build can't be tested standalone, so push this out to the next CL.

R=jam@chromium.org

Review URL: https://codereview.chromium.org/950113002

43 files changed:
samples/fx_lpng/include/fx_png.h [new file with mode: 0644]
samples/fx_lpng/lpng_v163/fx_png.c [new file with mode: 0644]
samples/fx_lpng/lpng_v163/fx_pngerror.c [new file with mode: 0644]
samples/fx_lpng/lpng_v163/fx_pngget.c [new file with mode: 0644]
samples/fx_lpng/lpng_v163/fx_pngmem.c [new file with mode: 0644]
samples/fx_lpng/lpng_v163/fx_pngpread.c [new file with mode: 0644]
samples/fx_lpng/lpng_v163/fx_pngread.c [new file with mode: 0644]
samples/fx_lpng/lpng_v163/fx_pngrio.c [new file with mode: 0644]
samples/fx_lpng/lpng_v163/fx_pngrtran.c [new file with mode: 0644]
samples/fx_lpng/lpng_v163/fx_pngrutil.c [new file with mode: 0644]
samples/fx_lpng/lpng_v163/fx_pngset.c [new file with mode: 0644]
samples/fx_lpng/lpng_v163/fx_pngtrans.c [new file with mode: 0644]
samples/fx_lpng/lpng_v163/fx_pngwio.c [new file with mode: 0644]
samples/fx_lpng/lpng_v163/fx_pngwrite.c [new file with mode: 0644]
samples/fx_lpng/lpng_v163/fx_pngwtran.c [new file with mode: 0644]
samples/fx_lpng/lpng_v163/fx_pngwutil.c [new file with mode: 0644]
samples/fx_lpng/lpng_v163/png.h [new file with mode: 0644]
samples/fx_lpng/lpng_v163/pngconf.h [new file with mode: 0644]
samples/fx_lpng/lpng_v163/pngdebug.h [new file with mode: 0644]
samples/fx_lpng/lpng_v163/pnginfo.h [new file with mode: 0644]
samples/fx_lpng/lpng_v163/pnglibconf.h [new file with mode: 0644]
samples/fx_lpng/lpng_v163/pngpriv.h [new file with mode: 0644]
samples/fx_lpng/lpng_v163/pngstruct.h [new file with mode: 0644]
samples/fx_lpng/src/fx_png.c [new file with mode: 0644]
samples/fx_lpng/src/fx_pngerror.c [new file with mode: 0644]
samples/fx_lpng/src/fx_pngget.c [new file with mode: 0644]
samples/fx_lpng/src/fx_pngmem.c [new file with mode: 0644]
samples/fx_lpng/src/fx_pngpread.c [new file with mode: 0644]
samples/fx_lpng/src/fx_pngread.c [new file with mode: 0644]
samples/fx_lpng/src/fx_pngrio.c [new file with mode: 0644]
samples/fx_lpng/src/fx_pngrtran.c [new file with mode: 0644]
samples/fx_lpng/src/fx_pngrutil.c [new file with mode: 0644]
samples/fx_lpng/src/fx_pngset.c [new file with mode: 0644]
samples/fx_lpng/src/fx_pngtrans.c [new file with mode: 0644]
samples/fx_lpng/src/fx_pngwio.c [new file with mode: 0644]
samples/fx_lpng/src/fx_pngwrite.c [new file with mode: 0644]
samples/fx_lpng/src/fx_pngwtran.c [new file with mode: 0644]
samples/fx_lpng/src/fx_pngwutil.c [new file with mode: 0644]
samples/image_diff.cc [new file with mode: 0644]
samples/image_diff_png.cc [new file with mode: 0644]
samples/image_diff_png.h [new file with mode: 0644]
samples/pdfium_test.cc
samples/samples.gyp

diff --git a/samples/fx_lpng/include/fx_png.h b/samples/fx_lpng/include/fx_png.h
new file mode 100644 (file)
index 0000000..4ef53d0
--- /dev/null
@@ -0,0 +1,7 @@
+// Copyright 2014 PDFium Authors. All rights reserved.\r
+// Use of this source code is governed by a BSD-style license that can be\r
+// found in the LICENSE file.\r
+\r
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com\r
+\r
+#include "../lpng_v163/png.h"\r
diff --git a/samples/fx_lpng/lpng_v163/fx_png.c b/samples/fx_lpng/lpng_v163/fx_png.c
new file mode 100644 (file)
index 0000000..93c675b
--- /dev/null
@@ -0,0 +1,4297 @@
+/* png.c - location for general purpose libpng functions\r
+ *\r
+ * Last changed in libpng 1.6.2 [April 25, 2013]\r
+ * Copyright (c) 1998-2013 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ *\r
+ * This code is released under the libpng license.\r
+ * For conditions of distribution and use, see the disclaimer\r
+ * and license in png.h\r
+ */\r
+\r
+#include "pngpriv.h"\r
+\r
+/* Generate a compiler error if there is an old png.h in the search path. */\r
+typedef png_libpng_version_1_6_3 Your_png_h_is_not_version_1_6_3;\r
+\r
+/* Tells libpng that we have already handled the first "num_bytes" bytes\r
+ * of the PNG file signature.  If the PNG data is embedded into another\r
+ * stream we can set num_bytes = 8 so that libpng will not attempt to read\r
+ * or write any of the magic bytes before it starts on the IHDR.\r
+ */\r
+\r
+#ifdef PNG_READ_SUPPORTED\r
+void PNGAPI\r
+png_set_sig_bytes(png_structrp png_ptr, int num_bytes)\r
+{\r
+   png_debug(1, "in png_set_sig_bytes");\r
+\r
+   if (png_ptr == NULL)\r
+      return;\r
+\r
+   if (num_bytes > 8)\r
+      png_error(png_ptr, "Too many bytes for PNG signature");\r
+\r
+   png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);\r
+}\r
+\r
+/* Checks whether the supplied bytes match the PNG signature.  We allow\r
+ * checking less than the full 8-byte signature so that those apps that\r
+ * already read the first few bytes of a file to determine the file type\r
+ * can simply check the remaining bytes for extra assurance.  Returns\r
+ * an integer less than, equal to, or greater than zero if sig is found,\r
+ * respectively, to be less than, to match, or be greater than the correct\r
+ * PNG signature (this is the same behavior as strcmp, memcmp, etc).\r
+ */\r
+int PNGAPI\r
+png_sig_cmp(png_const_bytep sig, png_size_t start, png_size_t num_to_check)\r
+{\r
+   png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};\r
+\r
+   if (num_to_check > 8)\r
+      num_to_check = 8;\r
+\r
+   else if (num_to_check < 1)\r
+      return (-1);\r
+\r
+   if (start > 7)\r
+      return (-1);\r
+\r
+   if (start + num_to_check > 8)\r
+      num_to_check = 8 - start;\r
+\r
+   return ((int)(memcmp(&sig[start], &png_signature[start], num_to_check)));\r
+}\r
+\r
+#endif /* PNG_READ_SUPPORTED */\r
+\r
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)\r
+/* Function to allocate memory for zlib */\r
+PNG_FUNCTION(voidpf /* PRIVATE */,\r
+png_zalloc,(voidpf png_ptr, uInt items, uInt size),PNG_ALLOCATED)\r
+{\r
+   png_alloc_size_t num_bytes = size;\r
+\r
+   if (png_ptr == NULL)\r
+      return NULL;\r
+\r
+   if (items >= (~(png_alloc_size_t)0)/size)\r
+   {\r
+      png_warning (png_voidcast(png_structrp, png_ptr),\r
+         "Potential overflow in png_zalloc()");\r
+      return NULL;\r
+   }\r
+\r
+   num_bytes *= items;\r
+   return png_malloc_warn(png_voidcast(png_structrp, png_ptr), num_bytes);\r
+}\r
+\r
+/* Function to free memory for zlib */\r
+void /* PRIVATE */\r
+png_zfree(voidpf png_ptr, voidpf ptr)\r
+{\r
+   png_free(png_voidcast(png_const_structrp,png_ptr), ptr);\r
+}\r
+\r
+/* Reset the CRC variable to 32 bits of 1's.  Care must be taken\r
+ * in case CRC is > 32 bits to leave the top bits 0.\r
+ */\r
+void /* PRIVATE */\r
+png_reset_crc(png_structrp png_ptr)\r
+{\r
+   /* The cast is safe because the crc is a 32 bit value. */\r
+   png_ptr->crc = (png_uint_32)crc32(0, Z_NULL, 0);\r
+}\r
+\r
+/* Calculate the CRC over a section of data.  We can only pass as\r
+ * much data to this routine as the largest single buffer size.  We\r
+ * also check that this data will actually be used before going to the\r
+ * trouble of calculating it.\r
+ */\r
+void /* PRIVATE */\r
+png_calculate_crc(png_structrp png_ptr, png_const_bytep ptr, png_size_t length)\r
+{\r
+   int need_crc = 1;\r
+\r
+   if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name))\r
+   {\r
+      if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==\r
+          (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))\r
+         need_crc = 0;\r
+   }\r
+\r
+   else /* critical */\r
+   {\r
+      if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)\r
+         need_crc = 0;\r
+   }\r
+\r
+   /* 'uLong' is defined in zlib.h as unsigned long; this means that on some\r
+    * systems it is a 64 bit value.  crc32, however, returns 32 bits so the\r
+    * following cast is safe.  'uInt' may be no more than 16 bits, so it is\r
+    * necessary to perform a loop here.\r
+    */\r
+   if (need_crc && length > 0)\r
+   {\r
+      uLong crc = png_ptr->crc; /* Should never issue a warning */\r
+\r
+      do\r
+      {\r
+         uInt safe_length = (uInt)length;\r
+         if (safe_length == 0)\r
+            safe_length = (uInt)-1; /* evil, but safe */\r
+\r
+         crc = crc32(crc, ptr, safe_length);\r
+\r
+         /* The following should never issue compiler warnings; if they do the\r
+          * target system has characteristics that will probably violate other\r
+          * assumptions within the libpng code.\r
+          */\r
+         ptr += safe_length;\r
+         length -= safe_length;\r
+      }\r
+      while (length > 0);\r
+\r
+      /* And the following is always safe because the crc is only 32 bits. */\r
+      png_ptr->crc = (png_uint_32)crc;\r
+   }\r
+}\r
+\r
+/* Check a user supplied version number, called from both read and write\r
+ * functions that create a png_struct.\r
+ */\r
+int\r
+png_user_version_check(png_structrp png_ptr, png_const_charp user_png_ver)\r
+{\r
+   if (user_png_ver)\r
+   {\r
+      int i = 0;\r
+\r
+      do\r
+      {\r
+         if (user_png_ver[i] != png_libpng_ver[i])\r
+            png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;\r
+      } while (png_libpng_ver[i++]);\r
+   }\r
+\r
+   else\r
+      png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;\r
+\r
+   if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)\r
+   {\r
+     /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so\r
+      * we must recompile any applications that use any older library version.\r
+      * For versions after libpng 1.0, we will be compatible, so we need\r
+      * only check the first and third digits (note that when we reach version\r
+      * 1.10 we will need to check the fourth symbol, namely user_png_ver[3]).\r
+      */\r
+      if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||\r
+          (user_png_ver[0] == '1' && (user_png_ver[2] != png_libpng_ver[2] ||\r
+          user_png_ver[3] != png_libpng_ver[3])) ||\r
+          (user_png_ver[0] == '0' && user_png_ver[2] < '9'))\r
+      {\r
+#ifdef PNG_WARNINGS_SUPPORTED\r
+         size_t pos = 0;\r
+         char m[128];\r
+\r
+         pos = png_safecat(m, (sizeof m), pos,\r
+             "Application built with libpng-");\r
+         pos = png_safecat(m, (sizeof m), pos, user_png_ver);\r
+         pos = png_safecat(m, (sizeof m), pos, " but running with ");\r
+         pos = png_safecat(m, (sizeof m), pos, png_libpng_ver);\r
+\r
+         png_warning(png_ptr, m);\r
+#endif\r
+\r
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
+         png_ptr->flags = 0;\r
+#endif\r
+\r
+         return 0;\r
+      }\r
+   }\r
+\r
+   /* Success return. */\r
+   return 1;\r
+}\r
+\r
+/* Generic function to create a png_struct for either read or write - this\r
+ * contains the common initialization.\r
+ */\r
+PNG_FUNCTION(png_structp /* PRIVATE */,\r
+png_create_png_struct,(png_const_charp user_png_ver, png_voidp error_ptr,\r
+    png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,\r
+    png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)\r
+{\r
+   png_struct create_struct;\r
+#  ifdef PNG_SETJMP_SUPPORTED\r
+      jmp_buf create_jmp_buf;\r
+#  endif\r
+\r
+   /* This temporary stack-allocated structure is used to provide a place to\r
+    * build enough context to allow the user provided memory allocator (if any)\r
+    * to be called.\r
+    */\r
+   memset(&create_struct, 0, (sizeof create_struct));\r
+\r
+   /* Added at libpng-1.2.6 */\r
+#  ifdef PNG_USER_LIMITS_SUPPORTED\r
+      create_struct.user_width_max = PNG_USER_WIDTH_MAX;\r
+      create_struct.user_height_max = PNG_USER_HEIGHT_MAX;\r
+\r
+#     ifdef PNG_USER_CHUNK_CACHE_MAX\r
+         /* Added at libpng-1.2.43 and 1.4.0 */\r
+         create_struct.user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX;\r
+#     endif\r
+\r
+#     ifdef PNG_USER_CHUNK_MALLOC_MAX\r
+         /* Added at libpng-1.2.43 and 1.4.1, required only for read but exists\r
+          * in png_struct regardless.\r
+          */\r
+         create_struct.user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX;\r
+#     endif\r
+#  endif\r
+\r
+   /* The following two API calls simply set fields in png_struct, so it is safe\r
+    * to do them now even though error handling is not yet set up.\r
+    */\r
+#  ifdef PNG_USER_MEM_SUPPORTED\r
+      png_set_mem_fn(&create_struct, mem_ptr, malloc_fn, free_fn);\r
+#  endif\r
+\r
+   /* (*error_fn) can return control to the caller after the error_ptr is set,\r
+    * this will result in a memory leak unless the error_fn does something\r
+    * extremely sophisticated.  The design lacks merit but is implicit in the\r
+    * API.\r
+    */\r
+   png_set_error_fn(&create_struct, error_ptr, error_fn, warn_fn);\r
+\r
+#  ifdef PNG_SETJMP_SUPPORTED\r
+      if (!setjmp(create_jmp_buf))\r
+      {\r
+         /* Temporarily fake out the longjmp information until we have\r
+          * successfully completed this function.  This only works if we have\r
+          * setjmp() support compiled in, but it is safe - this stuff should\r
+          * never happen.\r
+          */\r
+         create_struct.jmp_buf_ptr = &create_jmp_buf;\r
+         create_struct.jmp_buf_size = 0; /*stack allocation*/\r
+         create_struct.longjmp_fn = longjmp;\r
+#  else\r
+      {\r
+#  endif\r
+         /* Call the general version checker (shared with read and write code):\r
+          */\r
+         if (png_user_version_check(&create_struct, user_png_ver))\r
+         {\r
+            png_structrp png_ptr = png_voidcast(png_structrp,\r
+               png_malloc_warn(&create_struct, (sizeof *png_ptr)));\r
+\r
+            if (png_ptr != NULL)\r
+            {\r
+               /* png_ptr->zstream holds a back-pointer to the png_struct, so\r
+                * this can only be done now:\r
+                */\r
+               create_struct.zstream.zalloc = png_zalloc;\r
+               create_struct.zstream.zfree = png_zfree;\r
+               create_struct.zstream.opaque = png_ptr;\r
+\r
+#              ifdef PNG_SETJMP_SUPPORTED\r
+                  /* Eliminate the local error handling: */\r
+                  create_struct.jmp_buf_ptr = NULL;\r
+                  create_struct.jmp_buf_size = 0;\r
+                  create_struct.longjmp_fn = 0;\r
+#              endif\r
+\r
+               *png_ptr = create_struct;\r
+\r
+               /* This is the successful return point */\r
+               return png_ptr;\r
+            }\r
+         }\r
+      }\r
+\r
+   /* A longjmp because of a bug in the application storage allocator or a\r
+    * simple failure to allocate the png_struct.\r
+    */\r
+   return NULL;\r
+}\r
+\r
+/* Allocate the memory for an info_struct for the application. */\r
+PNG_FUNCTION(png_infop,PNGAPI\r
+png_create_info_struct,(png_const_structrp png_ptr),PNG_ALLOCATED)\r
+{\r
+   png_inforp info_ptr;\r
+\r
+   png_debug(1, "in png_create_info_struct");\r
+\r
+   if (png_ptr == NULL)\r
+      return NULL;\r
+\r
+   /* Use the internal API that does not (or at least should not) error out, so\r
+    * that this call always returns ok.  The application typically sets up the\r
+    * error handling *after* creating the info_struct because this is the way it\r
+    * has always been done in 'example.c'.\r
+    */\r
+   info_ptr = png_voidcast(png_inforp, png_malloc_base(png_ptr,\r
+      (sizeof *info_ptr)));\r
+\r
+   if (info_ptr != NULL)\r
+      memset(info_ptr, 0, (sizeof *info_ptr));\r
+\r
+   return info_ptr;\r
+}\r
+\r
+/* This function frees the memory associated with a single info struct.\r
+ * Normally, one would use either png_destroy_read_struct() or\r
+ * png_destroy_write_struct() to free an info struct, but this may be\r
+ * useful for some applications.  From libpng 1.6.0 this function is also used\r
+ * internally to implement the png_info release part of the 'struct' destroy\r
+ * APIs.  This ensures that all possible approaches free the same data (all of\r
+ * it).\r
+ */\r
+void PNGAPI\r
+png_destroy_info_struct(png_const_structrp png_ptr, png_infopp info_ptr_ptr)\r
+{\r
+   png_inforp info_ptr = NULL;\r
+\r
+   png_debug(1, "in png_destroy_info_struct");\r
+\r
+   if (png_ptr == NULL)\r
+      return;\r
+\r
+   if (info_ptr_ptr != NULL)\r
+      info_ptr = *info_ptr_ptr;\r
+\r
+   if (info_ptr != NULL)\r
+   {\r
+      /* Do this first in case of an error below; if the app implements its own\r
+       * memory management this can lead to png_free calling png_error, which\r
+       * will abort this routine and return control to the app error handler.\r
+       * An infinite loop may result if it then tries to free the same info\r
+       * ptr.\r
+       */\r
+      *info_ptr_ptr = NULL;\r
+\r
+      png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);\r
+      memset(info_ptr, 0, (sizeof *info_ptr));\r
+      png_free(png_ptr, info_ptr);\r
+   }\r
+}\r
+\r
+/* Initialize the info structure.  This is now an internal function (0.89)\r
+ * and applications using it are urged to use png_create_info_struct()\r
+ * instead.  Use deprecated in 1.6.0, internal use removed (used internally it\r
+ * is just a memset).\r
+ *\r
+ * NOTE: it is almost inconceivable that this API is used because it bypasses\r
+ * the user-memory mechanism and the user error handling/warning mechanisms in\r
+ * those cases where it does anything other than a memset.\r
+ */\r
+PNG_FUNCTION(void,PNGAPI\r
+png_info_init_3,(png_infopp ptr_ptr, png_size_t png_info_struct_size),\r
+   PNG_DEPRECATED)\r
+{\r
+   png_inforp info_ptr = *ptr_ptr;\r
+\r
+   png_debug(1, "in png_info_init_3");\r
+\r
+   if (info_ptr == NULL)\r
+      return;\r
+\r
+   if ((sizeof (png_info)) > png_info_struct_size)\r
+   {\r
+      *ptr_ptr = NULL;\r
+      /* The following line is why this API should not be used: */\r
+      free(info_ptr);\r
+      info_ptr = png_voidcast(png_inforp, png_malloc_base(NULL,\r
+         (sizeof *info_ptr)));\r
+      *ptr_ptr = info_ptr;\r
+   }\r
+\r
+   /* Set everything to 0 */\r
+   memset(info_ptr, 0, (sizeof *info_ptr));\r
+}\r
+\r
+/* The following API is not called internally */\r
+void PNGAPI\r
+png_data_freer(png_const_structrp png_ptr, png_inforp info_ptr,\r
+   int freer, png_uint_32 mask)\r
+{\r
+   png_debug(1, "in png_data_freer");\r
+\r
+   if (png_ptr == NULL || info_ptr == NULL)\r
+      return;\r
+\r
+   if (freer == PNG_DESTROY_WILL_FREE_DATA)\r
+      info_ptr->free_me |= mask;\r
+\r
+   else if (freer == PNG_USER_WILL_FREE_DATA)\r
+      info_ptr->free_me &= ~mask;\r
+\r
+   else\r
+      png_error(png_ptr, "Unknown freer parameter in png_data_freer");\r
+}\r
+\r
+void PNGAPI\r
+png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask,\r
+   int num)\r
+{\r
+   png_debug(1, "in png_free_data");\r
+\r
+   if (png_ptr == NULL || info_ptr == NULL)\r
+      return;\r
+\r
+#ifdef PNG_TEXT_SUPPORTED\r
+   /* Free text item num or (if num == -1) all text items */\r
+   if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)\r
+   {\r
+      if (num != -1)\r
+      {\r
+         if (info_ptr->text && info_ptr->text[num].key)\r
+         {\r
+            png_free(png_ptr, info_ptr->text[num].key);\r
+            info_ptr->text[num].key = NULL;\r
+         }\r
+      }\r
+\r
+      else\r
+      {\r
+         int i;\r
+         for (i = 0; i < info_ptr->num_text; i++)\r
+             png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);\r
+         png_free(png_ptr, info_ptr->text);\r
+         info_ptr->text = NULL;\r
+         info_ptr->num_text=0;\r
+      }\r
+   }\r
+#endif\r
+\r
+#ifdef PNG_tRNS_SUPPORTED\r
+   /* Free any tRNS entry */\r
+   if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)\r
+   {\r
+      png_free(png_ptr, info_ptr->trans_alpha);\r
+      info_ptr->trans_alpha = NULL;\r
+      info_ptr->valid &= ~PNG_INFO_tRNS;\r
+   }\r
+#endif\r
+\r
+#ifdef PNG_sCAL_SUPPORTED\r
+   /* Free any sCAL entry */\r
+   if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)\r
+   {\r
+      png_free(png_ptr, info_ptr->scal_s_width);\r
+      png_free(png_ptr, info_ptr->scal_s_height);\r
+      info_ptr->scal_s_width = NULL;\r
+      info_ptr->scal_s_height = NULL;\r
+      info_ptr->valid &= ~PNG_INFO_sCAL;\r
+   }\r
+#endif\r
+\r
+#ifdef PNG_pCAL_SUPPORTED\r
+   /* Free any pCAL entry */\r
+   if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)\r
+   {\r
+      png_free(png_ptr, info_ptr->pcal_purpose);\r
+      png_free(png_ptr, info_ptr->pcal_units);\r
+      info_ptr->pcal_purpose = NULL;\r
+      info_ptr->pcal_units = NULL;\r
+      if (info_ptr->pcal_params != NULL)\r
+         {\r
+            unsigned int i;\r
+            for (i = 0; i < info_ptr->pcal_nparams; i++)\r
+            {\r
+               png_free(png_ptr, info_ptr->pcal_params[i]);\r
+               info_ptr->pcal_params[i] = NULL;\r
+            }\r
+            png_free(png_ptr, info_ptr->pcal_params);\r
+            info_ptr->pcal_params = NULL;\r
+         }\r
+      info_ptr->valid &= ~PNG_INFO_pCAL;\r
+   }\r
+#endif\r
+\r
+#ifdef PNG_iCCP_SUPPORTED\r
+   /* Free any profile entry */\r
+   if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)\r
+   {\r
+      png_free(png_ptr, info_ptr->iccp_name);\r
+      png_free(png_ptr, info_ptr->iccp_profile);\r
+      info_ptr->iccp_name = NULL;\r
+      info_ptr->iccp_profile = NULL;\r
+      info_ptr->valid &= ~PNG_INFO_iCCP;\r
+   }\r
+#endif\r
+\r
+#ifdef PNG_sPLT_SUPPORTED\r
+   /* Free a given sPLT entry, or (if num == -1) all sPLT entries */\r
+   if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)\r
+   {\r
+      if (num != -1)\r
+      {\r
+         if (info_ptr->splt_palettes)\r
+         {\r
+            png_free(png_ptr, info_ptr->splt_palettes[num].name);\r
+            png_free(png_ptr, info_ptr->splt_palettes[num].entries);\r
+            info_ptr->splt_palettes[num].name = NULL;\r
+            info_ptr->splt_palettes[num].entries = NULL;\r
+         }\r
+      }\r
+\r
+      else\r
+      {\r
+         if (info_ptr->splt_palettes_num)\r
+         {\r
+            int i;\r
+            for (i = 0; i < info_ptr->splt_palettes_num; i++)\r
+               png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, (int)i);\r
+\r
+            png_free(png_ptr, info_ptr->splt_palettes);\r
+            info_ptr->splt_palettes = NULL;\r
+            info_ptr->splt_palettes_num = 0;\r
+         }\r
+         info_ptr->valid &= ~PNG_INFO_sPLT;\r
+      }\r
+   }\r
+#endif\r
+\r
+#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED\r
+   if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)\r
+   {\r
+      if (num != -1)\r
+      {\r
+          if (info_ptr->unknown_chunks)\r
+          {\r
+             png_free(png_ptr, info_ptr->unknown_chunks[num].data);\r
+             info_ptr->unknown_chunks[num].data = NULL;\r
+          }\r
+      }\r
+\r
+      else\r
+      {\r
+         int i;\r
+\r
+         if (info_ptr->unknown_chunks_num)\r
+         {\r
+            for (i = 0; i < info_ptr->unknown_chunks_num; i++)\r
+               png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, (int)i);\r
+\r
+            png_free(png_ptr, info_ptr->unknown_chunks);\r
+            info_ptr->unknown_chunks = NULL;\r
+            info_ptr->unknown_chunks_num = 0;\r
+         }\r
+      }\r
+   }\r
+#endif\r
+\r
+#ifdef PNG_hIST_SUPPORTED\r
+   /* Free any hIST entry */\r
+   if ((mask & PNG_FREE_HIST)  & info_ptr->free_me)\r
+   {\r
+      png_free(png_ptr, info_ptr->hist);\r
+      info_ptr->hist = NULL;\r
+      info_ptr->valid &= ~PNG_INFO_hIST;\r
+   }\r
+#endif\r
+\r
+   /* Free any PLTE entry that was internally allocated */\r
+   if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)\r
+   {\r
+      png_free(png_ptr, info_ptr->palette);\r
+      info_ptr->palette = NULL;\r
+      info_ptr->valid &= ~PNG_INFO_PLTE;\r
+      info_ptr->num_palette = 0;\r
+   }\r
+\r
+#ifdef PNG_INFO_IMAGE_SUPPORTED\r
+   /* Free any image bits attached to the info structure */\r
+   if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)\r
+   {\r
+      if (info_ptr->row_pointers)\r
+      {\r
+         png_uint_32 row;\r
+         for (row = 0; row < info_ptr->height; row++)\r
+         {\r
+            png_free(png_ptr, info_ptr->row_pointers[row]);\r
+            info_ptr->row_pointers[row] = NULL;\r
+         }\r
+         png_free(png_ptr, info_ptr->row_pointers);\r
+         info_ptr->row_pointers = NULL;\r
+      }\r
+      info_ptr->valid &= ~PNG_INFO_IDAT;\r
+   }\r
+#endif\r
+\r
+   if (num != -1)\r
+      mask &= ~PNG_FREE_MUL;\r
+\r
+   info_ptr->free_me &= ~mask;\r
+}\r
+#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */\r
+\r
+/* This function returns a pointer to the io_ptr associated with the user\r
+ * functions.  The application should free any memory associated with this\r
+ * pointer before png_write_destroy() or png_read_destroy() are called.\r
+ */\r
+png_voidp PNGAPI\r
+png_get_io_ptr(png_const_structrp png_ptr)\r
+{\r
+   if (png_ptr == NULL)\r
+      return (NULL);\r
+\r
+   return (png_ptr->io_ptr);\r
+}\r
+\r
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)\r
+#  ifdef PNG_STDIO_SUPPORTED\r
+/* Initialize the default input/output functions for the PNG file.  If you\r
+ * use your own read or write routines, you can call either png_set_read_fn()\r
+ * or png_set_write_fn() instead of png_init_io().  If you have defined\r
+ * PNG_NO_STDIO or otherwise disabled PNG_STDIO_SUPPORTED, you must use a\r
+ * function of your own because "FILE *" isn't necessarily available.\r
+ */\r
+void PNGAPI\r
+png_init_io(png_structrp png_ptr, png_FILE_p fp)\r
+{\r
+   png_debug(1, "in png_init_io");\r
+\r
+   if (png_ptr == NULL)\r
+      return;\r
+\r
+   png_ptr->io_ptr = (png_voidp)fp;\r
+}\r
+#  endif\r
+\r
+#ifdef PNG_SAVE_INT_32_SUPPORTED\r
+/* The png_save_int_32 function assumes integers are stored in two's\r
+ * complement format.  If this isn't the case, then this routine needs to\r
+ * be modified to write data in two's complement format.  Note that,\r
+ * the following works correctly even if png_int_32 has more than 32 bits\r
+ * (compare the more complex code required on read for sign extension.)\r
+ */\r
+void PNGAPI\r
+png_save_int_32(png_bytep buf, png_int_32 i)\r
+{\r
+   buf[0] = (png_byte)((i >> 24) & 0xff);\r
+   buf[1] = (png_byte)((i >> 16) & 0xff);\r
+   buf[2] = (png_byte)((i >> 8) & 0xff);\r
+   buf[3] = (png_byte)(i & 0xff);\r
+}\r
+#endif\r
+\r
+#  ifdef PNG_TIME_RFC1123_SUPPORTED\r
+/* Convert the supplied time into an RFC 1123 string suitable for use in\r
+ * a "Creation Time" or other text-based time string.\r
+ */\r
+int PNGAPI\r
+png_convert_to_rfc1123_buffer(char out[29], png_const_timep ptime)\r
+{\r
+   static PNG_CONST char short_months[12][4] =\r
+        {"Jan", "Feb", "Mar", "Apr", "May", "Jun",\r
+         "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};\r
+\r
+   if (out == NULL)\r
+      return 0;\r
+\r
+   if (ptime->year > 9999 /* RFC1123 limitation */ ||\r
+       ptime->month == 0    ||  ptime->month > 12  ||\r
+       ptime->day   == 0    ||  ptime->day   > 31  ||\r
+       ptime->hour  > 23    ||  ptime->minute > 59 ||\r
+       ptime->second > 60)\r
+      return 0;\r
+\r
+   {\r
+      size_t pos = 0;\r
+      char number_buf[5]; /* enough for a four-digit year */\r
+\r
+#     define APPEND_STRING(string) pos = png_safecat(out, 29, pos, (string))\r
+#     define APPEND_NUMBER(format, value)\\r
+         APPEND_STRING(PNG_FORMAT_NUMBER(number_buf, format, (value)))\r
+#     define APPEND(ch) if (pos < 28) out[pos++] = (ch)\r
+\r
+      APPEND_NUMBER(PNG_NUMBER_FORMAT_u, (unsigned)ptime->day);\r
+      APPEND(' ');\r
+      APPEND_STRING(short_months[(ptime->month - 1)]);\r
+      APPEND(' ');\r
+      APPEND_NUMBER(PNG_NUMBER_FORMAT_u, ptime->year);\r
+      APPEND(' ');\r
+      APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->hour);\r
+      APPEND(':');\r
+      APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->minute);\r
+      APPEND(':');\r
+      APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->second);\r
+      APPEND_STRING(" +0000"); /* This reliably terminates the buffer */\r
+\r
+#     undef APPEND\r
+#     undef APPEND_NUMBER\r
+#     undef APPEND_STRING\r
+   }\r
+\r
+   return 1;\r
+}\r
+\r
+#     if PNG_LIBPNG_VER < 10700\r
+/* To do: remove the following from libpng-1.7 */\r
+/* Original API that uses a private buffer in png_struct.\r
+ * Deprecated because it causes png_struct to carry a spurious temporary\r
+ * buffer (png_struct::time_buffer), better to have the caller pass this in.\r
+ */\r
+png_const_charp PNGAPI\r
+png_convert_to_rfc1123(png_structrp png_ptr, png_const_timep ptime)\r
+{\r
+   if (png_ptr != NULL)\r
+   {\r
+      /* The only failure above if png_ptr != NULL is from an invalid ptime */\r
+      if (!png_convert_to_rfc1123_buffer(png_ptr->time_buffer, ptime))\r
+         png_warning(png_ptr, "Ignoring invalid time value");\r
+\r
+      else\r
+         return png_ptr->time_buffer;\r
+   }\r
+\r
+   return NULL;\r
+}\r
+#     endif\r
+#  endif /* PNG_TIME_RFC1123_SUPPORTED */\r
+\r
+#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */\r
+\r
+png_const_charp PNGAPI\r
+png_get_copyright(png_const_structrp png_ptr)\r
+{\r
+   PNG_UNUSED(png_ptr)  /* Silence compiler warning about unused png_ptr */\r
+#ifdef PNG_STRING_COPYRIGHT\r
+   return PNG_STRING_COPYRIGHT\r
+#else\r
+#  ifdef __STDC__\r
+   return PNG_STRING_NEWLINE \\r
+     "libpng version 1.6.3 - July 18, 2013" PNG_STRING_NEWLINE \\r
+     "Copyright (c) 1998-2013 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \\r
+     "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \\r
+     "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \\r
+     PNG_STRING_NEWLINE;\r
+#  else\r
+      return "libpng version 1.6.3 - July 18, 2013\\r
+      Copyright (c) 1998-2013 Glenn Randers-Pehrson\\r
+      Copyright (c) 1996-1997 Andreas Dilger\\r
+      Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.";\r
+#  endif\r
+#endif\r
+}\r
+\r
+/* The following return the library version as a short string in the\r
+ * format 1.0.0 through 99.99.99zz.  To get the version of *.h files\r
+ * used with your application, print out PNG_LIBPNG_VER_STRING, which\r
+ * is defined in png.h.\r
+ * Note: now there is no difference between png_get_libpng_ver() and\r
+ * png_get_header_ver().  Due to the version_nn_nn_nn typedef guard,\r
+ * it is guaranteed that png.c uses the correct version of png.h.\r
+ */\r
+png_const_charp PNGAPI\r
+png_get_libpng_ver(png_const_structrp png_ptr)\r
+{\r
+   /* Version of *.c files used when building libpng */\r
+   return png_get_header_ver(png_ptr);\r
+}\r
+\r
+png_const_charp PNGAPI\r
+png_get_header_ver(png_const_structrp png_ptr)\r
+{\r
+   /* Version of *.h files used when building libpng */\r
+   PNG_UNUSED(png_ptr)  /* Silence compiler warning about unused png_ptr */\r
+   return PNG_LIBPNG_VER_STRING;\r
+}\r
+\r
+png_const_charp PNGAPI\r
+png_get_header_version(png_const_structrp png_ptr)\r
+{\r
+   /* Returns longer string containing both version and date */\r
+   PNG_UNUSED(png_ptr)  /* Silence compiler warning about unused png_ptr */\r
+#ifdef __STDC__\r
+   return PNG_HEADER_VERSION_STRING\r
+#  ifndef PNG_READ_SUPPORTED\r
+   "     (NO READ SUPPORT)"\r
+#  endif\r
+   PNG_STRING_NEWLINE;\r
+#else\r
+   return PNG_HEADER_VERSION_STRING;\r
+#endif\r
+}\r
+\r
+#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED\r
+int PNGAPI\r
+png_handle_as_unknown(png_const_structrp png_ptr, png_const_bytep chunk_name)\r
+{\r
+   /* Check chunk_name and return "keep" value if it's on the list, else 0 */\r
+   png_const_bytep p, p_end;\r
+\r
+   if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list == 0)\r
+      return PNG_HANDLE_CHUNK_AS_DEFAULT;\r
+\r
+   p_end = png_ptr->chunk_list;\r
+   p = p_end + png_ptr->num_chunk_list*5; /* beyond end */\r
+\r
+   /* The code is the fifth byte after each four byte string.  Historically this\r
+    * code was always searched from the end of the list, this is no longer\r
+    * necessary because the 'set' routine handles duplicate entries correcty.\r
+    */\r
+   do /* num_chunk_list > 0, so at least one */\r
+   {\r
+      p -= 5;\r
+\r
+      if (!memcmp(chunk_name, p, 4))\r
+         return p[4];\r
+   }\r
+   while (p > p_end);\r
+\r
+   /* This means that known chunks should be processed and unknown chunks should\r
+    * be handled according to the value of png_ptr->unknown_default; this can be\r
+    * confusing because, as a result, there are two levels of defaulting for\r
+    * unknown chunks.\r
+    */\r
+   return PNG_HANDLE_CHUNK_AS_DEFAULT;\r
+}\r
+\r
+#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED\r
+int /* PRIVATE */\r
+png_chunk_unknown_handling(png_const_structrp png_ptr, png_uint_32 chunk_name)\r
+{\r
+   png_byte chunk_string[5];\r
+\r
+   PNG_CSTRING_FROM_CHUNK(chunk_string, chunk_name);\r
+   return png_handle_as_unknown(png_ptr, chunk_string);\r
+}\r
+#endif /* READ_UNKNOWN_CHUNKS */\r
+#endif /* SET_UNKNOWN_CHUNKS */\r
+\r
+#ifdef PNG_READ_SUPPORTED\r
+/* This function, added to libpng-1.0.6g, is untested. */\r
+int PNGAPI\r
+png_reset_zstream(png_structrp png_ptr)\r
+{\r
+   if (png_ptr == NULL)\r
+      return Z_STREAM_ERROR;\r
+\r
+   /* WARNING: this resets the window bits to the maximum! */\r
+   return (inflateReset(&png_ptr->zstream));\r
+}\r
+#endif /* PNG_READ_SUPPORTED */\r
+\r
+/* This function was added to libpng-1.0.7 */\r
+png_uint_32 PNGAPI\r
+png_access_version_number(void)\r
+{\r
+   /* Version of *.c files used when building libpng */\r
+   return((png_uint_32)PNG_LIBPNG_VER);\r
+}\r
+\r
+\r
+\r
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)\r
+/* Ensure that png_ptr->zstream.msg holds some appropriate error message string.\r
+ * If it doesn't 'ret' is used to set it to something appropriate, even in cases\r
+ * like Z_OK or Z_STREAM_END where the error code is apparently a success code.\r
+ */\r
+void /* PRIVATE */\r
+png_zstream_error(png_structrp png_ptr, int ret)\r
+{\r
+   /* Translate 'ret' into an appropriate error string, priority is given to the\r
+    * one in zstream if set.  This always returns a string, even in cases like\r
+    * Z_OK or Z_STREAM_END where the error code is a success code.\r
+    */\r
+   if (png_ptr->zstream.msg == NULL) switch (ret)\r
+   {\r
+      default:\r
+      case Z_OK:\r
+         png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return code");\r
+         break;\r
+\r
+      case Z_STREAM_END:\r
+         /* Normal exit */\r
+         png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected end of LZ stream");\r
+         break;\r
+\r
+      case Z_NEED_DICT:\r
+         /* This means the deflate stream did not have a dictionary; this\r
+          * indicates a bogus PNG.\r
+          */\r
+         png_ptr->zstream.msg = PNGZ_MSG_CAST("missing LZ dictionary");\r
+         break;\r
+\r
+      case Z_ERRNO:\r
+         /* gz APIs only: should not happen */\r
+         png_ptr->zstream.msg = PNGZ_MSG_CAST("zlib IO error");\r
+         break;\r
+\r
+      case Z_STREAM_ERROR:\r
+         /* internal libpng error */\r
+         png_ptr->zstream.msg = PNGZ_MSG_CAST("bad parameters to zlib");\r
+         break;\r
+\r
+      case Z_DATA_ERROR:\r
+         png_ptr->zstream.msg = PNGZ_MSG_CAST("damaged LZ stream");\r
+         break;\r
+\r
+      case Z_MEM_ERROR:\r
+         png_ptr->zstream.msg = PNGZ_MSG_CAST("insufficient memory");\r
+         break;\r
+\r
+      case Z_BUF_ERROR:\r
+         /* End of input or output; not a problem if the caller is doing\r
+          * incremental read or write.\r
+          */\r
+         png_ptr->zstream.msg = PNGZ_MSG_CAST("truncated");\r
+         break;\r
+\r
+      case Z_VERSION_ERROR:\r
+         png_ptr->zstream.msg = PNGZ_MSG_CAST("unsupported zlib version");\r
+         break;\r
+\r
+      case PNG_UNEXPECTED_ZLIB_RETURN:\r
+         /* Compile errors here mean that zlib now uses the value co-opted in\r
+          * pngpriv.h for PNG_UNEXPECTED_ZLIB_RETURN; update the switch above\r
+          * and change pngpriv.h.  Note that this message is "... return",\r
+          * whereas the default/Z_OK one is "... return code".\r
+          */\r
+         png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return");\r
+         break;\r
+   }\r
+}\r
+\r
+/* png_convert_size: a PNGAPI but no longer in png.h, so deleted\r
+ * at libpng 1.5.5!\r
+ */\r
+\r
+/* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */\r
+#ifdef PNG_GAMMA_SUPPORTED /* always set if COLORSPACE */\r
+static int\r
+png_colorspace_check_gamma(png_const_structrp png_ptr,\r
+   png_colorspacerp colorspace, png_fixed_point gAMA, int from)\r
+   /* This is called to check a new gamma value against an existing one.  The\r
+    * routine returns false if the new gamma value should not be written.\r
+    *\r
+    * 'from' says where the new gamma value comes from:\r
+    *\r
+    *    0: the new gamma value is the libpng estimate for an ICC profile\r
+    *    1: the new gamma value comes from a gAMA chunk\r
+    *    2: the new gamma value comes from an sRGB chunk\r
+    */\r
+{\r
+   png_fixed_point gtest;\r
+\r
+   if ((colorspace->flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 &&\r
+      (!png_muldiv(&gtest, colorspace->gamma, PNG_FP_1, gAMA) ||\r
+      png_gamma_significant(gtest)))\r
+   {\r
+      /* Either this is an sRGB image, in which case the calculated gamma\r
+       * approximation should match, or this is an image with a profile and the\r
+       * value libpng calculates for the gamma of the profile does not match the\r
+       * value recorded in the file.  The former, sRGB, case is an error, the\r
+       * latter is just a warning.\r
+       */\r
+      if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0 || from == 2)\r
+      {\r
+         png_chunk_report(png_ptr, "gamma value does not match sRGB",\r
+            PNG_CHUNK_ERROR);\r
+         /* Do not overwrite an sRGB value */\r
+         return from == 2;\r
+      }\r
+\r
+      else /* sRGB tag not involved */\r
+      {\r
+         png_chunk_report(png_ptr, "gamma value does not match libpng estimate",\r
+            PNG_CHUNK_WARNING);\r
+         return from == 1;\r
+      }\r
+   }\r
+\r
+   return 1;\r
+}\r
+\r
+void /* PRIVATE */\r
+png_colorspace_set_gamma(png_const_structrp png_ptr,\r
+   png_colorspacerp colorspace, png_fixed_point gAMA)\r
+{\r
+   /* Changed in libpng-1.5.4 to limit the values to ensure overflow can't\r
+    * occur.  Since the fixed point representation is assymetrical it is\r
+    * possible for 1/gamma to overflow the limit of 21474 and this means the\r
+    * gamma value must be at least 5/100000 and hence at most 20000.0.  For\r
+    * safety the limits here are a little narrower.  The values are 0.00016 to\r
+    * 6250.0, which are truly ridiculous gamma values (and will produce\r
+    * displays that are all black or all white.)\r
+    *\r
+    * In 1.6.0 this test replaces the ones in pngrutil.c, in the gAMA chunk\r
+    * handling code, which only required the value to be >0.\r
+    */\r
+   png_const_charp errmsg;\r
+\r
+   if (gAMA < 16 || gAMA > 625000000)\r
+      errmsg = "gamma value out of range";\r
+\r
+#  ifdef PNG_READ_gAMA_SUPPORTED\r
+      /* Allow the application to set the gamma value more than once */\r
+      else if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&\r
+         (colorspace->flags & PNG_COLORSPACE_FROM_gAMA) != 0)\r
+         errmsg = "duplicate";\r
+#  endif\r
+\r
+   /* Do nothing if the colorspace is already invalid */\r
+   else if (colorspace->flags & PNG_COLORSPACE_INVALID)\r
+      return;\r
+\r
+   else\r
+   {\r
+      if (png_colorspace_check_gamma(png_ptr, colorspace, gAMA, 1/*from gAMA*/))\r
+      {\r
+         /* Store this gamma value. */\r
+         colorspace->gamma = gAMA;\r
+         colorspace->flags |=\r
+            (PNG_COLORSPACE_HAVE_GAMMA | PNG_COLORSPACE_FROM_gAMA);\r
+      }\r
+\r
+      /* At present if the check_gamma test fails the gamma of the colorspace is\r
+       * not updated however the colorspace is not invalidated.  This\r
+       * corresponds to the case where the existing gamma comes from an sRGB\r
+       * chunk or profile.  An error message has already been output.\r
+       */\r
+      return;\r
+   }\r
+\r
+   /* Error exit - errmsg has been set. */\r
+   colorspace->flags |= PNG_COLORSPACE_INVALID;\r
+   png_chunk_report(png_ptr, errmsg, PNG_CHUNK_WRITE_ERROR);\r
+}\r
+\r
+void /* PRIVATE */\r
+png_colorspace_sync_info(png_const_structrp png_ptr, png_inforp info_ptr)\r
+{\r
+   if (info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID)\r
+   {\r
+      /* Everything is invalid */\r
+      info_ptr->valid &= ~(PNG_INFO_gAMA|PNG_INFO_cHRM|PNG_INFO_sRGB|\r
+         PNG_INFO_iCCP);\r
+\r
+#     ifdef PNG_COLORSPACE_SUPPORTED\r
+         /* Clean up the iCCP profile now if it won't be used. */\r
+         png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, -1/*not used*/);\r
+#     else\r
+         PNG_UNUSED(png_ptr)\r
+#     endif\r
+   }\r
+\r
+   else\r
+   {\r
+#     ifdef PNG_COLORSPACE_SUPPORTED\r
+         /* Leave the INFO_iCCP flag set if the pngset.c code has already set\r
+          * it; this allows a PNG to contain a profile which matches sRGB and\r
+          * yet still have that profile retrievable by the application.\r
+          */\r
+         if (info_ptr->colorspace.flags & PNG_COLORSPACE_MATCHES_sRGB)\r
+            info_ptr->valid |= PNG_INFO_sRGB;\r
+\r
+         else\r
+            info_ptr->valid &= ~PNG_INFO_sRGB;\r
+\r
+         if (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS)\r
+            info_ptr->valid |= PNG_INFO_cHRM;\r
+\r
+         else\r
+            info_ptr->valid &= ~PNG_INFO_cHRM;\r
+#     endif\r
+\r
+      if (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA)\r
+         info_ptr->valid |= PNG_INFO_gAMA;\r
+\r
+      else\r
+         info_ptr->valid &= ~PNG_INFO_gAMA;\r
+   }\r
+}\r
+\r
+#ifdef PNG_READ_SUPPORTED\r
+void /* PRIVATE */\r
+png_colorspace_sync(png_const_structrp png_ptr, png_inforp info_ptr)\r
+{\r
+   if (info_ptr == NULL) /* reduce code size; check here not in the caller */\r
+      return;\r
+\r
+   info_ptr->colorspace = png_ptr->colorspace;\r
+   png_colorspace_sync_info(png_ptr, info_ptr);\r
+}\r
+#endif\r
+#endif\r
+\r
+#ifdef PNG_COLORSPACE_SUPPORTED\r
+/* Added at libpng-1.5.5 to support read and write of true CIEXYZ values for\r
+ * cHRM, as opposed to using chromaticities.  These internal APIs return\r
+ * non-zero on a parameter error.  The X, Y and Z values are required to be\r
+ * positive and less than 1.0.\r
+ */\r
+static int\r
+png_xy_from_XYZ(png_xy *xy, const png_XYZ *XYZ)\r
+{\r
+   png_int_32 d, dwhite, whiteX, whiteY;\r
+\r
+   d = XYZ->red_X + XYZ->red_Y + XYZ->red_Z;\r
+   if (!png_muldiv(&xy->redx, XYZ->red_X, PNG_FP_1, d)) return 1;\r
+   if (!png_muldiv(&xy->redy, XYZ->red_Y, PNG_FP_1, d)) return 1;\r
+   dwhite = d;\r
+   whiteX = XYZ->red_X;\r
+   whiteY = XYZ->red_Y;\r
+\r
+   d = XYZ->green_X + XYZ->green_Y + XYZ->green_Z;\r
+   if (!png_muldiv(&xy->greenx, XYZ->green_X, PNG_FP_1, d)) return 1;\r
+   if (!png_muldiv(&xy->greeny, XYZ->green_Y, PNG_FP_1, d)) return 1;\r
+   dwhite += d;\r
+   whiteX += XYZ->green_X;\r
+   whiteY += XYZ->green_Y;\r
+\r
+   d = XYZ->blue_X + XYZ->blue_Y + XYZ->blue_Z;\r
+   if (!png_muldiv(&xy->bluex, XYZ->blue_X, PNG_FP_1, d)) return 1;\r
+   if (!png_muldiv(&xy->bluey, XYZ->blue_Y, PNG_FP_1, d)) return 1;\r
+   dwhite += d;\r
+   whiteX += XYZ->blue_X;\r
+   whiteY += XYZ->blue_Y;\r
+\r
+   /* The reference white is simply the sum of the end-point (X,Y,Z) vectors,\r
+    * thus:\r
+    */\r
+   if (!png_muldiv(&xy->whitex, whiteX, PNG_FP_1, dwhite)) return 1;\r
+   if (!png_muldiv(&xy->whitey, whiteY, PNG_FP_1, dwhite)) return 1;\r
+\r
+   return 0;\r
+}\r
+\r
+static int\r
+png_XYZ_from_xy(png_XYZ *XYZ, const png_xy *xy)\r
+{\r
+   png_fixed_point red_inverse, green_inverse, blue_scale;\r
+   png_fixed_point left, right, denominator;\r
+\r
+   /* Check xy and, implicitly, z.  Note that wide gamut color spaces typically\r
+    * have end points with 0 tristimulus values (these are impossible end\r
+    * points, but they are used to cover the possible colors.)\r
+    */\r
+   if (xy->redx < 0 || xy->redx > PNG_FP_1) return 1;\r
+   if (xy->redy < 0 || xy->redy > PNG_FP_1-xy->redx) return 1;\r
+   if (xy->greenx < 0 || xy->greenx > PNG_FP_1) return 1;\r
+   if (xy->greeny < 0 || xy->greeny > PNG_FP_1-xy->greenx) return 1;\r
+   if (xy->bluex < 0 || xy->bluex > PNG_FP_1) return 1;\r
+   if (xy->bluey < 0 || xy->bluey > PNG_FP_1-xy->bluex) return 1;\r
+   if (xy->whitex < 0 || xy->whitex > PNG_FP_1) return 1;\r
+   if (xy->whitey < 0 || xy->whitey > PNG_FP_1-xy->whitex) return 1;\r
+\r
+   /* The reverse calculation is more difficult because the original tristimulus\r
+    * value had 9 independent values (red,green,blue)x(X,Y,Z) however only 8\r
+    * derived values were recorded in the cHRM chunk;\r
+    * (red,green,blue,white)x(x,y).  This loses one degree of freedom and\r
+    * therefore an arbitrary ninth value has to be introduced to undo the\r
+    * original transformations.\r
+    *\r
+    * Think of the original end-points as points in (X,Y,Z) space.  The\r
+    * chromaticity values (c) have the property:\r
+    *\r
+    *           C\r
+    *   c = ---------\r
+    *       X + Y + Z\r
+    *\r
+    * For each c (x,y,z) from the corresponding original C (X,Y,Z).  Thus the\r
+    * three chromaticity values (x,y,z) for each end-point obey the\r
+    * relationship:\r
+    *\r
+    *   x + y + z = 1\r
+    *\r
+    * This describes the plane in (X,Y,Z) space that intersects each axis at the\r
+    * value 1.0; call this the chromaticity plane.  Thus the chromaticity\r
+    * calculation has scaled each end-point so that it is on the x+y+z=1 plane\r
+    * and chromaticity is the intersection of the vector from the origin to the\r
+    * (X,Y,Z) value with the chromaticity plane.\r
+    *\r
+    * To fully invert the chromaticity calculation we would need the three\r
+    * end-point scale factors, (red-scale, green-scale, blue-scale), but these\r
+    * were not recorded.  Instead we calculated the reference white (X,Y,Z) and\r
+    * recorded the chromaticity of this.  The reference white (X,Y,Z) would have\r
+    * given all three of the scale factors since:\r
+    *\r
+    *    color-C = color-c * color-scale\r
+    *    white-C = red-C + green-C + blue-C\r
+    *            = red-c*red-scale + green-c*green-scale + blue-c*blue-scale\r
+    *\r
+    * But cHRM records only white-x and white-y, so we have lost the white scale\r
+    * factor:\r
+    *\r
+    *    white-C = white-c*white-scale\r
+    *\r
+    * To handle this the inverse transformation makes an arbitrary assumption\r
+    * about white-scale:\r
+    *\r
+    *    Assume: white-Y = 1.0\r
+    *    Hence:  white-scale = 1/white-y\r
+    *    Or:     red-Y + green-Y + blue-Y = 1.0\r
+    *\r
+    * Notice the last statement of the assumption gives an equation in three of\r
+    * the nine values we want to calculate.  8 more equations come from the\r
+    * above routine as summarised at the top above (the chromaticity\r
+    * calculation):\r
+    *\r
+    *    Given: color-x = color-X / (color-X + color-Y + color-Z)\r
+    *    Hence: (color-x - 1)*color-X + color.x*color-Y + color.x*color-Z = 0\r
+    *\r
+    * This is 9 simultaneous equations in the 9 variables "color-C" and can be\r
+    * solved by Cramer's rule.  Cramer's rule requires calculating 10 9x9 matrix\r
+    * determinants, however this is not as bad as it seems because only 28 of\r
+    * the total of 90 terms in the various matrices are non-zero.  Nevertheless\r
+    * Cramer's rule is notoriously numerically unstable because the determinant\r
+    * calculation involves the difference of large, but similar, numbers.  It is\r
+    * difficult to be sure that the calculation is stable for real world values\r
+    * and it is certain that it becomes unstable where the end points are close\r
+    * together.\r
+    *\r
+    * So this code uses the perhaps slightly less optimal but more\r
+    * understandable and totally obvious approach of calculating color-scale.\r
+    *\r
+    * This algorithm depends on the precision in white-scale and that is\r
+    * (1/white-y), so we can immediately see that as white-y approaches 0 the\r
+    * accuracy inherent in the cHRM chunk drops off substantially.\r
+    *\r
+    * libpng arithmetic: a simple invertion of the above equations\r
+    * ------------------------------------------------------------\r
+    *\r
+    *    white_scale = 1/white-y\r
+    *    white-X = white-x * white-scale\r
+    *    white-Y = 1.0\r
+    *    white-Z = (1 - white-x - white-y) * white_scale\r
+    *\r
+    *    white-C = red-C + green-C + blue-C\r
+    *            = red-c*red-scale + green-c*green-scale + blue-c*blue-scale\r
+    *\r
+    * This gives us three equations in (red-scale,green-scale,blue-scale) where\r
+    * all the coefficients are now known:\r
+    *\r
+    *    red-x*red-scale + green-x*green-scale + blue-x*blue-scale\r
+    *       = white-x/white-y\r
+    *    red-y*red-scale + green-y*green-scale + blue-y*blue-scale = 1\r
+    *    red-z*red-scale + green-z*green-scale + blue-z*blue-scale\r
+    *       = (1 - white-x - white-y)/white-y\r
+    *\r
+    * In the last equation color-z is (1 - color-x - color-y) so we can add all\r
+    * three equations together to get an alternative third:\r
+    *\r
+    *    red-scale + green-scale + blue-scale = 1/white-y = white-scale\r
+    *\r
+    * So now we have a Cramer's rule solution where the determinants are just\r
+    * 3x3 - far more tractible.  Unfortunately 3x3 determinants still involve\r
+    * multiplication of three coefficients so we can't guarantee to avoid\r
+    * overflow in the libpng fixed point representation.  Using Cramer's rule in\r
+    * floating point is probably a good choice here, but it's not an option for\r
+    * fixed point.  Instead proceed to simplify the first two equations by\r
+    * eliminating what is likely to be the largest value, blue-scale:\r
+    *\r
+    *    blue-scale = white-scale - red-scale - green-scale\r
+    *\r
+    * Hence:\r
+    *\r
+    *    (red-x - blue-x)*red-scale + (green-x - blue-x)*green-scale =\r
+    *                (white-x - blue-x)*white-scale\r
+    *\r
+    *    (red-y - blue-y)*red-scale + (green-y - blue-y)*green-scale =\r
+    *                1 - blue-y*white-scale\r
+    *\r
+    * And now we can trivially solve for (red-scale,green-scale):\r
+    *\r
+    *    green-scale =\r
+    *                (white-x - blue-x)*white-scale - (red-x - blue-x)*red-scale\r
+    *                -----------------------------------------------------------\r
+    *                                  green-x - blue-x\r
+    *\r
+    *    red-scale =\r
+    *                1 - blue-y*white-scale - (green-y - blue-y) * green-scale\r
+    *                ---------------------------------------------------------\r
+    *                                  red-y - blue-y\r
+    *\r
+    * Hence:\r
+    *\r
+    *    red-scale =\r
+    *          ( (green-x - blue-x) * (white-y - blue-y) -\r
+    *            (green-y - blue-y) * (white-x - blue-x) ) / white-y\r
+    * -------------------------------------------------------------------------\r
+    *  (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x)\r
+    *\r
+    *    green-scale =\r
+    *          ( (red-y - blue-y) * (white-x - blue-x) -\r
+    *            (red-x - blue-x) * (white-y - blue-y) ) / white-y\r
+    * -------------------------------------------------------------------------\r
+    *  (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x)\r
+    *\r
+    * Accuracy:\r
+    * The input values have 5 decimal digits of accuracy.  The values are all in\r
+    * the range 0 < value < 1, so simple products are in the same range but may\r
+    * need up to 10 decimal digits to preserve the original precision and avoid\r
+    * underflow.  Because we are using a 32-bit signed representation we cannot\r
+    * match this; the best is a little over 9 decimal digits, less than 10.\r
+    *\r
+    * The approach used here is to preserve the maximum precision within the\r
+    * signed representation.  Because the red-scale calculation above uses the\r
+    * difference between two products of values that must be in the range -1..+1\r
+    * it is sufficient to divide the product by 7; ceil(100,000/32767*2).  The\r
+    * factor is irrelevant in the calculation because it is applied to both\r
+    * numerator and denominator.\r
+    *\r
+    * Note that the values of the differences of the products of the\r
+    * chromaticities in the above equations tend to be small, for example for\r
+    * the sRGB chromaticities they are:\r
+    *\r
+    * red numerator:    -0.04751\r
+    * green numerator:  -0.08788\r
+    * denominator:      -0.2241 (without white-y multiplication)\r
+    *\r
+    *  The resultant Y coefficients from the chromaticities of some widely used\r
+    *  color space definitions are (to 15 decimal places):\r
+    *\r
+    *  sRGB\r
+    *    0.212639005871510 0.715168678767756 0.072192315360734\r
+    *  Kodak ProPhoto\r
+    *    0.288071128229293 0.711843217810102 0.000085653960605\r
+    *  Adobe RGB\r
+    *    0.297344975250536 0.627363566255466 0.075291458493998\r
+    *  Adobe Wide Gamut RGB\r
+    *    0.258728243040113 0.724682314948566 0.016589442011321\r
+    */\r
+   /* By the argument, above overflow should be impossible here. The return\r
+    * value of 2 indicates an internal error to the caller.\r
+    */\r
+   if (!png_muldiv(&left, xy->greenx-xy->bluex, xy->redy - xy->bluey, 7))\r
+      return 2;\r
+   if (!png_muldiv(&right, xy->greeny-xy->bluey, xy->redx - xy->bluex, 7))\r
+      return 2;\r
+   denominator = left - right;\r
+\r
+   /* Now find the red numerator. */\r
+   if (!png_muldiv(&left, xy->greenx-xy->bluex, xy->whitey-xy->bluey, 7))\r
+      return 2;\r
+   if (!png_muldiv(&right, xy->greeny-xy->bluey, xy->whitex-xy->bluex, 7))\r
+      return 2;\r
+\r
+   /* Overflow is possible here and it indicates an extreme set of PNG cHRM\r
+    * chunk values.  This calculation actually returns the reciprocal of the\r
+    * scale value because this allows us to delay the multiplication of white-y\r
+    * into the denominator, which tends to produce a small number.\r
+    */\r
+   if (!png_muldiv(&red_inverse, xy->whitey, denominator, left-right) ||\r
+       red_inverse <= xy->whitey /* r+g+b scales = white scale */)\r
+      return 1;\r
+\r
+   /* Similarly for green_inverse: */\r
+   if (!png_muldiv(&left, xy->redy-xy->bluey, xy->whitex-xy->bluex, 7))\r
+      return 2;\r
+   if (!png_muldiv(&right, xy->redx-xy->bluex, xy->whitey-xy->bluey, 7))\r
+      return 2;\r
+   if (!png_muldiv(&green_inverse, xy->whitey, denominator, left-right) ||\r
+       green_inverse <= xy->whitey)\r
+      return 1;\r
+\r
+   /* And the blue scale, the checks above guarantee this can't overflow but it\r
+    * can still produce 0 for extreme cHRM values.\r
+    */\r
+   blue_scale = png_reciprocal(xy->whitey) - png_reciprocal(red_inverse) -\r
+      png_reciprocal(green_inverse);\r
+   if (blue_scale <= 0) return 1;\r
+\r
+\r
+   /* And fill in the png_XYZ: */\r
+   if (!png_muldiv(&XYZ->red_X, xy->redx, PNG_FP_1, red_inverse)) return 1;\r
+   if (!png_muldiv(&XYZ->red_Y, xy->redy, PNG_FP_1, red_inverse)) return 1;\r
+   if (!png_muldiv(&XYZ->red_Z, PNG_FP_1 - xy->redx - xy->redy, PNG_FP_1,\r
+      red_inverse))\r
+      return 1;\r
+\r
+   if (!png_muldiv(&XYZ->green_X, xy->greenx, PNG_FP_1, green_inverse))\r
+      return 1;\r
+   if (!png_muldiv(&XYZ->green_Y, xy->greeny, PNG_FP_1, green_inverse))\r
+      return 1;\r
+   if (!png_muldiv(&XYZ->green_Z, PNG_FP_1 - xy->greenx - xy->greeny, PNG_FP_1,\r
+      green_inverse))\r
+      return 1;\r
+\r
+   if (!png_muldiv(&XYZ->blue_X, xy->bluex, blue_scale, PNG_FP_1)) return 1;\r
+   if (!png_muldiv(&XYZ->blue_Y, xy->bluey, blue_scale, PNG_FP_1)) return 1;\r
+   if (!png_muldiv(&XYZ->blue_Z, PNG_FP_1 - xy->bluex - xy->bluey, blue_scale,\r
+      PNG_FP_1))\r
+      return 1;\r
+\r
+   return 0; /*success*/\r
+}\r
+\r
+static int\r
+png_XYZ_normalize(png_XYZ *XYZ)\r
+{\r
+   png_int_32 Y;\r
+\r
+   if (XYZ->red_Y < 0 || XYZ->green_Y < 0 || XYZ->blue_Y < 0 ||\r
+      XYZ->red_X < 0 || XYZ->green_X < 0 || XYZ->blue_X < 0 ||\r
+      XYZ->red_Z < 0 || XYZ->green_Z < 0 || XYZ->blue_Z < 0)\r
+      return 1;\r
+\r
+   /* Normalize by scaling so the sum of the end-point Y values is PNG_FP_1.\r
+    * IMPLEMENTATION NOTE: ANSI requires signed overflow not to occur, therefore\r
+    * relying on addition of two positive values producing a negative one is not\r
+    * safe.\r
+    */\r
+   Y = XYZ->red_Y;\r
+   if (0x7fffffff - Y < XYZ->green_X) return 1;\r
+   Y += XYZ->green_Y;\r
+   if (0x7fffffff - Y < XYZ->blue_X) return 1;\r
+   Y += XYZ->blue_Y;\r
+\r
+   if (Y != PNG_FP_1)\r
+   {\r
+      if (!png_muldiv(&XYZ->red_X, XYZ->red_X, PNG_FP_1, Y)) return 1;\r
+      if (!png_muldiv(&XYZ->red_Y, XYZ->red_Y, PNG_FP_1, Y)) return 1;\r
+      if (!png_muldiv(&XYZ->red_Z, XYZ->red_Z, PNG_FP_1, Y)) return 1;\r
+\r
+      if (!png_muldiv(&XYZ->green_X, XYZ->green_X, PNG_FP_1, Y)) return 1;\r
+      if (!png_muldiv(&XYZ->green_Y, XYZ->green_Y, PNG_FP_1, Y)) return 1;\r
+      if (!png_muldiv(&XYZ->green_Z, XYZ->green_Z, PNG_FP_1, Y)) return 1;\r
+\r
+      if (!png_muldiv(&XYZ->blue_X, XYZ->blue_X, PNG_FP_1, Y)) return 1;\r
+      if (!png_muldiv(&XYZ->blue_Y, XYZ->blue_Y, PNG_FP_1, Y)) return 1;\r
+      if (!png_muldiv(&XYZ->blue_Z, XYZ->blue_Z, PNG_FP_1, Y)) return 1;\r
+   }\r
+\r
+   return 0;\r
+}\r
+\r
+static int\r
+png_colorspace_endpoints_match(const png_xy *xy1, const png_xy *xy2, int delta)\r
+{\r
+   /* Allow an error of +/-0.01 (absolute value) on each chromaticity */\r
+   return !(PNG_OUT_OF_RANGE(xy1->whitex, xy2->whitex,delta) ||\r
+      PNG_OUT_OF_RANGE(xy1->whitey, xy2->whitey,delta) ||\r
+      PNG_OUT_OF_RANGE(xy1->redx,   xy2->redx,  delta) ||\r
+      PNG_OUT_OF_RANGE(xy1->redy,   xy2->redy,  delta) ||\r
+      PNG_OUT_OF_RANGE(xy1->greenx, xy2->greenx,delta) ||\r
+      PNG_OUT_OF_RANGE(xy1->greeny, xy2->greeny,delta) ||\r
+      PNG_OUT_OF_RANGE(xy1->bluex,  xy2->bluex, delta) ||\r
+      PNG_OUT_OF_RANGE(xy1->bluey,  xy2->bluey, delta));\r
+}\r
+\r
+/* Added in libpng-1.6.0, a different check for the validity of a set of cHRM\r
+ * chunk chromaticities.  Earlier checks used to simply look for the overflow\r
+ * condition (where the determinant of the matrix to solve for XYZ ends up zero\r
+ * because the chromaticity values are not all distinct.)  Despite this it is\r
+ * theoretically possible to produce chromaticities that are apparently valid\r
+ * but that rapidly degrade to invalid, potentially crashing, sets because of\r
+ * arithmetic inaccuracies when calculations are performed on them.  The new\r
+ * check is to round-trip xy -> XYZ -> xy and then check that the result is\r
+ * within a small percentage of the original.\r
+ */\r
+static int\r
+png_colorspace_check_xy(png_XYZ *XYZ, const png_xy *xy)\r
+{\r
+   int result;\r
+   png_xy xy_test;\r
+\r
+   /* As a side-effect this routine also returns the XYZ endpoints. */\r
+   result = png_XYZ_from_xy(XYZ, xy);\r
+   if (result) return result;\r
+\r
+   result = png_xy_from_XYZ(&xy_test, XYZ);\r
+   if (result) return result;\r
+\r
+   if (png_colorspace_endpoints_match(xy, &xy_test,\r
+      5/*actually, the math is pretty accurate*/))\r
+      return 0;\r
+\r
+   /* Too much slip */\r
+   return 1;\r
+}\r
+\r
+/* This is the check going the other way.  The XYZ is modified to normalize it\r
+ * (another side-effect) and the xy chromaticities are returned.\r
+ */\r
+static int\r
+png_colorspace_check_XYZ(png_xy *xy, png_XYZ *XYZ)\r
+{\r
+   int result;\r
+   png_XYZ XYZtemp;\r
+\r
+   result = png_XYZ_normalize(XYZ);\r
+   if (result) return result;\r
+\r
+   result = png_xy_from_XYZ(xy, XYZ);\r
+   if (result) return result;\r
+\r
+   XYZtemp = *XYZ;\r
+   return png_colorspace_check_xy(&XYZtemp, xy);\r
+}\r
+\r
+/* Used to check for an endpoint match against sRGB */\r
+static const png_xy sRGB_xy = /* From ITU-R BT.709-3 */\r
+{\r
+   /* color      x       y */\r
+   /* red   */ 64000, 33000,\r
+   /* green */ 30000, 60000,\r
+   /* blue  */ 15000,  6000,\r
+   /* white */ 31270, 32900\r
+};\r
+\r
+static int\r
+png_colorspace_set_xy_and_XYZ(png_const_structrp png_ptr,\r
+   png_colorspacerp colorspace, const png_xy *xy, const png_XYZ *XYZ,\r
+   int preferred)\r
+{\r
+   if (colorspace->flags & PNG_COLORSPACE_INVALID)\r
+      return 0;\r
+\r
+   /* The consistency check is performed on the chromaticities; this factors out\r
+    * variations because of the normalization (or not) of the end point Y\r
+    * values.\r
+    */\r
+   if (preferred < 2 && (colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS))\r
+   {\r
+      /* The end points must be reasonably close to any we already have.  The\r
+       * following allows an error of up to +/-.001\r
+       */\r
+      if (!png_colorspace_endpoints_match(xy, &colorspace->end_points_xy, 100))\r
+      {\r
+         colorspace->flags |= PNG_COLORSPACE_INVALID;\r
+         png_benign_error(png_ptr, "inconsistent chromaticities");\r
+         return 0; /* failed */\r
+      }\r
+\r
+      /* Only overwrite with preferred values */\r
+      if (!preferred)\r
+         return 1; /* ok, but no change */\r
+   }\r
+\r
+   colorspace->end_points_xy = *xy;\r
+   colorspace->end_points_XYZ = *XYZ;\r
+   colorspace->flags |= PNG_COLORSPACE_HAVE_ENDPOINTS;\r
+\r
+   /* The end points are normally quoted to two decimal digits, so allow +/-0.01\r
+    * on this test.\r
+    */\r
+   if (png_colorspace_endpoints_match(xy, &sRGB_xy, 1000))\r
+      colorspace->flags |= PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB;\r
+\r
+   else\r
+      colorspace->flags &= PNG_COLORSPACE_CANCEL(\r
+         PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB);\r
+\r
+   return 2; /* ok and changed */\r
+}\r
+\r
+int /* PRIVATE */\r
+png_colorspace_set_chromaticities(png_const_structrp png_ptr,\r
+   png_colorspacerp colorspace, const png_xy *xy, int preferred)\r
+{\r
+   /* We must check the end points to ensure they are reasonable - in the past\r
+    * color management systems have crashed as a result of getting bogus\r
+    * colorant values, while this isn't the fault of libpng it is the\r
+    * responsibility of libpng because PNG carries the bomb and libpng is in a\r
+    * position to protect against it.\r
+    */\r
+   png_XYZ XYZ;\r
+\r
+   switch (png_colorspace_check_xy(&XYZ, xy))\r
+   {\r
+      case 0: /* success */\r
+         return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, xy, &XYZ,\r
+            preferred);\r
+\r
+      case 1:\r
+         /* We can't invert the chromaticities so we can't produce value XYZ\r
+          * values.  Likely as not a color management system will fail too.\r
+          */\r
+         colorspace->flags |= PNG_COLORSPACE_INVALID;\r
+         png_benign_error(png_ptr, "invalid chromaticities");\r
+         break;\r
+\r
+      default:\r
+         /* libpng is broken; this should be a warning but if it happens we\r
+          * want error reports so for the moment it is an error.\r
+          */\r
+         colorspace->flags |= PNG_COLORSPACE_INVALID;\r
+         png_error(png_ptr, "internal error checking chromaticities");\r
+         break;\r
+   }\r
+\r
+   return 0; /* failed */\r
+}\r
+\r
+int /* PRIVATE */\r
+png_colorspace_set_endpoints(png_const_structrp png_ptr,\r
+   png_colorspacerp colorspace, const png_XYZ *XYZ_in, int preferred)\r
+{\r
+   png_XYZ XYZ = *XYZ_in;\r
+   png_xy xy;\r
+\r
+   switch (png_colorspace_check_XYZ(&xy, &XYZ))\r
+   {\r
+      case 0:\r
+         return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, &xy, &XYZ,\r
+            preferred);\r
+\r
+      case 1:\r
+         /* End points are invalid. */\r
+         colorspace->flags |= PNG_COLORSPACE_INVALID;\r
+         png_benign_error(png_ptr, "invalid end points");\r
+         break;\r
+\r
+      default:\r
+         colorspace->flags |= PNG_COLORSPACE_INVALID;\r
+         png_error(png_ptr, "internal error checking chromaticities");\r
+         break;\r
+   }\r
+\r
+   return 0; /* failed */\r
+}\r
+\r
+#if defined(PNG_sRGB_SUPPORTED) || defined(PNG_iCCP_SUPPORTED)\r
+/* Error message generation */\r
+static char\r
+png_icc_tag_char(png_uint_32 byte)\r
+{\r
+   byte &= 0xff;\r
+   if (byte >= 32 && byte <= 126)\r
+      return (char)byte;\r
+   else\r
+      return '?';\r
+}\r
+\r
+static void\r
+png_icc_tag_name(char *name, png_uint_32 tag)\r
+{\r
+   name[0] = '\'';\r
+   name[1] = png_icc_tag_char(tag >> 24);\r
+   name[2] = png_icc_tag_char(tag >> 16);\r
+   name[3] = png_icc_tag_char(tag >>  8);\r
+   name[4] = png_icc_tag_char(tag      );\r
+   name[5] = '\'';\r
+}\r
+\r
+static int\r
+is_ICC_signature_char(png_alloc_size_t it)\r
+{\r
+   return it == 32 || (it >= 48 && it <= 57) || (it >= 65 && it <= 90) ||\r
+      (it >= 97 && it <= 122);\r
+}\r
+\r
+static int is_ICC_signature(png_alloc_size_t it)\r
+{\r
+   return is_ICC_signature_char(it >> 24) /* checks all the top bits */ &&\r
+      is_ICC_signature_char((it >> 16) & 0xff) &&\r
+      is_ICC_signature_char((it >> 8) & 0xff) &&\r
+      is_ICC_signature_char(it & 0xff);\r
+}\r
+\r
+static int\r
+png_icc_profile_error(png_const_structrp png_ptr, png_colorspacerp colorspace,\r
+   png_const_charp name, png_alloc_size_t value, png_const_charp reason)\r
+{\r
+   size_t pos;\r
+   char message[196]; /* see below for calculation */\r
+\r
+   if (colorspace != NULL)\r
+      colorspace->flags |= PNG_COLORSPACE_INVALID;\r
+\r
+   pos = png_safecat(message, (sizeof message), 0, "profile '"); /* 9 chars */\r
+   pos = png_safecat(message, pos+79, pos, name); /* Truncate to 79 chars */\r
+   pos = png_safecat(message, (sizeof message), pos, "': "); /* +2 = 90 */\r
+   if (is_ICC_signature(value))\r
+   {\r
+      /* So 'value' is at most 4 bytes and the following cast is safe */\r
+      png_icc_tag_name(message+pos, (png_uint_32)value);\r
+      pos += 6; /* total +8; less than the else clause */\r
+      message[pos++] = ':';\r
+      message[pos++] = ' ';\r
+   }\r
+#  ifdef PNG_WARNINGS_SUPPORTED\r
+   else\r
+      {\r
+         char number[PNG_NUMBER_BUFFER_SIZE]; /* +24 = 114*/\r
+\r
+         pos = png_safecat(message, (sizeof message), pos,\r
+            png_format_number(number, number+(sizeof number),\r
+               PNG_NUMBER_FORMAT_x, value));\r
+         pos = png_safecat(message, (sizeof message), pos, "h: "); /*+2 = 116*/\r
+      }\r
+#  endif\r
+   /* The 'reason' is an arbitrary message, allow +79 maximum 195 */\r
+   pos = png_safecat(message, (sizeof message), pos, reason);\r
+\r
+   /* This is recoverable, but make it unconditionally an app_error on write to\r
+    * avoid writing invalid ICC profiles into PNG files.  (I.e.  we handle them\r
+    * on read, with a warning, but on write unless the app turns off\r
+    * application errors the PNG won't be written.)\r
+    */\r
+   png_chunk_report(png_ptr, message,\r
+      (colorspace != NULL) ? PNG_CHUNK_ERROR : PNG_CHUNK_WRITE_ERROR);\r
+\r
+   return 0;\r
+}\r
+#endif /* sRGB || iCCP */\r
+\r
+#ifdef PNG_sRGB_SUPPORTED\r
+int /* PRIVATE */\r
+png_colorspace_set_sRGB(png_const_structrp png_ptr, png_colorspacerp colorspace,\r
+   int intent)\r
+{\r
+   /* sRGB sets known gamma, end points and (from the chunk) intent. */\r
+   /* IMPORTANT: these are not necessarily the values found in an ICC profile\r
+    * because ICC profiles store values adapted to a D50 environment; it is\r
+    * expected that the ICC profile mediaWhitePointTag will be D50, see the\r
+    * checks and code elsewhere to understand this better.\r
+    *\r
+    * These XYZ values, which are accurate to 5dp, produce rgb to gray\r
+    * coefficients of (6968,23435,2366), which are reduced (because they add up\r
+    * to 32769 not 32768) to (6968,23434,2366).  These are the values that\r
+    * libpng has traditionally used (and are the best values given the 15bit\r
+    * algorithm used by the rgb to gray code.)\r
+    */\r
+   static const png_XYZ sRGB_XYZ = /* D65 XYZ (*not* the D50 adapted values!) */\r
+   {\r
+      /* color      X      Y      Z */\r
+      /* red   */ 41239, 21264,  1933,\r
+      /* green */ 35758, 71517, 11919,\r
+      /* blue  */ 18048,  7219, 95053\r
+   };\r
+\r
+   /* Do nothing if the colorspace is already invalidated. */\r
+   if (colorspace->flags & PNG_COLORSPACE_INVALID)\r
+      return 0;\r
+\r
+   /* Check the intent, then check for existing settings.  It is valid for the\r
+    * PNG file to have cHRM or gAMA chunks along with sRGB, but the values must\r
+    * be consistent with the correct values.  If, however, this function is\r
+    * called below because an iCCP chunk matches sRGB then it is quite\r
+    * conceivable that an older app recorded incorrect gAMA and cHRM because of\r
+    * an incorrect calculation based on the values in the profile - this does\r
+    * *not* invalidate the profile (though it still produces an error, which can\r
+    * be ignored.)\r
+    */\r
+   if (intent < 0 || intent >= PNG_sRGB_INTENT_LAST)\r
+      return png_icc_profile_error(png_ptr, colorspace, "sRGB",\r
+         (unsigned)intent, "invalid sRGB rendering intent");\r
+\r
+   if ((colorspace->flags & PNG_COLORSPACE_HAVE_INTENT) != 0 &&\r
+      colorspace->rendering_intent != intent)\r
+      return png_icc_profile_error(png_ptr, colorspace, "sRGB",\r
+         (unsigned)intent, "inconsistent rendering intents");\r
+\r
+   if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0)\r
+   {\r
+      png_benign_error(png_ptr, "duplicate sRGB information ignored");\r
+      return 0;\r
+   }\r
+\r
+   /* If the standard sRGB cHRM chunk does not match the one from the PNG file\r
+    * warn but overwrite the value with the correct one.\r
+    */\r
+   if ((colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0 &&\r
+      !png_colorspace_endpoints_match(&sRGB_xy, &colorspace->end_points_xy,\r
+         100))\r
+      png_chunk_report(png_ptr, "cHRM chunk does not match sRGB",\r
+         PNG_CHUNK_ERROR);\r
+\r
+   /* This check is just done for the error reporting - the routine always\r
+    * returns true when the 'from' argument corresponds to sRGB (2).\r
+    */\r
+   (void)png_colorspace_check_gamma(png_ptr, colorspace, PNG_GAMMA_sRGB_INVERSE,\r
+      2/*from sRGB*/);\r
+\r
+   /* intent: bugs in GCC force 'int' to be used as the parameter type. */\r
+   colorspace->rendering_intent = (png_uint_16)intent;\r
+   colorspace->flags |= PNG_COLORSPACE_HAVE_INTENT;\r
+\r
+   /* endpoints */\r
+   colorspace->end_points_xy = sRGB_xy;\r
+   colorspace->end_points_XYZ = sRGB_XYZ;\r
+   colorspace->flags |=\r
+      (PNG_COLORSPACE_HAVE_ENDPOINTS|PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB);\r
+\r
+   /* gamma */\r
+   colorspace->gamma = PNG_GAMMA_sRGB_INVERSE;\r
+   colorspace->flags |= PNG_COLORSPACE_HAVE_GAMMA;\r
+\r
+   /* Finally record that we have an sRGB profile */\r
+   colorspace->flags |=\r
+      (PNG_COLORSPACE_MATCHES_sRGB|PNG_COLORSPACE_FROM_sRGB);\r
+\r
+   return 1; /* set */\r
+}\r
+#endif /* sRGB */\r
+\r
+#ifdef PNG_iCCP_SUPPORTED\r
+/* Encoded value of D50 as an ICC XYZNumber.  From the ICC 2010 spec the value\r
+ * is XYZ(0.9642,1.0,0.8249), which scales to:\r
+ *\r
+ *    (63189.8112, 65536, 54060.6464)\r
+ */\r
+static const png_byte D50_nCIEXYZ[12] =\r
+   { 0x00, 0x00, 0xf6, 0xd6, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d };\r
+\r
+int /* PRIVATE */\r
+png_icc_check_length(png_const_structrp png_ptr, png_colorspacerp colorspace,\r
+   png_const_charp name, png_uint_32 profile_length)\r
+{\r
+   if (profile_length < 132)\r
+      return png_icc_profile_error(png_ptr, colorspace, name, profile_length,\r
+         "too short");\r
+\r
+   if (profile_length & 3)\r
+      return png_icc_profile_error(png_ptr, colorspace, name, profile_length,\r
+         "invalid length");\r
+\r
+   return 1;\r
+}\r
+\r
+int /* PRIVATE */\r
+png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace,\r
+   png_const_charp name, png_uint_32 profile_length,\r
+   png_const_bytep profile/* first 132 bytes only */, int color_type)\r
+{\r
+   png_uint_32 temp;\r
+\r
+   /* Length check; this cannot be ignored in this code because profile_length\r
+    * is used later to check the tag table, so even if the profile seems over\r
+    * long profile_length from the caller must be correct.  The caller can fix\r
+    * this up on read or write by just passing in the profile header length.\r
+    */\r
+   temp = png_get_uint_32(profile);\r
+   if (temp != profile_length)\r
+      return png_icc_profile_error(png_ptr, colorspace, name, temp,\r
+         "length does not match profile");\r
+\r
+   temp = png_get_uint_32(profile+128); /* tag count: 12 bytes/tag */\r
+   if (temp > 357913930 || /* (2^32-4-132)/12: maximum possible tag count */\r
+      profile_length < 132+12*temp) /* truncated tag table */\r
+      return png_icc_profile_error(png_ptr, colorspace, name, temp,\r
+         "tag count too large");\r
+\r
+   /* The 'intent' must be valid or we can't store it, ICC limits the intent to\r
+    * 16 bits.\r
+    */\r
+   temp = png_get_uint_32(profile+64);\r
+   if (temp >= 0xffff) /* The ICC limit */\r
+      return png_icc_profile_error(png_ptr, colorspace, name, temp,\r
+         "invalid rendering intent");\r
+\r
+   /* This is just a warning because the profile may be valid in future\r
+    * versions.\r
+    */\r
+   if (temp >= PNG_sRGB_INTENT_LAST)\r
+      (void)png_icc_profile_error(png_ptr, NULL, name, temp,\r
+         "intent outside defined range");\r
+\r
+   /* At this point the tag table can't be checked because it hasn't necessarily\r
+    * been loaded; however, various header fields can be checked.  These checks\r
+    * are for values permitted by the PNG spec in an ICC profile; the PNG spec\r
+    * restricts the profiles that can be passed in an iCCP chunk (they must be\r
+    * appropriate to processing PNG data!)\r
+    */\r
+\r
+   /* Data checks (could be skipped).  These checks must be independent of the\r
+    * version number; however, the version number doesn't accomodate changes in\r
+    * the header fields (just the known tags and the interpretation of the\r
+    * data.)\r
+    */\r
+   temp = png_get_uint_32(profile+36); /* signature 'ascp' */\r
+   if (temp != 0x61637370)\r
+      return png_icc_profile_error(png_ptr, colorspace, name, temp,\r
+         "invalid signature");\r
+\r
+   /* Currently the PCS illuminant/adopted white point (the computational\r
+    * white point) are required to be D50,\r
+    * however the profile contains a record of the illuminant so perhaps ICC\r
+    * expects to be able to change this in the future (despite the rationale in\r
+    * the introduction for using a fixed PCS adopted white.)  Consequently the\r
+    * following is just a warning.\r
+    */\r
+   if (memcmp(profile+68, D50_nCIEXYZ, 12) != 0)\r
+      (void)png_icc_profile_error(png_ptr, NULL, name, 0/*no tag value*/,\r
+         "PCS illuminant is not D50");\r
+\r
+   /* The PNG spec requires this:\r
+    * "If the iCCP chunk is present, the image samples conform to the colour\r
+    * space represented by the embedded ICC profile as defined by the\r
+    * International Color Consortium [ICC]. The colour space of the ICC profile\r
+    * shall be an RGB colour space for colour images (PNG colour types 2, 3, and\r
+    * 6), or a greyscale colour space for greyscale images (PNG colour types 0\r
+    * and 4)."\r
+    *\r
+    * This checking code ensures the embedded profile (on either read or write)\r
+    * conforms to the specification requirements.  Notice that an ICC 'gray'\r
+    * color-space profile contains the information to transform the monochrome\r
+    * data to XYZ or L*a*b (according to which PCS the profile uses) and this\r
+    * should be used in preference to the standard libpng K channel replication\r
+    * into R, G and B channels.\r
+    *\r
+    * Previously it was suggested that an RGB profile on grayscale data could be\r
+    * handled.  However it it is clear that using an RGB profile in this context\r
+    * must be an error - there is no specification of what it means.  Thus it is\r
+    * almost certainly more correct to ignore the profile.\r
+    */\r
+   temp = png_get_uint_32(profile+16); /* data colour space field */\r
+   switch (temp)\r
+   {\r
+      case 0x52474220: /* 'RGB ' */\r
+         if (!(color_type & PNG_COLOR_MASK_COLOR))\r
+            return png_icc_profile_error(png_ptr, colorspace, name, temp,\r
+               "RGB color space not permitted on grayscale PNG");\r
+         break;\r
+\r
+      case 0x47524159: /* 'GRAY' */\r
+         if (color_type & PNG_COLOR_MASK_COLOR)\r
+            return png_icc_profile_error(png_ptr, colorspace, name, temp,\r
+               "Gray color space not permitted on RGB PNG");\r
+         break;\r
+\r
+      default:\r
+         return png_icc_profile_error(png_ptr, colorspace, name, temp,\r
+            "invalid ICC profile color space");\r
+   }\r
+\r
+   /* It is up to the application to check that the profile class matches the\r
+    * application requirements; the spec provides no guidance, but it's pretty\r
+    * weird if the profile is not scanner ('scnr'), monitor ('mntr'), printer\r
+    * ('prtr') or 'spac' (for generic color spaces).  Issue a warning in these\r
+    * cases.  Issue an error for device link or abstract profiles - these don't\r
+    * contain the records necessary to transform the color-space to anything\r
+    * other than the target device (and not even that for an abstract profile).\r
+    * Profiles of these classes may not be embedded in images.\r
+    */\r
+   temp = png_get_uint_32(profile+12); /* profile/device class */\r
+   switch (temp)\r
+   {\r
+      case 0x73636E72: /* 'scnr' */\r
+      case 0x6D6E7472: /* 'mntr' */\r
+      case 0x70727472: /* 'prtr' */\r
+      case 0x73706163: /* 'spac' */\r
+         /* All supported */\r
+         break;\r
+\r
+      case 0x61627374: /* 'abst' */\r
+         /* May not be embedded in an image */\r
+         return png_icc_profile_error(png_ptr, colorspace, name, temp,\r
+            "invalid embedded Abstract ICC profile");\r
+\r
+      case 0x6C696E6B: /* 'link' */\r
+         /* DeviceLink profiles cannnot be interpreted in a non-device specific\r
+          * fashion, if an app uses the AToB0Tag in the profile the results are\r
+          * undefined unless the result is sent to the intended device,\r
+          * therefore a DeviceLink profile should not be found embedded in a\r
+          * PNG.\r
+          */\r
+         return png_icc_profile_error(png_ptr, colorspace, name, temp,\r
+            "unexpected DeviceLink ICC profile class");\r
+\r
+      case 0x6E6D636C: /* 'nmcl' */\r
+         /* A NamedColor profile is also device specific, however it doesn't\r
+          * contain an AToB0 tag that is open to misintrepretation.  Almost\r
+          * certainly it will fail the tests below.\r
+          */\r
+         (void)png_icc_profile_error(png_ptr, NULL, name, temp,\r
+            "unexpected NamedColor ICC profile class");\r
+         break;\r
+\r
+      default:\r
+         /* To allow for future enhancements to the profile accept unrecognized\r
+          * profile classes with a warning, these then hit the test below on the\r
+          * tag content to ensure they are backward compatible with one of the\r
+          * understood profiles.\r
+          */\r
+         (void)png_icc_profile_error(png_ptr, NULL, name, temp,\r
+            "unrecognized ICC profile class");\r
+         break;\r
+   }\r
+\r
+   /* For any profile other than a device link one the PCS must be encoded\r
+    * either in XYZ or Lab.\r
+    */\r
+   temp = png_get_uint_32(profile+20);\r
+   switch (temp)\r
+   {\r
+      case 0x58595A20: /* 'XYZ ' */\r
+      case 0x4C616220: /* 'Lab ' */\r
+         break;\r
+\r
+      default:\r
+         return png_icc_profile_error(png_ptr, colorspace, name, temp,\r
+            "unexpected ICC PCS encoding");\r
+   }\r
+\r
+   return 1;\r
+}\r
+\r
+int /* PRIVATE */\r
+png_icc_check_tag_table(png_const_structrp png_ptr, png_colorspacerp colorspace,\r
+   png_const_charp name, png_uint_32 profile_length,\r
+   png_const_bytep profile /* header plus whole tag table */)\r
+{\r
+   png_uint_32 tag_count = png_get_uint_32(profile+128);\r
+   png_uint_32 itag;\r
+   png_const_bytep tag = profile+132; /* The first tag */\r
+\r
+   /* First scan all the tags in the table and add bits to the icc_info value\r
+    * (temporarily in 'tags').\r
+    */\r
+   for (itag=0; itag < tag_count; ++itag, tag += 12)\r
+   {\r
+      png_uint_32 tag_id = png_get_uint_32(tag+0);\r
+      png_uint_32 tag_start = png_get_uint_32(tag+4); /* must be aligned */\r
+      png_uint_32 tag_length = png_get_uint_32(tag+8);/* not padded */\r
+\r
+      /* The ICC specification does not exclude zero length tags, therefore the\r
+       * start might actually be anywhere if there is no data, but this would be\r
+       * a clear abuse of the intent of the standard so the start is checked for\r
+       * being in range.  All defined tag types have an 8 byte header - a 4 byte\r
+       * type signature then 0.\r
+       */\r
+      if ((tag_start & 3) != 0)\r
+      {\r
+         /* CNHP730S.icc shipped with Microsoft Windows 64 violates this, it is\r
+          * only a warning here because libpng does not care about the\r
+          * alignment.\r
+          */\r
+         (void)png_icc_profile_error(png_ptr, NULL, name, tag_id,\r
+            "ICC profile tag start not a multiple of 4");\r
+      }\r
+\r
+      /* This is a hard error; potentially it can cause read outside the\r
+       * profile.\r
+       */\r
+      if (tag_start > profile_length || tag_length > profile_length - tag_start)\r
+         return png_icc_profile_error(png_ptr, colorspace, name, tag_id,\r
+            "ICC profile tag outside profile");\r
+   }\r
+\r
+   return 1; /* success, maybe with warnings */\r
+}\r
+\r
+#ifdef PNG_sRGB_SUPPORTED\r
+/* Information about the known ICC sRGB profiles */\r
+static const struct\r
+{\r
+   png_uint_32 adler, crc, length;\r
+   png_uint_32 md5[4];\r
+   png_byte    have_md5;\r
+   png_byte    is_broken;\r
+   png_uint_16 intent;\r
+\r
+#  define PNG_MD5(a,b,c,d) { a, b, c, d }, (a!=0)||(b!=0)||(c!=0)||(d!=0)\r
+#  define PNG_ICC_CHECKSUM(adler, crc, md5, intent, broke, date, length, fname)\\r
+      { adler, crc, length, md5, broke, intent },\r
+\r
+} png_sRGB_checks[] =\r
+{\r
+   /* This data comes from contrib/tools/checksum-icc run on downloads of\r
+    * all four ICC sRGB profiles from www.color.org.\r
+    */\r
+   /* adler32, crc32, MD5[4], intent, date, length, file-name */\r
+   PNG_ICC_CHECKSUM(0x0a3fd9f6, 0x3b8772b9,\r
+      PNG_MD5(0x29f83dde, 0xaff255ae, 0x7842fae4, 0xca83390d), 0, 0,\r
+      "2009/03/27 21:36:31", 3048, "sRGB_IEC61966-2-1_black_scaled.icc")\r
+\r
+   /* ICC sRGB v2 perceptual no black-compensation: */\r
+   PNG_ICC_CHECKSUM(0x4909e5e1, 0x427ebb21,\r
+      PNG_MD5(0xc95bd637, 0xe95d8a3b, 0x0df38f99, 0xc1320389), 1, 0,\r
+      "2009/03/27 21:37:45", 3052, "sRGB_IEC61966-2-1_no_black_scaling.icc")\r
+\r
+   PNG_ICC_CHECKSUM(0xfd2144a1, 0x306fd8ae,\r
+      PNG_MD5(0xfc663378, 0x37e2886b, 0xfd72e983, 0x8228f1b8), 0, 0,\r
+      "2009/08/10 17:28:01", 60988, "sRGB_v4_ICC_preference_displayclass.icc")\r
+\r
+   /* ICC sRGB v4 perceptual */\r
+   PNG_ICC_CHECKSUM(0x209c35d2, 0xbbef7812,\r
+      PNG_MD5(0x34562abf, 0x994ccd06, 0x6d2c5721, 0xd0d68c5d), 0, 0,\r
+      "2007/07/25 00:05:37", 60960, "sRGB_v4_ICC_preference.icc")\r
+\r
+   /* The following profiles have no known MD5 checksum. If there is a match\r
+    * on the (empty) MD5 the other fields are used to attempt a match and\r
+    * a warning is produced.  The first two of these profiles have a 'cprt' tag\r
+    * which suggests that they were also made by Hewlett Packard.\r
+    */\r
+   PNG_ICC_CHECKSUM(0xa054d762, 0x5d5129ce,\r
+      PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 1, 0,\r
+      "2004/07/21 18:57:42", 3024, "sRGB_IEC61966-2-1_noBPC.icc")\r
+\r
+   /* This is a 'mntr' (display) profile with a mediaWhitePointTag that does not\r
+    * match the D50 PCS illuminant in the header (it is in fact the D65 values,\r
+    * so the white point is recorded as the un-adapted value.)  The profiles\r
+    * below only differ in one byte - the intent - and are basically the same as\r
+    * the previous profile except for the mediaWhitePointTag error and a missing\r
+    * chromaticAdaptationTag.\r
+    */\r
+   PNG_ICC_CHECKSUM(0xf784f3fb, 0x182ea552,\r
+      PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 0, 1/*broken*/,\r
+      "1998/02/09 06:49:00", 3144, "HP-Microsoft sRGB v2 perceptual")\r
+\r
+   PNG_ICC_CHECKSUM(0x0398f3fc, 0xf29e526d,\r
+      PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 1, 1/*broken*/,\r
+      "1998/02/09 06:49:00", 3144, "HP-Microsoft sRGB v2 media-relative")\r
+};\r
+\r
+static int\r
+png_compare_ICC_profile_with_sRGB(png_const_structrp png_ptr,\r
+   png_const_bytep profile, uLong adler)\r
+{\r
+   /* The quick check is to verify just the MD5 signature and trust the\r
+    * rest of the data.  Because the profile has already been verified for\r
+    * correctness this is safe.  png_colorspace_set_sRGB will check the 'intent'\r
+    * field too, so if the profile has been edited with an intent not defined\r
+    * by sRGB (but maybe defined by a later ICC specification) the read of\r
+    * the profile will fail at that point.\r
+    */\r
+   png_uint_32 length = 0;\r
+   png_uint_32 intent = 0x10000; /* invalid */\r
+#if PNG_sRGB_PROFILE_CHECKS > 1\r
+   uLong crc = 0; /* the value for 0 length data */\r
+#endif\r
+   unsigned int i;\r
+\r
+   for (i=0; i < (sizeof png_sRGB_checks) / (sizeof png_sRGB_checks[0]); ++i)\r
+   {\r
+      if (png_get_uint_32(profile+84) == png_sRGB_checks[i].md5[0] &&\r
+         png_get_uint_32(profile+88) == png_sRGB_checks[i].md5[1] &&\r
+         png_get_uint_32(profile+92) == png_sRGB_checks[i].md5[2] &&\r
+         png_get_uint_32(profile+96) == png_sRGB_checks[i].md5[3])\r
+      {\r
+         /* This may be one of the old HP profiles without an MD5, in that\r
+          * case we can only use the length and Adler32 (note that these\r
+          * are not used by default if there is an MD5!)\r
+          */\r
+#        if PNG_sRGB_PROFILE_CHECKS == 0\r
+            if (png_sRGB_checks[i].have_md5)\r
+               return 1+png_sRGB_checks[i].is_broken;\r
+#        endif\r
+\r
+         /* Profile is unsigned or more checks have been configured in. */\r
+         if (length == 0)\r
+         {\r
+            length = png_get_uint_32(profile);\r
+            intent = png_get_uint_32(profile+64);\r
+         }\r
+\r
+         /* Length *and* intent must match */\r
+         if (length == png_sRGB_checks[i].length &&\r
+            intent == png_sRGB_checks[i].intent)\r
+         {\r
+            /* Now calculate the adler32 if not done already. */\r
+            if (adler == 0)\r
+            {\r
+               adler = adler32(0, NULL, 0);\r
+               adler = adler32(adler, profile, length);\r
+            }\r
+\r
+            if (adler == png_sRGB_checks[i].adler)\r
+            {\r
+               /* These basic checks suggest that the data has not been\r
+                * modified, but if the check level is more than 1 perform\r
+                * our own crc32 checksum on the data.\r
+                */\r
+#              if PNG_sRGB_PROFILE_CHECKS > 1\r
+                  if (crc == 0)\r
+                  {\r
+                     crc = crc32(0, NULL, 0);\r
+                     crc = crc32(crc, profile, length);\r
+                  }\r
+\r
+                  /* So this check must pass for the 'return' below to happen.\r
+                   */\r
+                  if (crc == png_sRGB_checks[i].crc)\r
+#              endif\r
+               {\r
+                  if (png_sRGB_checks[i].is_broken)\r
+                  {\r
+                     /* These profiles are known to have bad data that may cause\r
+                      * problems if they are used, therefore attempt to\r
+                      * discourage their use, skip the 'have_md5' warning below,\r
+                      * which is made irrelevant by this error.\r
+                      */\r
+                     png_chunk_report(png_ptr, "known incorrect sRGB profile",\r
+                        PNG_CHUNK_ERROR);\r
+                  }\r
+\r
+                  /* Warn that this being done; this isn't even an error since\r
+                   * the profile is perfectly valid, but it would be nice if\r
+                   * people used the up-to-date ones.\r
+                   */\r
+                  else if (!png_sRGB_checks[i].have_md5)\r
+                  {\r
+                     png_chunk_report(png_ptr,\r
+                        "out-of-date sRGB profile with no signature",\r
+                        PNG_CHUNK_WARNING);\r
+                  }\r
+\r
+                  return 1+png_sRGB_checks[i].is_broken;\r
+               }\r
+            }\r
+         }\r
+\r
+#        if PNG_sRGB_PROFILE_CHECKS > 0\r
+            /* The signature matched, but the profile had been changed in some\r
+             * way.  This is an apparent violation of the ICC terms of use and,\r
+             * anyway, probably indicates a data error or uninformed hacking.\r
+             */\r
+            if (png_sRGB_checks[i].have_md5)\r
+               png_benign_error(png_ptr,\r
+                  "copyright violation: edited ICC profile ignored");\r
+#        endif\r
+      }\r
+   }\r
+\r
+   return 0; /* no match */\r
+}\r
+#endif\r
+\r
+#ifdef PNG_sRGB_SUPPORTED\r
+void /* PRIVATE */\r
+png_icc_set_sRGB(png_const_structrp png_ptr,\r
+   png_colorspacerp colorspace, png_const_bytep profile, uLong adler)\r
+{\r
+   /* Is this profile one of the known ICC sRGB profiles?  If it is, just set\r
+    * the sRGB information.\r
+    */\r
+   if (png_compare_ICC_profile_with_sRGB(png_ptr, profile, adler))\r
+      (void)png_colorspace_set_sRGB(png_ptr, colorspace,\r
+         (int)/*already checked*/png_get_uint_32(profile+64));\r
+}\r
+#endif /* PNG_READ_sRGB_SUPPORTED */\r
+\r
+int /* PRIVATE */\r
+png_colorspace_set_ICC(png_const_structrp png_ptr, png_colorspacerp colorspace,\r
+   png_const_charp name, png_uint_32 profile_length, png_const_bytep profile,\r
+   int color_type)\r
+{\r
+   if (colorspace->flags & PNG_COLORSPACE_INVALID)\r
+      return 0;\r
+\r
+   if (png_icc_check_length(png_ptr, colorspace, name, profile_length) &&\r
+      png_icc_check_header(png_ptr, colorspace, name, profile_length, profile,\r
+         color_type) &&\r
+      png_icc_check_tag_table(png_ptr, colorspace, name, profile_length,\r
+         profile))\r
+   {\r
+#     ifdef PNG_sRGB_SUPPORTED\r
+         /* If no sRGB support, don't try storing sRGB information */\r
+         png_icc_set_sRGB(png_ptr, colorspace, profile, 0);\r
+#     endif\r
+      return 1;\r
+   }\r
+\r
+   /* Failure case */\r
+   return 0;\r
+}\r
+#endif /* iCCP */\r
+\r
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED\r
+void /* PRIVATE */\r
+png_colorspace_set_rgb_coefficients(png_structrp png_ptr)\r
+{\r
+   /* Set the rgb_to_gray coefficients from the colorspace. */\r
+   if (!png_ptr->rgb_to_gray_coefficients_set &&\r
+      (png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)\r
+   {\r
+      /* png_set_background has not been called, get the coefficients from the Y\r
+       * values of the colorspace colorants.\r
+       */\r
+      png_fixed_point r = png_ptr->colorspace.end_points_XYZ.red_Y;\r
+      png_fixed_point g = png_ptr->colorspace.end_points_XYZ.green_Y;\r
+      png_fixed_point b = png_ptr->colorspace.end_points_XYZ.blue_Y;\r
+      png_fixed_point total = r+g+b;\r
+\r
+      if (total > 0 &&\r
+         r >= 0 && png_muldiv(&r, r, 32768, total) && r >= 0 && r <= 32768 &&\r
+         g >= 0 && png_muldiv(&g, g, 32768, total) && g >= 0 && g <= 32768 &&\r
+         b >= 0 && png_muldiv(&b, b, 32768, total) && b >= 0 && b <= 32768 &&\r
+         r+g+b <= 32769)\r
+      {\r
+         /* We allow 0 coefficients here.  r+g+b may be 32769 if two or\r
+          * all of the coefficients were rounded up.  Handle this by\r
+          * reducing the *largest* coefficient by 1; this matches the\r
+          * approach used for the default coefficients in pngrtran.c\r
+          */\r
+         int add = 0;\r
+\r
+         if (r+g+b > 32768)\r
+            add = -1;\r
+         else if (r+g+b < 32768)\r
+            add = 1;\r
+\r
+         if (add != 0)\r
+         {\r
+            if (g >= r && g >= b)\r
+               g += add;\r
+            else if (r >= g && r >= b)\r
+               r += add;\r
+            else\r
+               b += add;\r
+         }\r
+\r
+         /* Check for an internal error. */\r
+         if (r+g+b != 32768)\r
+            png_error(png_ptr,\r
+               "internal error handling cHRM coefficients");\r
+\r
+         else\r
+         {\r
+            png_ptr->rgb_to_gray_red_coeff   = (png_uint_16)r;\r
+            png_ptr->rgb_to_gray_green_coeff = (png_uint_16)g;\r
+         }\r
+      }\r
+\r
+      /* This is a png_error at present even though it could be ignored -\r
+       * it should never happen, but it is important that if it does, the\r
+       * bug is fixed.\r
+       */\r
+      else\r
+         png_error(png_ptr, "internal error handling cHRM->XYZ");\r
+   }\r
+}\r
+#endif\r
+\r
+#endif /* COLORSPACE */\r
+\r
+void /* PRIVATE */\r
+png_check_IHDR(png_const_structrp png_ptr,\r
+   png_uint_32 width, png_uint_32 height, int bit_depth,\r
+   int color_type, int interlace_type, int compression_type,\r
+   int filter_type)\r
+{\r
+   int error = 0;\r
+\r
+   /* Check for width and height valid values */\r
+   if (width == 0)\r
+   {\r
+      png_warning(png_ptr, "Image width is zero in IHDR");\r
+      error = 1;\r
+   }\r
+\r
+   if (height == 0)\r
+   {\r
+      png_warning(png_ptr, "Image height is zero in IHDR");\r
+      error = 1;\r
+   }\r
+\r
+#  ifdef PNG_SET_USER_LIMITS_SUPPORTED\r
+   if (width > png_ptr->user_width_max)\r
+\r
+#  else\r
+   if (width > PNG_USER_WIDTH_MAX)\r
+#  endif\r
+   {\r
+      png_warning(png_ptr, "Image width exceeds user limit in IHDR");\r
+      error = 1;\r
+   }\r
+\r
+#  ifdef PNG_SET_USER_LIMITS_SUPPORTED\r
+   if (height > png_ptr->user_height_max)\r
+#  else\r
+   if (height > PNG_USER_HEIGHT_MAX)\r
+#  endif\r
+   {\r
+      png_warning(png_ptr, "Image height exceeds user limit in IHDR");\r
+      error = 1;\r
+   }\r
+\r
+   if (width > PNG_UINT_31_MAX)\r
+   {\r
+      png_warning(png_ptr, "Invalid image width in IHDR");\r
+      error = 1;\r
+   }\r
+\r
+   if (height > PNG_UINT_31_MAX)\r
+   {\r
+      png_warning(png_ptr, "Invalid image height in IHDR");\r
+      error = 1;\r
+   }\r
+\r
+   if (width > (PNG_UINT_32_MAX\r
+                 >> 3)      /* 8-byte RGBA pixels */\r
+                 - 48       /* bigrowbuf hack */\r
+                 - 1        /* filter byte */\r
+                 - 7*8      /* rounding of width to multiple of 8 pixels */\r
+                 - 8)       /* extra max_pixel_depth pad */\r
+      png_warning(png_ptr, "Width is too large for libpng to process pixels");\r
+\r
+   /* Check other values */\r
+   if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&\r
+       bit_depth != 8 && bit_depth != 16)\r
+   {\r
+      png_warning(png_ptr, "Invalid bit depth in IHDR");\r
+      error = 1;\r
+   }\r
+\r
+   if (color_type < 0 || color_type == 1 ||\r
+       color_type == 5 || color_type > 6)\r
+   {\r
+      png_warning(png_ptr, "Invalid color type in IHDR");\r
+      error = 1;\r
+   }\r
+\r
+   if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||\r
+       ((color_type == PNG_COLOR_TYPE_RGB ||\r
+         color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||\r
+         color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))\r
+   {\r
+      png_warning(png_ptr, "Invalid color type/bit depth combination in IHDR");\r
+      error = 1;\r
+   }\r
+\r
+   if (interlace_type >= PNG_INTERLACE_LAST)\r
+   {\r
+      png_warning(png_ptr, "Unknown interlace method in IHDR");\r
+      error = 1;\r
+   }\r
+\r
+   if (compression_type != PNG_COMPRESSION_TYPE_BASE)\r
+   {\r
+      png_warning(png_ptr, "Unknown compression method in IHDR");\r
+      error = 1;\r
+   }\r
+\r
+#  ifdef PNG_MNG_FEATURES_SUPPORTED\r
+   /* Accept filter_method 64 (intrapixel differencing) only if\r
+    * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and\r
+    * 2. Libpng did not read a PNG signature (this filter_method is only\r
+    *    used in PNG datastreams that are embedded in MNG datastreams) and\r
+    * 3. The application called png_permit_mng_features with a mask that\r
+    *    included PNG_FLAG_MNG_FILTER_64 and\r
+    * 4. The filter_method is 64 and\r
+    * 5. The color_type is RGB or RGBA\r
+    */\r
+   if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) &&\r
+       png_ptr->mng_features_permitted)\r
+      png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");\r
+\r
+   if (filter_type != PNG_FILTER_TYPE_BASE)\r
+   {\r
+      if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&\r
+          (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&\r
+          ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&\r
+          (color_type == PNG_COLOR_TYPE_RGB ||\r
+          color_type == PNG_COLOR_TYPE_RGB_ALPHA)))\r
+      {\r
+         png_warning(png_ptr, "Unknown filter method in IHDR");\r
+         error = 1;\r
+      }\r
+\r
+      if (png_ptr->mode & PNG_HAVE_PNG_SIGNATURE)\r
+      {\r
+         png_warning(png_ptr, "Invalid filter method in IHDR");\r
+         error = 1;\r
+      }\r
+   }\r
+\r
+#  else\r
+   if (filter_type != PNG_FILTER_TYPE_BASE)\r
+   {\r
+      png_warning(png_ptr, "Unknown filter method in IHDR");\r
+      error = 1;\r
+   }\r
+#  endif\r
+\r
+   if (error == 1)\r
+      png_error(png_ptr, "Invalid IHDR data");\r
+}\r
+\r
+#if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED)\r
+/* ASCII to fp functions */\r
+/* Check an ASCII formated floating point value, see the more detailed\r
+ * comments in pngpriv.h\r
+ */\r
+/* The following is used internally to preserve the sticky flags */\r
+#define png_fp_add(state, flags) ((state) |= (flags))\r
+#define png_fp_set(state, value) ((state) = (value) | ((state) & PNG_FP_STICKY))\r
+\r
+int /* PRIVATE */\r
+png_check_fp_number(png_const_charp string, png_size_t size, int *statep,\r
+   png_size_tp whereami)\r
+{\r
+   int state = *statep;\r
+   png_size_t i = *whereami;\r
+\r
+   while (i < size)\r
+   {\r
+      int type;\r
+      /* First find the type of the next character */\r
+      switch (string[i])\r
+      {\r
+      case 43:  type = PNG_FP_SAW_SIGN;                   break;\r
+      case 45:  type = PNG_FP_SAW_SIGN + PNG_FP_NEGATIVE; break;\r
+      case 46:  type = PNG_FP_SAW_DOT;                    break;\r
+      case 48:  type = PNG_FP_SAW_DIGIT;                  break;\r
+      case 49: case 50: case 51: case 52:\r
+      case 53: case 54: case 55: case 56:\r
+      case 57:  type = PNG_FP_SAW_DIGIT + PNG_FP_NONZERO; break;\r
+      case 69:\r
+      case 101: type = PNG_FP_SAW_E;                      break;\r
+      default:  goto PNG_FP_End;\r
+      }\r
+\r
+      /* Now deal with this type according to the current\r
+       * state, the type is arranged to not overlap the\r
+       * bits of the PNG_FP_STATE.\r
+       */\r
+      switch ((state & PNG_FP_STATE) + (type & PNG_FP_SAW_ANY))\r
+      {\r
+      case PNG_FP_INTEGER + PNG_FP_SAW_SIGN:\r
+         if (state & PNG_FP_SAW_ANY)\r
+            goto PNG_FP_End; /* not a part of the number */\r
+\r
+         png_fp_add(state, type);\r
+         break;\r
+\r
+      case PNG_FP_INTEGER + PNG_FP_SAW_DOT:\r
+         /* Ok as trailer, ok as lead of fraction. */\r
+         if (state & PNG_FP_SAW_DOT) /* two dots */\r
+            goto PNG_FP_End;\r
+\r
+         else if (state & PNG_FP_SAW_DIGIT) /* trailing dot? */\r
+            png_fp_add(state, type);\r
+\r
+         else\r
+            png_fp_set(state, PNG_FP_FRACTION | type);\r
+\r
+         break;\r
+\r
+      case PNG_FP_INTEGER + PNG_FP_SAW_DIGIT:\r
+         if (state & PNG_FP_SAW_DOT) /* delayed fraction */\r
+            png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT);\r
+\r
+         png_fp_add(state, type | PNG_FP_WAS_VALID);\r
+\r
+         break;\r
+\r
+      case PNG_FP_INTEGER + PNG_FP_SAW_E:\r
+         if ((state & PNG_FP_SAW_DIGIT) == 0)\r
+            goto PNG_FP_End;\r
+\r
+         png_fp_set(state, PNG_FP_EXPONENT);\r
+\r
+         break;\r
+\r
+   /* case PNG_FP_FRACTION + PNG_FP_SAW_SIGN:\r
+         goto PNG_FP_End; ** no sign in fraction */\r
+\r
+   /* case PNG_FP_FRACTION + PNG_FP_SAW_DOT:\r
+         goto PNG_FP_End; ** Because SAW_DOT is always set */\r
+\r
+      case PNG_FP_FRACTION + PNG_FP_SAW_DIGIT:\r
+         png_fp_add(state, type | PNG_FP_WAS_VALID);\r
+         break;\r
+\r
+      case PNG_FP_FRACTION + PNG_FP_SAW_E:\r
+         /* This is correct because the trailing '.' on an\r
+          * integer is handled above - so we can only get here\r
+          * with the sequence ".E" (with no preceding digits).\r
+          */\r
+         if ((state & PNG_FP_SAW_DIGIT) == 0)\r
+            goto PNG_FP_End;\r
+\r
+         png_fp_set(state, PNG_FP_EXPONENT);\r
+\r
+         break;\r
+\r
+      case PNG_FP_EXPONENT + PNG_FP_SAW_SIGN:\r
+         if (state & PNG_FP_SAW_ANY)\r
+            goto PNG_FP_End; /* not a part of the number */\r
+\r
+         png_fp_add(state, PNG_FP_SAW_SIGN);\r
+\r
+         break;\r
+\r
+   /* case PNG_FP_EXPONENT + PNG_FP_SAW_DOT:\r
+         goto PNG_FP_End; */\r
+\r
+      case PNG_FP_EXPONENT + PNG_FP_SAW_DIGIT:\r
+         png_fp_add(state, PNG_FP_SAW_DIGIT | PNG_FP_WAS_VALID);\r
+\r
+         break;\r
+\r
+   /* case PNG_FP_EXPONEXT + PNG_FP_SAW_E:\r
+         goto PNG_FP_End; */\r
+\r
+      default: goto PNG_FP_End; /* I.e. break 2 */\r
+      }\r
+\r
+      /* The character seems ok, continue. */\r
+      ++i;\r
+   }\r
+\r
+PNG_FP_End:\r
+   /* Here at the end, update the state and return the correct\r
+    * return code.\r
+    */\r
+   *statep = state;\r
+   *whereami = i;\r
+\r
+   return (state & PNG_FP_SAW_DIGIT) != 0;\r
+}\r
+\r
+\r
+/* The same but for a complete string. */\r
+int\r
+png_check_fp_string(png_const_charp string, png_size_t size)\r
+{\r
+   int        state=0;\r
+   png_size_t char_index=0;\r
+\r
+   if (png_check_fp_number(string, size, &state, &char_index) &&\r
+      (char_index == size || string[char_index] == 0))\r
+      return state /* must be non-zero - see above */;\r
+\r
+   return 0; /* i.e. fail */\r
+}\r
+#endif /* pCAL or sCAL */\r
+\r
+#ifdef PNG_sCAL_SUPPORTED\r
+#  ifdef PNG_FLOATING_POINT_SUPPORTED\r
+/* Utility used below - a simple accurate power of ten from an integral\r
+ * exponent.\r
+ */\r
+static double\r
+png_pow10(int power)\r
+{\r
+   int recip = 0;\r
+   double d = 1;\r
+\r
+   /* Handle negative exponent with a reciprocal at the end because\r
+    * 10 is exact whereas .1 is inexact in base 2\r
+    */\r
+   if (power < 0)\r
+   {\r
+      if (power < DBL_MIN_10_EXP) return 0;\r
+      recip = 1, power = -power;\r
+   }\r
+\r
+   if (power > 0)\r
+   {\r
+      /* Decompose power bitwise. */\r
+      double mult = 10;\r
+      do\r
+      {\r
+         if (power & 1) d *= mult;\r
+         mult *= mult;\r
+         power >>= 1;\r
+      }\r
+      while (power > 0);\r
+\r
+      if (recip) d = 1/d;\r
+   }\r
+   /* else power is 0 and d is 1 */\r
+\r
+   return d;\r
+}\r
+\r
+/* Function to format a floating point value in ASCII with a given\r
+ * precision.\r
+ */\r
+void /* PRIVATE */\r
+png_ascii_from_fp(png_const_structrp png_ptr, png_charp ascii, png_size_t size,\r
+    double fp, unsigned int precision)\r
+{\r
+   /* We use standard functions from math.h, but not printf because\r
+    * that would require stdio.  The caller must supply a buffer of\r
+    * sufficient size or we will png_error.  The tests on size and\r
+    * the space in ascii[] consumed are indicated below.\r
+    */\r
+   if (precision < 1)\r
+      precision = DBL_DIG;\r
+\r
+   /* Enforce the limit of the implementation precision too. */\r
+   if (precision > DBL_DIG+1)\r
+      precision = DBL_DIG+1;\r
+\r
+   /* Basic sanity checks */\r
+   if (size >= precision+5) /* See the requirements below. */\r
+   {\r
+      if (fp < 0)\r
+      {\r
+         fp = -fp;\r
+         *ascii++ = 45; /* '-'  PLUS 1 TOTAL 1 */\r
+         --size;\r
+      }\r
+\r
+      if (fp >= DBL_MIN && fp <= DBL_MAX)\r
+      {\r
+         int exp_b10;       /* A base 10 exponent */\r
+         double base;   /* 10^exp_b10 */\r
+\r
+         /* First extract a base 10 exponent of the number,\r
+          * the calculation below rounds down when converting\r
+          * from base 2 to base 10 (multiply by log10(2) -\r
+          * 0.3010, but 77/256 is 0.3008, so exp_b10 needs to\r
+          * be increased.  Note that the arithmetic shift\r
+          * performs a floor() unlike C arithmetic - using a\r
+          * C multiply would break the following for negative\r
+          * exponents.\r
+          */\r
+         (void)frexp(fp, &exp_b10); /* exponent to base 2 */\r
+\r
+         exp_b10 = (exp_b10 * 77) >> 8; /* <= exponent to base 10 */\r
+\r
+         /* Avoid underflow here. */\r
+         base = png_pow10(exp_b10); /* May underflow */\r
+\r
+         while (base < DBL_MIN || base < fp)\r
+         {\r
+            /* And this may overflow. */\r
+            double test = png_pow10(exp_b10+1);\r
+\r
+            if (test <= DBL_MAX)\r
+               ++exp_b10, base = test;\r
+\r
+            else\r
+               break;\r
+         }\r
+\r
+         /* Normalize fp and correct exp_b10, after this fp is in the\r
+          * range [.1,1) and exp_b10 is both the exponent and the digit\r
+          * *before* which the decimal point should be inserted\r
+          * (starting with 0 for the first digit).  Note that this\r
+          * works even if 10^exp_b10 is out of range because of the\r
+          * test on DBL_MAX above.\r
+          */\r
+         fp /= base;\r
+         while (fp >= 1) fp /= 10, ++exp_b10;\r
+\r
+         /* Because of the code above fp may, at this point, be\r
+          * less than .1, this is ok because the code below can\r
+          * handle the leading zeros this generates, so no attempt\r
+          * is made to correct that here.\r
+          */\r
+\r
+         {\r
+            int czero, clead, cdigits;\r
+            char exponent[10];\r
+\r
+            /* Allow up to two leading zeros - this will not lengthen\r
+             * the number compared to using E-n.\r
+             */\r
+            if (exp_b10 < 0 && exp_b10 > -3) /* PLUS 3 TOTAL 4 */\r
+            {\r
+               czero = -exp_b10; /* PLUS 2 digits: TOTAL 3 */\r
+               exp_b10 = 0;      /* Dot added below before first output. */\r
+            }\r
+            else\r
+               czero = 0;    /* No zeros to add */\r
+\r
+            /* Generate the digit list, stripping trailing zeros and\r
+             * inserting a '.' before a digit if the exponent is 0.\r
+             */\r
+            clead = czero; /* Count of leading zeros */\r
+            cdigits = 0;   /* Count of digits in list. */\r
+\r
+            do\r
+            {\r
+               double d;\r
+\r
+               fp *= 10;\r
+               /* Use modf here, not floor and subtract, so that\r
+                * the separation is done in one step.  At the end\r
+                * of the loop don't break the number into parts so\r
+                * that the final digit is rounded.\r
+                */\r
+               if (cdigits+czero-clead+1 < (int)precision)\r
+                  fp = modf(fp, &d);\r
+\r
+               else\r
+               {\r
+                  d = floor(fp + .5);\r
+\r
+                  if (d > 9)\r
+                  {\r
+                     /* Rounding up to 10, handle that here. */\r
+                     if (czero > 0)\r
+                     {\r
+                        --czero, d = 1;\r
+                        if (cdigits == 0) --clead;\r
+                     }\r
+                     else\r
+                     {\r
+                        while (cdigits > 0 && d > 9)\r
+                        {\r
+                           int ch = *--ascii;\r
+\r
+                           if (exp_b10 != (-1))\r
+                              ++exp_b10;\r
+\r
+                           else if (ch == 46)\r
+                           {\r
+                              ch = *--ascii, ++size;\r
+                              /* Advance exp_b10 to '1', so that the\r
+                               * decimal point happens after the\r
+                               * previous digit.\r
+                               */\r
+                              exp_b10 = 1;\r
+                           }\r
+\r
+                           --cdigits;\r
+                           d = ch - 47;  /* I.e. 1+(ch-48) */\r
+                        }\r
+\r
+                        /* Did we reach the beginning? If so adjust the\r
+                         * exponent but take into account the leading\r
+                         * decimal point.\r
+                         */\r
+                        if (d > 9)  /* cdigits == 0 */\r
+                        {\r
+                           if (exp_b10 == (-1))\r
+                           {\r
+                              /* Leading decimal point (plus zeros?), if\r
+                               * we lose the decimal point here it must\r
+                               * be reentered below.\r
+                               */\r
+                              int ch = *--ascii;\r
+\r
+                              if (ch == 46)\r
+                                 ++size, exp_b10 = 1;\r
+\r
+                              /* Else lost a leading zero, so 'exp_b10' is\r
+                               * still ok at (-1)\r
+                               */\r
+                           }\r
+                           else\r
+                              ++exp_b10;\r
+\r
+                           /* In all cases we output a '1' */\r
+                           d = 1;\r
+                        }\r
+                     }\r
+                  }\r
+                  fp = 0; /* Guarantees termination below. */\r
+               }\r
+\r
+               if (d == 0)\r
+               {\r
+                  ++czero;\r
+                  if (cdigits == 0) ++clead;\r
+               }\r
+               else\r
+               {\r
+                  /* Included embedded zeros in the digit count. */\r
+                  cdigits += czero - clead;\r
+                  clead = 0;\r
+\r
+                  while (czero > 0)\r
+                  {\r
+                     /* exp_b10 == (-1) means we just output the decimal\r
+                      * place - after the DP don't adjust 'exp_b10' any\r
+                      * more!\r
+                      */\r
+                     if (exp_b10 != (-1))\r
+                     {\r
+                        if (exp_b10 == 0) *ascii++ = 46, --size;\r
+                        /* PLUS 1: TOTAL 4 */\r
+                        --exp_b10;\r
+                     }\r
+                     *ascii++ = 48, --czero;\r
+                  }\r
+\r
+                  if (exp_b10 != (-1))\r
+                  {\r
+                     if (exp_b10 == 0) *ascii++ = 46, --size; /* counted\r
+                                                                 above */\r
+                     --exp_b10;\r
+                  }\r
+                  *ascii++ = (char)(48 + (int)d), ++cdigits;\r
+               }\r
+            }\r
+            while (cdigits+czero-clead < (int)precision && fp > DBL_MIN);\r
+\r
+            /* The total output count (max) is now 4+precision */\r
+\r
+            /* Check for an exponent, if we don't need one we are\r
+             * done and just need to terminate the string.  At\r
+             * this point exp_b10==(-1) is effectively if flag - it got\r
+             * to '-1' because of the decrement after outputing\r
+             * the decimal point above (the exponent required is\r
+             * *not* -1!)\r
+             */\r
+            if (exp_b10 >= (-1) && exp_b10 <= 2)\r
+            {\r
+               /* The following only happens if we didn't output the\r
+                * leading zeros above for negative exponent, so this\r
+                * doest add to the digit requirement.  Note that the\r
+                * two zeros here can only be output if the two leading\r
+                * zeros were *not* output, so this doesn't increase\r
+                * the output count.\r
+                */\r
+               while (--exp_b10 >= 0) *ascii++ = 48;\r
+\r
+               *ascii = 0;\r
+\r
+               /* Total buffer requirement (including the '\0') is\r
+                * 5+precision - see check at the start.\r
+                */\r
+               return;\r
+            }\r
+\r
+            /* Here if an exponent is required, adjust size for\r
+             * the digits we output but did not count.  The total\r
+             * digit output here so far is at most 1+precision - no\r
+             * decimal point and no leading or trailing zeros have\r
+             * been output.\r
+             */\r
+            size -= cdigits;\r
+\r
+            *ascii++ = 69, --size;    /* 'E': PLUS 1 TOTAL 2+precision */\r
+\r
+            /* The following use of an unsigned temporary avoids ambiguities in\r
+             * the signed arithmetic on exp_b10 and permits GCC at least to do\r
+             * better optimization.\r
+             */\r
+            {\r
+               unsigned int uexp_b10;\r
+\r
+               if (exp_b10 < 0)\r
+               {\r
+                  *ascii++ = 45, --size; /* '-': PLUS 1 TOTAL 3+precision */\r
+                  uexp_b10 = -exp_b10;\r
+               }\r
+\r
+               else\r
+                  uexp_b10 = exp_b10;\r
+\r
+               cdigits = 0;\r
+\r
+               while (uexp_b10 > 0)\r
+               {\r
+                  exponent[cdigits++] = (char)(48 + uexp_b10 % 10);\r
+                  uexp_b10 /= 10;\r
+               }\r
+            }\r
+\r
+            /* Need another size check here for the exponent digits, so\r
+             * this need not be considered above.\r
+             */\r
+            if ((int)size > cdigits)\r
+            {\r
+               while (cdigits > 0) *ascii++ = exponent[--cdigits];\r
+\r
+               *ascii = 0;\r
+\r
+               return;\r
+            }\r
+         }\r
+      }\r
+      else if (!(fp >= DBL_MIN))\r
+      {\r
+         *ascii++ = 48; /* '0' */\r
+         *ascii = 0;\r
+         return;\r
+      }\r
+      else\r
+      {\r
+         *ascii++ = 105; /* 'i' */\r
+         *ascii++ = 110; /* 'n' */\r
+         *ascii++ = 102; /* 'f' */\r
+         *ascii = 0;\r
+         return;\r
+      }\r
+   }\r
+\r
+   /* Here on buffer too small. */\r
+   png_error(png_ptr, "ASCII conversion buffer too small");\r
+}\r
+\r
+#  endif /* FLOATING_POINT */\r
+\r
+#  ifdef PNG_FIXED_POINT_SUPPORTED\r
+/* Function to format a fixed point value in ASCII.\r
+ */\r
+void /* PRIVATE */\r
+png_ascii_from_fixed(png_const_structrp png_ptr, png_charp ascii,\r
+    png_size_t size, png_fixed_point fp)\r
+{\r
+   /* Require space for 10 decimal digits, a decimal point, a minus sign and a\r
+    * trailing \0, 13 characters:\r
+    */\r
+   if (size > 12)\r
+   {\r
+      png_uint_32 num;\r
+\r
+      /* Avoid overflow here on the minimum integer. */\r
+      if (fp < 0)\r
+         *ascii++ = 45, --size, num = -fp;\r
+      else\r
+         num = fp;\r
+\r
+      if (num <= 0x80000000) /* else overflowed */\r
+      {\r
+         unsigned int ndigits = 0, first = 16 /* flag value */;\r
+         char digits[10];\r
+\r
+         while (num)\r
+         {\r
+            /* Split the low digit off num: */\r
+            unsigned int tmp = num/10;\r
+            num -= tmp*10;\r
+            digits[ndigits++] = (char)(48 + num);\r
+            /* Record the first non-zero digit, note that this is a number\r
+             * starting at 1, it's not actually the array index.\r
+             */\r
+            if (first == 16 && num > 0)\r
+               first = ndigits;\r
+            num = tmp;\r
+         }\r
+\r
+         if (ndigits > 0)\r
+         {\r
+            while (ndigits > 5) *ascii++ = digits[--ndigits];\r
+            /* The remaining digits are fractional digits, ndigits is '5' or\r
+             * smaller at this point.  It is certainly not zero.  Check for a\r
+             * non-zero fractional digit:\r
+             */\r
+            if (first <= 5)\r
+            {\r
+               unsigned int i;\r
+               *ascii++ = 46; /* decimal point */\r
+               /* ndigits may be <5 for small numbers, output leading zeros\r
+                * then ndigits digits to first:\r
+                */\r
+               i = 5;\r
+               while (ndigits < i) *ascii++ = 48, --i;\r
+               while (ndigits >= first) *ascii++ = digits[--ndigits];\r
+               /* Don't output the trailing zeros! */\r
+            }\r
+         }\r
+         else\r
+            *ascii++ = 48;\r
+\r
+         /* And null terminate the string: */\r
+         *ascii = 0;\r
+         return;\r
+      }\r
+   }\r
+\r
+   /* Here on buffer too small. */\r
+   png_error(png_ptr, "ASCII conversion buffer too small");\r
+}\r
+#   endif /* FIXED_POINT */\r
+#endif /* READ_SCAL */\r
+\r
+#if defined(PNG_FLOATING_POINT_SUPPORTED) && \\r
+   !defined(PNG_FIXED_POINT_MACRO_SUPPORTED) && \\r
+   (defined(PNG_gAMA_SUPPORTED) || defined(PNG_cHRM_SUPPORTED) || \\r
+   defined(PNG_sCAL_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) || \\r
+   defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)) || \\r
+   (defined(PNG_sCAL_SUPPORTED) && \\r
+   defined(PNG_FLOATING_ARITHMETIC_SUPPORTED))\r
+png_fixed_point\r
+png_fixed(png_const_structrp png_ptr, double fp, png_const_charp text)\r
+{\r
+   double r = floor(100000 * fp + .5);\r
+\r
+   if (r > 2147483647. || r < -2147483648.)\r
+      png_fixed_error(png_ptr, text);\r
+\r
+   return (png_fixed_point)r;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_GAMMA_SUPPORTED) || \\r
+    defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG_READ_pHYs_SUPPORTED)\r
+/* muldiv functions */\r
+/* This API takes signed arguments and rounds the result to the nearest\r
+ * integer (or, for a fixed point number - the standard argument - to\r
+ * the nearest .00001).  Overflow and divide by zero are signalled in\r
+ * the result, a boolean - true on success, false on overflow.\r
+ */\r
+int\r
+png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times,\r
+    png_int_32 divisor)\r
+{\r
+   /* Return a * times / divisor, rounded. */\r
+   if (divisor != 0)\r
+   {\r
+      if (a == 0 || times == 0)\r
+      {\r
+         *res = 0;\r
+         return 1;\r
+      }\r
+      else\r
+      {\r
+#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED\r
+         double r = a;\r
+         r *= times;\r
+         r /= divisor;\r
+         r = floor(r+.5);\r
+\r
+         /* A png_fixed_point is a 32-bit integer. */\r
+         if (r <= 2147483647. && r >= -2147483648.)\r
+         {\r
+            *res = (png_fixed_point)r;\r
+            return 1;\r
+         }\r
+#else\r
+         int negative = 0;\r
+         png_uint_32 A, T, D;\r
+         png_uint_32 s16, s32, s00;\r
+\r
+         if (a < 0)\r
+            negative = 1, A = -a;\r
+         else\r
+            A = a;\r
+\r
+         if (times < 0)\r
+            negative = !negative, T = -times;\r
+         else\r
+            T = times;\r
+\r
+         if (divisor < 0)\r
+            negative = !negative, D = -divisor;\r
+         else\r
+            D = divisor;\r
+\r
+         /* Following can't overflow because the arguments only\r
+          * have 31 bits each, however the result may be 32 bits.\r
+          */\r
+         s16 = (A >> 16) * (T & 0xffff) +\r
+                           (A & 0xffff) * (T >> 16);\r
+         /* Can't overflow because the a*times bit is only 30\r
+          * bits at most.\r
+          */\r
+         s32 = (A >> 16) * (T >> 16) + (s16 >> 16);\r
+         s00 = (A & 0xffff) * (T & 0xffff);\r
+\r
+         s16 = (s16 & 0xffff) << 16;\r
+         s00 += s16;\r
+\r
+         if (s00 < s16)\r
+            ++s32; /* carry */\r
+\r
+         if (s32 < D) /* else overflow */\r
+         {\r
+            /* s32.s00 is now the 64-bit product, do a standard\r
+             * division, we know that s32 < D, so the maximum\r
+             * required shift is 31.\r
+             */\r
+            int bitshift = 32;\r
+            png_fixed_point result = 0; /* NOTE: signed */\r
+\r
+            while (--bitshift >= 0)\r
+            {\r
+               png_uint_32 d32, d00;\r
+\r
+               if (bitshift > 0)\r
+                  d32 = D >> (32-bitshift), d00 = D << bitshift;\r
+\r
+               else\r
+                  d32 = 0, d00 = D;\r
+\r
+               if (s32 > d32)\r
+               {\r
+                  if (s00 < d00) --s32; /* carry */\r
+                  s32 -= d32, s00 -= d00, result += 1<<bitshift;\r
+               }\r
+\r
+               else\r
+                  if (s32 == d32 && s00 >= d00)\r
+                     s32 = 0, s00 -= d00, result += 1<<bitshift;\r
+            }\r
+\r
+            /* Handle the rounding. */\r
+            if (s00 >= (D >> 1))\r
+               ++result;\r
+\r
+            if (negative)\r
+               result = -result;\r
+\r
+            /* Check for overflow. */\r
+            if ((negative && result <= 0) || (!negative && result >= 0))\r
+            {\r
+               *res = result;\r
+               return 1;\r
+            }\r
+         }\r
+#endif\r
+      }\r
+   }\r
+\r
+   return 0;\r
+}\r
+#endif /* READ_GAMMA || INCH_CONVERSIONS */\r
+\r
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED)\r
+/* The following is for when the caller doesn't much care about the\r
+ * result.\r
+ */\r
+png_fixed_point\r
+png_muldiv_warn(png_const_structrp png_ptr, png_fixed_point a, png_int_32 times,\r
+    png_int_32 divisor)\r
+{\r
+   png_fixed_point result;\r
+\r
+   if (png_muldiv(&result, a, times, divisor))\r
+      return result;\r
+\r
+   png_warning(png_ptr, "fixed point overflow ignored");\r
+   return 0;\r
+}\r
+#endif\r
+\r
+#ifdef PNG_GAMMA_SUPPORTED /* more fixed point functions for gamma */\r
+/* Calculate a reciprocal, return 0 on div-by-zero or overflow. */\r
+png_fixed_point\r
+png_reciprocal(png_fixed_point a)\r
+{\r
+#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED\r
+   double r = floor(1E10/a+.5);\r
+\r
+   if (r <= 2147483647. && r >= -2147483648.)\r
+      return (png_fixed_point)r;\r
+#else\r
+   png_fixed_point res;\r
+\r
+   if (png_muldiv(&res, 100000, 100000, a))\r
+      return res;\r
+#endif\r
+\r
+   return 0; /* error/overflow */\r
+}\r
+\r
+/* This is the shared test on whether a gamma value is 'significant' - whether\r
+ * it is worth doing gamma correction.\r
+ */\r
+int /* PRIVATE */\r
+png_gamma_significant(png_fixed_point gamma_val)\r
+{\r
+   return gamma_val < PNG_FP_1 - PNG_GAMMA_THRESHOLD_FIXED ||\r
+       gamma_val > PNG_FP_1 + PNG_GAMMA_THRESHOLD_FIXED;\r
+}\r
+#endif\r
+\r
+#ifdef PNG_READ_GAMMA_SUPPORTED\r
+/* A local convenience routine. */\r
+static png_fixed_point\r
+png_product2(png_fixed_point a, png_fixed_point b)\r
+{\r
+   /* The required result is 1/a * 1/b; the following preserves accuracy. */\r
+#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED\r
+   double r = a * 1E-5;\r
+   r *= b;\r
+   r = floor(r+.5);\r
+\r
+   if (r <= 2147483647. && r >= -2147483648.)\r
+      return (png_fixed_point)r;\r
+#else\r
+   png_fixed_point res;\r
+\r
+   if (png_muldiv(&res, a, b, 100000))\r
+      return res;\r
+#endif\r
+\r
+   return 0; /* overflow */\r
+}\r
+\r
+/* The inverse of the above. */\r
+png_fixed_point\r
+png_reciprocal2(png_fixed_point a, png_fixed_point b)\r
+{\r
+   /* The required result is 1/a * 1/b; the following preserves accuracy. */\r
+#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED\r
+   double r = 1E15/a;\r
+   r /= b;\r
+   r = floor(r+.5);\r
+\r
+   if (r <= 2147483647. && r >= -2147483648.)\r
+      return (png_fixed_point)r;\r
+#else\r
+   /* This may overflow because the range of png_fixed_point isn't symmetric,\r
+    * but this API is only used for the product of file and screen gamma so it\r
+    * doesn't matter that the smallest number it can produce is 1/21474, not\r
+    * 1/100000\r
+    */\r
+   png_fixed_point res = png_product2(a, b);\r
+\r
+   if (res != 0)\r
+      return png_reciprocal(res);\r
+#endif\r
+\r
+   return 0; /* overflow */\r
+}\r
+#endif /* READ_GAMMA */\r
+\r
+#ifdef PNG_READ_GAMMA_SUPPORTED /* gamma table code */\r
+#ifndef PNG_FLOATING_ARITHMETIC_SUPPORTED\r
+/* Fixed point gamma.\r
+ *\r
+ * The code to calculate the tables used below can be found in the shell script\r
+ * contrib/tools/intgamma.sh\r
+ *\r
+ * To calculate gamma this code implements fast log() and exp() calls using only\r
+ * fixed point arithmetic.  This code has sufficient precision for either 8-bit\r
+ * or 16-bit sample values.\r
+ *\r
+ * The tables used here were calculated using simple 'bc' programs, but C double\r
+ * precision floating point arithmetic would work fine.\r
+ *\r
+ * 8-bit log table\r
+ *   This is a table of -log(value/255)/log(2) for 'value' in the range 128 to\r
+ *   255, so it's the base 2 logarithm of a normalized 8-bit floating point\r
+ *   mantissa.  The numbers are 32-bit fractions.\r
+ */\r
+static const png_uint_32\r
+png_8bit_l2[128] =\r
+{\r
+   4270715492U, 4222494797U, 4174646467U, 4127164793U, 4080044201U, 4033279239U,\r
+   3986864580U, 3940795015U, 3895065449U, 3849670902U, 3804606499U, 3759867474U,\r
+   3715449162U, 3671346997U, 3627556511U, 3584073329U, 3540893168U, 3498011834U,\r
+   3455425220U, 3413129301U, 3371120137U, 3329393864U, 3287946700U, 3246774933U,\r
+   3205874930U, 3165243125U, 3124876025U, 3084770202U, 3044922296U, 3005329011U,\r
+   2965987113U, 2926893432U, 2888044853U, 2849438323U, 2811070844U, 2772939474U,\r
+   2735041326U, 2697373562U, 2659933400U, 2622718104U, 2585724991U, 2548951424U,\r
+   2512394810U, 2476052606U, 2439922311U, 2404001468U, 2368287663U, 2332778523U,\r
+   2297471715U, 2262364947U, 2227455964U, 2192742551U, 2158222529U, 2123893754U,\r
+   2089754119U, 2055801552U, 2022034013U, 1988449497U, 1955046031U, 1921821672U,\r
+   1888774511U, 1855902668U, 1823204291U, 1790677560U, 1758320682U, 1726131893U,\r
+   1694109454U, 1662251657U, 1630556815U, 1599023271U, 1567649391U, 1536433567U,\r
+   1505374214U, 1474469770U, 1443718700U, 1413119487U, 1382670639U, 1352370686U,\r
+   1322218179U, 1292211689U, 1262349810U, 1232631153U, 1203054352U, 1173618059U,\r
+   1144320946U, 1115161701U, 1086139034U, 1057251672U, 1028498358U, 999877854U,\r
+   971388940U, 943030410U, 914801076U, 886699767U, 858725327U, 830876614U,\r
+   803152505U, 775551890U, 748073672U, 720716771U, 693480120U, 666362667U,\r
+   639363374U, 612481215U, 585715177U, 559064263U, 532527486U, 506103872U,\r
+   479792461U, 453592303U, 427502463U, 401522014U, 375650043U, 349885648U,\r
+   324227938U, 298676034U, 273229066U, 247886176U, 222646516U, 197509248U,\r
+   172473545U, 147538590U, 122703574U, 97967701U, 73330182U, 48790236U,\r
+   24347096U, 0U\r
+\r
+#if 0\r
+   /* The following are the values for 16-bit tables - these work fine for the\r
+    * 8-bit conversions but produce very slightly larger errors in the 16-bit\r
+    * log (about 1.2 as opposed to 0.7 absolute error in the final value).  To\r
+    * use these all the shifts below must be adjusted appropriately.\r
+    */\r
+   65166, 64430, 63700, 62976, 62257, 61543, 60835, 60132, 59434, 58741, 58054,\r
+   57371, 56693, 56020, 55352, 54689, 54030, 53375, 52726, 52080, 51439, 50803,\r
+   50170, 49542, 48918, 48298, 47682, 47070, 46462, 45858, 45257, 44661, 44068,\r
+   43479, 42894, 42312, 41733, 41159, 40587, 40020, 39455, 38894, 38336, 37782,\r
+   37230, 36682, 36137, 35595, 35057, 34521, 33988, 33459, 32932, 32408, 31887,\r
+   31369, 30854, 30341, 29832, 29325, 28820, 28319, 27820, 27324, 26830, 26339,\r
+   25850, 25364, 24880, 24399, 23920, 23444, 22970, 22499, 22029, 21562, 21098,\r
+   20636, 20175, 19718, 19262, 18808, 18357, 17908, 17461, 17016, 16573, 16132,\r
+   15694, 15257, 14822, 14390, 13959, 13530, 13103, 12678, 12255, 11834, 11415,\r
+   10997, 10582, 10168, 9756, 9346, 8937, 8531, 8126, 7723, 7321, 6921, 6523,\r
+   6127, 5732, 5339, 4947, 4557, 4169, 3782, 3397, 3014, 2632, 2251, 1872, 1495,\r
+   1119, 744, 372\r
+#endif\r
+};\r
+\r
+static png_int_32\r
+png_log8bit(unsigned int x)\r
+{\r
+   unsigned int lg2 = 0;\r
+   /* Each time 'x' is multiplied by 2, 1 must be subtracted off the final log,\r
+    * because the log is actually negate that means adding 1.  The final\r
+    * returned value thus has the range 0 (for 255 input) to 7.994 (for 1\r
+    * input), return -1 for the overflow (log 0) case, - so the result is\r
+    * always at most 19 bits.\r
+    */\r
+   if ((x &= 0xff) == 0)\r
+      return -1;\r
+\r
+   if ((x & 0xf0) == 0)\r
+      lg2  = 4, x <<= 4;\r
+\r
+   if ((x & 0xc0) == 0)\r
+      lg2 += 2, x <<= 2;\r
+\r
+   if ((x & 0x80) == 0)\r
+      lg2 += 1, x <<= 1;\r
+\r
+   /* result is at most 19 bits, so this cast is safe: */\r
+   return (png_int_32)((lg2 << 16) + ((png_8bit_l2[x-128]+32768)>>16));\r
+}\r
+\r
+/* The above gives exact (to 16 binary places) log2 values for 8-bit images,\r
+ * for 16-bit images we use the most significant 8 bits of the 16-bit value to\r
+ * get an approximation then multiply the approximation by a correction factor\r
+ * determined by the remaining up to 8 bits.  This requires an additional step\r
+ * in the 16-bit case.\r
+ *\r
+ * We want log2(value/65535), we have log2(v'/255), where:\r
+ *\r
+ *    value = v' * 256 + v''\r
+ *          = v' * f\r
+ *\r
+ * So f is value/v', which is equal to (256+v''/v') since v' is in the range 128\r
+ * to 255 and v'' is in the range 0 to 255 f will be in the range 256 to less\r
+ * than 258.  The final factor also needs to correct for the fact that our 8-bit\r
+ * value is scaled by 255, whereas the 16-bit values must be scaled by 65535.\r
+ *\r
+ * This gives a final formula using a calculated value 'x' which is value/v' and\r
+ * scaling by 65536 to match the above table:\r
+ *\r
+ *   log2(x/257) * 65536\r
+ *\r
+ * Since these numbers are so close to '1' we can use simple linear\r
+ * interpolation between the two end values 256/257 (result -368.61) and 258/257\r
+ * (result 367.179).  The values used below are scaled by a further 64 to give\r
+ * 16-bit precision in the interpolation:\r
+ *\r
+ * Start (256): -23591\r
+ * Zero  (257):      0\r
+ * End   (258):  23499\r
+ */\r
+static png_int_32\r
+png_log16bit(png_uint_32 x)\r
+{\r
+   unsigned int lg2 = 0;\r
+\r
+   /* As above, but now the input has 16 bits. */\r
+   if ((x &= 0xffff) == 0)\r
+      return -1;\r
+\r
+   if ((x & 0xff00) == 0)\r
+      lg2  = 8, x <<= 8;\r
+\r
+   if ((x & 0xf000) == 0)\r
+      lg2 += 4, x <<= 4;\r
+\r
+   if ((x & 0xc000) == 0)\r
+      lg2 += 2, x <<= 2;\r
+\r
+   if ((x & 0x8000) == 0)\r
+      lg2 += 1, x <<= 1;\r
+\r
+   /* Calculate the base logarithm from the top 8 bits as a 28-bit fractional\r
+    * value.\r
+    */\r
+   lg2 <<= 28;\r
+   lg2 += (png_8bit_l2[(x>>8)-128]+8) >> 4;\r
+\r
+   /* Now we need to interpolate the factor, this requires a division by the top\r
+    * 8 bits.  Do this with maximum precision.\r
+    */\r
+   x = ((x << 16) + (x >> 9)) / (x >> 8);\r
+\r
+   /* Since we divided by the top 8 bits of 'x' there will be a '1' at 1<<24,\r
+    * the value at 1<<16 (ignoring this) will be 0 or 1; this gives us exactly\r
+    * 16 bits to interpolate to get the low bits of the result.  Round the\r
+    * answer.  Note that the end point values are scaled by 64 to retain overall\r
+    * precision and that 'lg2' is current scaled by an extra 12 bits, so adjust\r
+    * the overall scaling by 6-12.  Round at every step.\r
+    */\r
+   x -= 1U << 24;\r
+\r
+   if (x <= 65536U) /* <= '257' */\r
+      lg2 += ((23591U * (65536U-x)) + (1U << (16+6-12-1))) >> (16+6-12);\r
+\r
+   else\r
+      lg2 -= ((23499U * (x-65536U)) + (1U << (16+6-12-1))) >> (16+6-12);\r
+\r
+   /* Safe, because the result can't have more than 20 bits: */\r
+   return (png_int_32)((lg2 + 2048) >> 12);\r
+}\r
+\r
+/* The 'exp()' case must invert the above, taking a 20-bit fixed point\r
+ * logarithmic value and returning a 16 or 8-bit number as appropriate.  In\r
+ * each case only the low 16 bits are relevant - the fraction - since the\r
+ * integer bits (the top 4) simply determine a shift.\r
+ *\r
+ * The worst case is the 16-bit distinction between 65535 and 65534, this\r
+ * requires perhaps spurious accuracty in the decoding of the logarithm to\r
+ * distinguish log2(65535/65534.5) - 10^-5 or 17 bits.  There is little chance\r
+ * of getting this accuracy in practice.\r
+ *\r
+ * To deal with this the following exp() function works out the exponent of the\r
+ * frational part of the logarithm by using an accurate 32-bit value from the\r
+ * top four fractional bits then multiplying in the remaining bits.\r
+ */\r
+static const png_uint_32\r
+png_32bit_exp[16] =\r
+{\r
+   /* NOTE: the first entry is deliberately set to the maximum 32-bit value. */\r
+   4294967295U, 4112874773U, 3938502376U, 3771522796U, 3611622603U, 3458501653U,\r
+   3311872529U, 3171459999U, 3037000500U, 2908241642U, 2784941738U, 2666869345U,\r
+   2553802834U, 2445529972U, 2341847524U, 2242560872U\r
+};\r
+\r
+/* Adjustment table; provided to explain the numbers in the code below. */\r
+#if 0\r
+for (i=11;i>=0;--i){ print i, " ", (1 - e(-(2^i)/65536*l(2))) * 2^(32-i), "\n"}\r
+   11 44937.64284865548751208448\r
+   10 45180.98734845585101160448\r
+    9 45303.31936980687359311872\r
+    8 45364.65110595323018870784\r
+    7 45395.35850361789624614912\r
+    6 45410.72259715102037508096\r
+    5 45418.40724413220722311168\r
+    4 45422.25021786898173001728\r
+    3 45424.17186732298419044352\r
+    2 45425.13273269940811464704\r
+    1 45425.61317555035558641664\r
+    0 45425.85339951654943850496\r
+#endif\r
+\r
+static png_uint_32\r
+png_exp(png_fixed_point x)\r
+{\r
+   if (x > 0 && x <= 0xfffff) /* Else overflow or zero (underflow) */\r
+   {\r
+      /* Obtain a 4-bit approximation */\r
+      png_uint_32 e = png_32bit_exp[(x >> 12) & 0xf];\r
+\r
+      /* Incorporate the low 12 bits - these decrease the returned value by\r
+       * multiplying by a number less than 1 if the bit is set.  The multiplier\r
+       * is determined by the above table and the shift. Notice that the values\r
+       * converge on 45426 and this is used to allow linear interpolation of the\r
+       * low bits.\r
+       */\r
+      if (x & 0x800)\r
+         e -= (((e >> 16) * 44938U) +  16U) >> 5;\r
+\r
+      if (x & 0x400)\r
+         e -= (((e >> 16) * 45181U) +  32U) >> 6;\r
+\r
+      if (x & 0x200)\r
+         e -= (((e >> 16) * 45303U) +  64U) >> 7;\r
+\r
+      if (x & 0x100)\r
+         e -= (((e >> 16) * 45365U) + 128U) >> 8;\r
+\r
+      if (x & 0x080)\r
+         e -= (((e >> 16) * 45395U) + 256U) >> 9;\r
+\r
+      if (x & 0x040)\r
+         e -= (((e >> 16) * 45410U) + 512U) >> 10;\r
+\r
+      /* And handle the low 6 bits in a single block. */\r
+      e -= (((e >> 16) * 355U * (x & 0x3fU)) + 256U) >> 9;\r
+\r
+      /* Handle the upper bits of x. */\r
+      e >>= x >> 16;\r
+      return e;\r
+   }\r
+\r
+   /* Check for overflow */\r
+   if (x <= 0)\r
+      return png_32bit_exp[0];\r
+\r
+   /* Else underflow */\r
+   return 0;\r
+}\r
+\r
+static png_byte\r
+png_exp8bit(png_fixed_point lg2)\r
+{\r
+   /* Get a 32-bit value: */\r
+   png_uint_32 x = png_exp(lg2);\r
+\r
+   /* Convert the 32-bit value to 0..255 by multiplying by 256-1, note that the\r
+    * second, rounding, step can't overflow because of the first, subtraction,\r
+    * step.\r
+    */\r
+   x -= x >> 8;\r
+   return (png_byte)((x + 0x7fffffU) >> 24);\r
+}\r
+\r
+static png_uint_16\r
+png_exp16bit(png_fixed_point lg2)\r
+{\r
+   /* Get a 32-bit value: */\r
+   png_uint_32 x = png_exp(lg2);\r
+\r
+   /* Convert the 32-bit value to 0..65535 by multiplying by 65536-1: */\r
+   x -= x >> 16;\r
+   return (png_uint_16)((x + 32767U) >> 16);\r
+}\r
+#endif /* FLOATING_ARITHMETIC */\r
+\r
+png_byte\r
+png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val)\r
+{\r
+   if (value > 0 && value < 255)\r
+   {\r
+#     ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED\r
+         double r = floor(255*pow(value/255.,gamma_val*.00001)+.5);\r
+         return (png_byte)r;\r
+#     else\r
+         png_int_32 lg2 = png_log8bit(value);\r
+         png_fixed_point res;\r
+\r
+         if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1))\r
+            return png_exp8bit(res);\r
+\r
+         /* Overflow. */\r
+         value = 0;\r
+#     endif\r
+   }\r
+\r
+   return (png_byte)value;\r
+}\r
+\r
+png_uint_16\r
+png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma_val)\r
+{\r
+   if (value > 0 && value < 65535)\r
+   {\r
+#     ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED\r
+         double r = floor(65535*pow(value/65535.,gamma_val*.00001)+.5);\r
+         return (png_uint_16)r;\r
+#     else\r
+         png_int_32 lg2 = png_log16bit(value);\r
+         png_fixed_point res;\r
+\r
+         if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1))\r
+            return png_exp16bit(res);\r
+\r
+         /* Overflow. */\r
+         value = 0;\r
+#     endif\r
+   }\r
+\r
+   return (png_uint_16)value;\r
+}\r
+\r
+/* This does the right thing based on the bit_depth field of the\r
+ * png_struct, interpreting values as 8-bit or 16-bit.  While the result\r
+ * is nominally a 16-bit value if bit depth is 8 then the result is\r
+ * 8-bit (as are the arguments.)\r
+ */\r
+png_uint_16 /* PRIVATE */\r
+png_gamma_correct(png_structrp png_ptr, unsigned int value,\r
+    png_fixed_point gamma_val)\r
+{\r
+   if (png_ptr->bit_depth == 8)\r
+      return png_gamma_8bit_correct(value, gamma_val);\r
+\r
+   else\r
+      return png_gamma_16bit_correct(value, gamma_val);\r
+}\r
+\r
+/* Internal function to build a single 16-bit table - the table consists of\r
+ * 'num' 256 entry subtables, where 'num' is determined by 'shift' - the amount\r
+ * to shift the input values right (or 16-number_of_signifiant_bits).\r
+ *\r
+ * The caller is responsible for ensuring that the table gets cleaned up on\r
+ * png_error (i.e. if one of the mallocs below fails) - i.e. the *table argument\r
+ * should be somewhere that will be cleaned.\r
+ */\r
+static void\r
+png_build_16bit_table(png_structrp png_ptr, png_uint_16pp *ptable,\r
+   PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)\r
+{\r
+   /* Various values derived from 'shift': */\r
+   PNG_CONST unsigned int num = 1U << (8U - shift);\r
+   PNG_CONST unsigned int max = (1U << (16U - shift))-1U;\r
+   PNG_CONST unsigned int max_by_2 = 1U << (15U-shift);\r
+   unsigned int i;\r
+\r
+   png_uint_16pp table = *ptable =\r
+       (png_uint_16pp)png_calloc(png_ptr, num * (sizeof (png_uint_16p)));\r
+\r
+   for (i = 0; i < num; i++)\r
+   {\r
+      png_uint_16p sub_table = table[i] =\r
+          (png_uint_16p)png_malloc(png_ptr, 256 * (sizeof (png_uint_16)));\r
+\r
+      /* The 'threshold' test is repeated here because it can arise for one of\r
+       * the 16-bit tables even if the others don't hit it.\r
+       */\r
+      if (png_gamma_significant(gamma_val))\r
+      {\r
+         /* The old code would overflow at the end and this would cause the\r
+          * 'pow' function to return a result >1, resulting in an\r
+          * arithmetic error.  This code follows the spec exactly; ig is\r
+          * the recovered input sample, it always has 8-16 bits.\r
+          *\r
+          * We want input * 65535/max, rounded, the arithmetic fits in 32\r
+          * bits (unsigned) so long as max <= 32767.\r
+          */\r
+         unsigned int j;\r
+         for (j = 0; j < 256; j++)\r
+         {\r
+            png_uint_32 ig = (j << (8-shift)) + i;\r
+#           ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED\r
+               /* Inline the 'max' scaling operation: */\r
+               double d = floor(65535*pow(ig/(double)max, gamma_val*.00001)+.5);\r
+               sub_table[j] = (png_uint_16)d;\r
+#           else\r
+               if (shift)\r
+                  ig = (ig * 65535U + max_by_2)/max;\r
+\r
+               sub_table[j] = png_gamma_16bit_correct(ig, gamma_val);\r
+#           endif\r
+         }\r
+      }\r
+      else\r
+      {\r
+         /* We must still build a table, but do it the fast way. */\r
+         unsigned int j;\r
+\r
+         for (j = 0; j < 256; j++)\r
+         {\r
+            png_uint_32 ig = (j << (8-shift)) + i;\r
+\r
+            if (shift)\r
+               ig = (ig * 65535U + max_by_2)/max;\r
+\r
+            sub_table[j] = (png_uint_16)ig;\r
+         }\r
+      }\r
+   }\r
+}\r
+\r
+/* NOTE: this function expects the *inverse* of the overall gamma transformation\r
+ * required.\r
+ */\r
+static void\r
+png_build_16to8_table(png_structrp png_ptr, png_uint_16pp *ptable,\r
+   PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)\r
+{\r
+   PNG_CONST unsigned int num = 1U << (8U - shift);\r
+   PNG_CONST unsigned int max = (1U << (16U - shift))-1U;\r
+   unsigned int i;\r
+   png_uint_32 last;\r
+\r
+   png_uint_16pp table = *ptable =\r
+       (png_uint_16pp)png_calloc(png_ptr, num * (sizeof (png_uint_16p)));\r
+\r
+   /* 'num' is the number of tables and also the number of low bits of low\r
+    * bits of the input 16-bit value used to select a table.  Each table is\r
+    * itself index by the high 8 bits of the value.\r
+    */\r
+   for (i = 0; i < num; i++)\r
+      table[i] = (png_uint_16p)png_malloc(png_ptr,\r
+          256 * (sizeof (png_uint_16)));\r
+\r
+   /* 'gamma_val' is set to the reciprocal of the value calculated above, so\r
+    * pow(out,g) is an *input* value.  'last' is the last input value set.\r
+    *\r
+    * In the loop 'i' is used to find output values.  Since the output is\r
+    * 8-bit there are only 256 possible values.  The tables are set up to\r
+    * select the closest possible output value for each input by finding\r
+    * the input value at the boundary between each pair of output values\r
+    * and filling the table up to that boundary with the lower output\r
+    * value.\r
+    *\r
+    * The boundary values are 0.5,1.5..253.5,254.5.  Since these are 9-bit\r
+    * values the code below uses a 16-bit value in i; the values start at\r
+    * 128.5 (for 0.5) and step by 257, for a total of 254 values (the last\r
+    * entries are filled with 255).  Start i at 128 and fill all 'last'\r
+    * table entries <= 'max'\r
+    */\r
+   last = 0;\r
+   for (i = 0; i < 255; ++i) /* 8-bit output value */\r
+   {\r
+      /* Find the corresponding maximum input value */\r
+      png_uint_16 out = (png_uint_16)(i * 257U); /* 16-bit output value */\r
+\r
+      /* Find the boundary value in 16 bits: */\r
+      png_uint_32 bound = png_gamma_16bit_correct(out+128U, gamma_val);\r
+\r
+      /* Adjust (round) to (16-shift) bits: */\r
+      bound = (bound * max + 32768U)/65535U + 1U;\r
+\r
+      while (last < bound)\r
+      {\r
+         table[last & (0xffU >> shift)][last >> (8U - shift)] = out;\r
+         last++;\r
+      }\r
+   }\r
+\r
+   /* And fill in the final entries. */\r
+   while (last < (num << 8))\r
+   {\r
+      table[last & (0xff >> shift)][last >> (8U - shift)] = 65535U;\r
+      last++;\r
+   }\r
+}\r
+\r
+/* Build a single 8-bit table: same as the 16-bit case but much simpler (and\r
+ * typically much faster).  Note that libpng currently does no sBIT processing\r
+ * (apparently contrary to the spec) so a 256 entry table is always generated.\r
+ */\r
+static void\r
+png_build_8bit_table(png_structrp png_ptr, png_bytepp ptable,\r
+   PNG_CONST png_fixed_point gamma_val)\r
+{\r
+   unsigned int i;\r
+   png_bytep table = *ptable = (png_bytep)png_malloc(png_ptr, 256);\r
+\r
+   if (png_gamma_significant(gamma_val)) for (i=0; i<256; i++)\r
+      table[i] = png_gamma_8bit_correct(i, gamma_val);\r
+\r
+   else for (i=0; i<256; ++i)\r
+      table[i] = (png_byte)i;\r
+}\r
+\r
+/* Used from png_read_destroy and below to release the memory used by the gamma\r
+ * tables.\r
+ */\r
+void /* PRIVATE */\r
+png_destroy_gamma_table(png_structrp png_ptr)\r
+{\r
+   png_free(png_ptr, png_ptr->gamma_table);\r
+   png_ptr->gamma_table = NULL;\r
+\r
+   if (png_ptr->gamma_16_table != NULL)\r
+   {\r
+      int i;\r
+      int istop = (1 << (8 - png_ptr->gamma_shift));\r
+      for (i = 0; i < istop; i++)\r
+      {\r
+         png_free(png_ptr, png_ptr->gamma_16_table[i]);\r
+      }\r
+   png_free(png_ptr, png_ptr->gamma_16_table);\r
+   png_ptr->gamma_16_table = NULL;\r
+   }\r
+\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \\r
+   defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \\r
+   defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)\r
+   png_free(png_ptr, png_ptr->gamma_from_1);\r
+   png_ptr->gamma_from_1 = NULL;\r
+   png_free(png_ptr, png_ptr->gamma_to_1);\r
+   png_ptr->gamma_to_1 = NULL;\r
+\r
+   if (png_ptr->gamma_16_from_1 != NULL)\r
+   {\r
+      int i;\r
+      int istop = (1 << (8 - png_ptr->gamma_shift));\r
+      for (i = 0; i < istop; i++)\r
+      {\r
+         png_free(png_ptr, png_ptr->gamma_16_from_1[i]);\r
+      }\r
+   png_free(png_ptr, png_ptr->gamma_16_from_1);\r
+   png_ptr->gamma_16_from_1 = NULL;\r
+   }\r
+   if (png_ptr->gamma_16_to_1 != NULL)\r
+   {\r
+      int i;\r
+      int istop = (1 << (8 - png_ptr->gamma_shift));\r
+      for (i = 0; i < istop; i++)\r
+      {\r
+         png_free(png_ptr, png_ptr->gamma_16_to_1[i]);\r
+      }\r
+   png_free(png_ptr, png_ptr->gamma_16_to_1);\r
+   png_ptr->gamma_16_to_1 = NULL;\r
+   }\r
+#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */\r
+}\r
+\r
+/* We build the 8- or 16-bit gamma tables here.  Note that for 16-bit\r
+ * tables, we don't make a full table if we are reducing to 8-bit in\r
+ * the future.  Note also how the gamma_16 tables are segmented so that\r
+ * we don't need to allocate > 64K chunks for a full 16-bit table.\r
+ */\r
+void /* PRIVATE */\r
+png_build_gamma_table(png_structrp png_ptr, int bit_depth)\r
+{\r
+  png_debug(1, "in png_build_gamma_table");\r
+\r
+  /* Remove any existing table; this copes with multiple calls to\r
+   * png_read_update_info.  The warning is because building the gamma tables\r
+   * multiple times is a performance hit - it's harmless but the ability to call\r
+   * png_read_update_info() multiple times is new in 1.5.6 so it seems sensible\r
+   * to warn if the app introduces such a hit.\r
+   */\r
+  if (png_ptr->gamma_table != NULL || png_ptr->gamma_16_table != NULL)\r
+  {\r
+    png_warning(png_ptr, "gamma table being rebuilt");\r
+    png_destroy_gamma_table(png_ptr);\r
+  }\r
+\r
+  if (bit_depth <= 8)\r
+  {\r
+     png_build_8bit_table(png_ptr, &png_ptr->gamma_table,\r
+         png_ptr->screen_gamma > 0 ?  png_reciprocal2(png_ptr->colorspace.gamma,\r
+         png_ptr->screen_gamma) : PNG_FP_1);\r
+\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \\r
+   defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \\r
+   defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)\r
+     if (png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY))\r
+     {\r
+        png_build_8bit_table(png_ptr, &png_ptr->gamma_to_1,\r
+            png_reciprocal(png_ptr->colorspace.gamma));\r
+\r
+        png_build_8bit_table(png_ptr, &png_ptr->gamma_from_1,\r
+            png_ptr->screen_gamma > 0 ?  png_reciprocal(png_ptr->screen_gamma) :\r
+            png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */);\r
+     }\r
+#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */\r
+  }\r
+  else\r
+  {\r
+     png_byte shift, sig_bit;\r
+\r
+     if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)\r
+     {\r
+        sig_bit = png_ptr->sig_bit.red;\r
+\r
+        if (png_ptr->sig_bit.green > sig_bit)\r
+           sig_bit = png_ptr->sig_bit.green;\r
+\r
+        if (png_ptr->sig_bit.blue > sig_bit)\r
+           sig_bit = png_ptr->sig_bit.blue;\r
+     }\r
+     else\r
+        sig_bit = png_ptr->sig_bit.gray;\r
+\r
+     /* 16-bit gamma code uses this equation:\r
+      *\r
+      *   ov = table[(iv & 0xff) >> gamma_shift][iv >> 8]\r
+      *\r
+      * Where 'iv' is the input color value and 'ov' is the output value -\r
+      * pow(iv, gamma).\r
+      *\r
+      * Thus the gamma table consists of up to 256 256 entry tables.  The table\r
+      * is selected by the (8-gamma_shift) most significant of the low 8 bits of\r
+      * the color value then indexed by the upper 8 bits:\r
+      *\r
+      *   table[low bits][high 8 bits]\r
+      *\r
+      * So the table 'n' corresponds to all those 'iv' of:\r
+      *\r
+      *   <all high 8-bit values><n << gamma_shift>..<(n+1 << gamma_shift)-1>\r
+      *\r
+      */\r
+     if (sig_bit > 0 && sig_bit < 16U)\r
+        shift = (png_byte)(16U - sig_bit); /* shift == insignificant bits */\r
+\r
+     else\r
+        shift = 0; /* keep all 16 bits */\r
+\r
+     if (png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8))\r
+     {\r
+        /* PNG_MAX_GAMMA_8 is the number of bits to keep - effectively\r
+         * the significant bits in the *input* when the output will\r
+         * eventually be 8 bits.  By default it is 11.\r
+         */\r
+        if (shift < (16U - PNG_MAX_GAMMA_8))\r
+           shift = (16U - PNG_MAX_GAMMA_8);\r
+     }\r
+\r
+     if (shift > 8U)\r
+        shift = 8U; /* Guarantees at least one table! */\r
+\r
+     png_ptr->gamma_shift = shift;\r
+\r
+#ifdef PNG_16BIT_SUPPORTED\r
+     /* NOTE: prior to 1.5.4 this test used to include PNG_BACKGROUND (now\r
+      * PNG_COMPOSE).  This effectively smashed the background calculation for\r
+      * 16-bit output because the 8-bit table assumes the result will be reduced\r
+      * to 8 bits.\r
+      */\r
+     if (png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8))\r
+#endif\r
+         png_build_16to8_table(png_ptr, &png_ptr->gamma_16_table, shift,\r
+         png_ptr->screen_gamma > 0 ? png_product2(png_ptr->colorspace.gamma,\r
+         png_ptr->screen_gamma) : PNG_FP_1);\r
+\r
+#ifdef PNG_16BIT_SUPPORTED\r
+     else\r
+         png_build_16bit_table(png_ptr, &png_ptr->gamma_16_table, shift,\r
+         png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->colorspace.gamma,\r
+         png_ptr->screen_gamma) : PNG_FP_1);\r
+#endif\r
+\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \\r
+   defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \\r
+   defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)\r
+     if (png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY))\r
+     {\r
+        png_build_16bit_table(png_ptr, &png_ptr->gamma_16_to_1, shift,\r
+            png_reciprocal(png_ptr->colorspace.gamma));\r
+\r
+        /* Notice that the '16 from 1' table should be full precision, however\r
+         * the lookup on this table still uses gamma_shift, so it can't be.\r
+         * TODO: fix this.\r
+         */\r
+        png_build_16bit_table(png_ptr, &png_ptr->gamma_16_from_1, shift,\r
+            png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) :\r
+            png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */);\r
+     }\r
+#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */\r
+  }\r
+}\r
+#endif /* READ_GAMMA */\r
+\r
+/* HARDWARE OPTION SUPPORT */\r
+#ifdef PNG_SET_OPTION_SUPPORTED\r
+int PNGAPI\r
+png_set_option(png_structrp png_ptr, int option, int onoff)\r
+{\r
+   if (png_ptr != NULL && option >= 0 && option < PNG_OPTION_NEXT &&\r
+      (option & 1) == 0)\r
+   {\r
+      int mask = 3 << option;\r
+      int setting = (2 + (onoff != 0)) << option;\r
+      int current = png_ptr->options;\r
+\r
+      png_ptr->options = (png_byte)((current & ~mask) | setting);\r
+\r
+      return (current & mask) >> option;\r
+   }\r
+\r
+   return PNG_OPTION_INVALID;\r
+}\r
+#endif\r
+\r
+/* sRGB support */\r
+#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\\r
+   defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)\r
+/* sRGB conversion tables; these are machine generated with the code in\r
+ * contrib/tools/makesRGB.c.  The actual sRGB transfer curve defined in the\r
+ * specification (see the article at http://en.wikipedia.org/wiki/SRGB)\r
+ * is used, not the gamma=1/2.2 approximation use elsewhere in libpng.\r
+ * The sRGB to linear table is exact (to the nearest 16 bit linear fraction).\r
+ * The inverse (linear to sRGB) table has accuracies as follows:\r
+ *\r
+ * For all possible (255*65535+1) input values:\r
+ *\r
+ *    error: -0.515566 - 0.625971, 79441 (0.475369%) of readings inexact\r
+ *\r
+ * For the input values corresponding to the 65536 16-bit values:\r
+ *\r
+ *    error: -0.513727 - 0.607759, 308 (0.469978%) of readings inexact\r
+ *\r
+ * In all cases the inexact readings are off by one.\r
+ */\r
+\r
+#ifdef PNG_SIMPLIFIED_READ_SUPPORTED\r
+/* The convert-to-sRGB table is only currently required for read. */\r
+const png_uint_16 png_sRGB_table[256] =\r
+{\r
+   0,20,40,60,80,99,119,139,\r
+   159,179,199,219,241,264,288,313,\r
+   340,367,396,427,458,491,526,562,\r
+   599,637,677,718,761,805,851,898,\r
+   947,997,1048,1101,1156,1212,1270,1330,\r
+   1391,1453,1517,1583,1651,1720,1790,1863,\r
+   1937,2013,2090,2170,2250,2333,2418,2504,\r
+   2592,2681,2773,2866,2961,3058,3157,3258,\r
+   3360,3464,3570,3678,3788,3900,4014,4129,\r
+   4247,4366,4488,4611,4736,4864,4993,5124,\r
+   5257,5392,5530,5669,5810,5953,6099,6246,\r
+   6395,6547,6700,6856,7014,7174,7335,7500,\r
+   7666,7834,8004,8177,8352,8528,8708,8889,\r
+   9072,9258,9445,9635,9828,10022,10219,10417,\r
+   10619,10822,11028,11235,11446,11658,11873,12090,\r
+   12309,12530,12754,12980,13209,13440,13673,13909,\r
+   14146,14387,14629,14874,15122,15371,15623,15878,\r
+   16135,16394,16656,16920,17187,17456,17727,18001,\r
+   18277,18556,18837,19121,19407,19696,19987,20281,\r
+   20577,20876,21177,21481,21787,22096,22407,22721,\r
+   23038,23357,23678,24002,24329,24658,24990,25325,\r
+   25662,26001,26344,26688,27036,27386,27739,28094,\r
+   28452,28813,29176,29542,29911,30282,30656,31033,\r
+   31412,31794,32179,32567,32957,33350,33745,34143,\r
+   34544,34948,35355,35764,36176,36591,37008,37429,\r
+   37852,38278,38706,39138,39572,40009,40449,40891,\r
+   41337,41785,42236,42690,43147,43606,44069,44534,\r
+   45002,45473,45947,46423,46903,47385,47871,48359,\r
+   48850,49344,49841,50341,50844,51349,51858,52369,\r
+   52884,53401,53921,54445,54971,55500,56032,56567,\r
+   57105,57646,58190,58737,59287,59840,60396,60955,\r
+   61517,62082,62650,63221,63795,64372,64952,65535\r
+};\r
+\r
+#endif /* simplified read only */\r
+\r
+/* The base/delta tables are required for both read and write (but currently\r
+ * only the simplified versions.)\r
+ */\r
+const png_uint_16 png_sRGB_base[512] =\r
+{\r
+   128,1782,3383,4644,5675,6564,7357,8074,\r
+   8732,9346,9921,10463,10977,11466,11935,12384,\r
+   12816,13233,13634,14024,14402,14769,15125,15473,\r
+   15812,16142,16466,16781,17090,17393,17690,17981,\r
+   18266,18546,18822,19093,19359,19621,19879,20133,\r
+   20383,20630,20873,21113,21349,21583,21813,22041,\r
+   22265,22487,22707,22923,23138,23350,23559,23767,\r
+   23972,24175,24376,24575,24772,24967,25160,25352,\r
+   25542,25730,25916,26101,26284,26465,26645,26823,\r
+   27000,27176,27350,27523,27695,27865,28034,28201,\r
+   28368,28533,28697,28860,29021,29182,29341,29500,\r
+   29657,29813,29969,30123,30276,30429,30580,30730,\r
+   30880,31028,31176,31323,31469,31614,31758,31902,\r
+   32045,32186,32327,32468,32607,32746,32884,33021,\r
+   33158,33294,33429,33564,33697,33831,33963,34095,\r
+   34226,34357,34486,34616,34744,34873,35000,35127,\r
+   35253,35379,35504,35629,35753,35876,35999,36122,\r
+   36244,36365,36486,36606,36726,36845,36964,37083,\r
+   37201,37318,37435,37551,37668,37783,37898,38013,\r
+   38127,38241,38354,38467,38580,38692,38803,38915,\r
+   39026,39136,39246,39356,39465,39574,39682,39790,\r
+   39898,40005,40112,40219,40325,40431,40537,40642,\r
+   40747,40851,40955,41059,41163,41266,41369,41471,\r
+   41573,41675,41777,41878,41979,42079,42179,42279,\r
+   42379,42478,42577,42676,42775,42873,42971,43068,\r
+   43165,43262,43359,43456,43552,43648,43743,43839,\r
+   43934,44028,44123,44217,44311,44405,44499,44592,\r
+   44685,44778,44870,44962,45054,45146,45238,45329,\r
+   45420,45511,45601,45692,45782,45872,45961,46051,\r
+   46140,46229,46318,46406,46494,46583,46670,46758,\r
+   46846,46933,47020,47107,47193,47280,47366,47452,\r
+   47538,47623,47709,47794,47879,47964,48048,48133,\r
+   48217,48301,48385,48468,48552,48635,48718,48801,\r
+   48884,48966,49048,49131,49213,49294,49376,49458,\r
+   49539,49620,49701,49782,49862,49943,50023,50103,\r
+   50183,50263,50342,50422,50501,50580,50659,50738,\r
+   50816,50895,50973,51051,51129,51207,51285,51362,\r
+   51439,51517,51594,51671,51747,51824,51900,51977,\r
+   52053,52129,52205,52280,52356,52432,52507,52582,\r
+   52657,52732,52807,52881,52956,53030,53104,53178,\r
+   53252,53326,53400,53473,53546,53620,53693,53766,\r
+   53839,53911,53984,54056,54129,54201,54273,54345,\r
+   54417,54489,54560,54632,54703,54774,54845,54916,\r
+   54987,55058,55129,55199,55269,55340,55410,55480,\r
+   55550,55620,55689,55759,55828,55898,55967,56036,\r
+   56105,56174,56243,56311,56380,56448,56517,56585,\r
+   56653,56721,56789,56857,56924,56992,57059,57127,\r
+   57194,57261,57328,57395,57462,57529,57595,57662,\r
+   57728,57795,57861,57927,57993,58059,58125,58191,\r
+   58256,58322,58387,58453,58518,58583,58648,58713,\r
+   58778,58843,58908,58972,59037,59101,59165,59230,\r
+   59294,59358,59422,59486,59549,59613,59677,59740,\r
+   59804,59867,59930,59993,60056,60119,60182,60245,\r
+   60308,60370,60433,60495,60558,60620,60682,60744,\r
+   60806,60868,60930,60992,61054,61115,61177,61238,\r
+   61300,61361,61422,61483,61544,61605,61666,61727,\r
+   61788,61848,61909,61969,62030,62090,62150,62211,\r
+   62271,62331,62391,62450,62510,62570,62630,62689,\r
+   62749,62808,62867,62927,62986,63045,63104,63163,\r
+   63222,63281,63340,63398,63457,63515,63574,63632,\r
+   63691,63749,63807,63865,63923,63981,64039,64097,\r
+   64155,64212,64270,64328,64385,64443,64500,64557,\r
+   64614,64672,64729,64786,64843,64900,64956,65013,\r
+   65070,65126,65183,65239,65296,65352,65409,65465\r
+};\r
+\r
+const png_byte png_sRGB_delta[512] =\r
+{\r
+   207,201,158,129,113,100,90,82,77,72,68,64,61,59,56,54,\r
+   52,50,49,47,46,45,43,42,41,40,39,39,38,37,36,36,\r
+   35,34,34,33,33,32,32,31,31,30,30,30,29,29,28,28,\r
+   28,27,27,27,27,26,26,26,25,25,25,25,24,24,24,24,\r
+   23,23,23,23,23,22,22,22,22,22,22,21,21,21,21,21,\r
+   21,20,20,20,20,20,20,20,20,19,19,19,19,19,19,19,\r
+   19,18,18,18,18,18,18,18,18,18,18,17,17,17,17,17,\r
+   17,17,17,17,17,17,16,16,16,16,16,16,16,16,16,16,\r
+   16,16,16,16,15,15,15,15,15,15,15,15,15,15,15,15,\r
+   15,15,15,15,14,14,14,14,14,14,14,14,14,14,14,14,\r
+   14,14,14,14,14,14,14,13,13,13,13,13,13,13,13,13,\r
+   13,13,13,13,13,13,13,13,13,13,13,13,13,13,12,12,\r
+   12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,\r
+   12,12,12,12,12,12,12,12,12,12,12,12,11,11,11,11,\r
+   11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,\r
+   11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,\r
+   11,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,\r
+   10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,\r
+   10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,\r
+   10,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,\r
+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,\r
+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,\r
+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,\r
+   9,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,\r
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,\r
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,\r
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,\r
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,\r
+   8,8,8,8,8,8,8,8,8,7,7,7,7,7,7,7,\r
+   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,\r
+   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,\r
+   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7\r
+};\r
+#endif /* SIMPLIFIED READ/WRITE sRGB support */\r
+\r
+/* SIMPLIFIED READ/WRITE SUPPORT */\r
+#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\\r
+   defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)\r
+static int\r
+png_image_free_function(png_voidp argument)\r
+{\r
+   png_imagep image = png_voidcast(png_imagep, argument);\r
+   png_controlp cp = image->opaque;\r
+   png_control c;\r
+\r
+   /* Double check that we have a png_ptr - it should be impossible to get here\r
+    * without one.\r
+    */\r
+   if (cp->png_ptr == NULL)\r
+      return 0;\r
+\r
+   /* First free any data held in the control structure. */\r
+#  ifdef PNG_STDIO_SUPPORTED\r
+      if (cp->owned_file)\r
+      {\r
+         FILE *fp = png_voidcast(FILE*, cp->png_ptr->io_ptr);\r
+         cp->owned_file = 0;\r
+\r
+         /* Ignore errors here. */\r
+         if (fp != NULL)\r
+         {\r
+            cp->png_ptr->io_ptr = NULL;\r
+            (void)fclose(fp);\r
+         }\r
+      }\r
+#  endif\r
+\r
+   /* Copy the control structure so that the original, allocated, version can be\r
+    * safely freed.  Notice that a png_error here stops the remainder of the\r
+    * cleanup, but this is probably fine because that would indicate bad memory\r
+    * problems anyway.\r
+    */\r
+   c = *cp;\r
+   image->opaque = &c;\r
+   png_free(c.png_ptr, cp);\r
+\r
+   /* Then the structures, calling the correct API. */\r
+   if (c.for_write)\r
+   {\r
+#     ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED\r
+         png_destroy_write_struct(&c.png_ptr, &c.info_ptr);\r
+#     else\r
+         png_error(c.png_ptr, "simplified write not supported");\r
+#     endif\r
+   }\r
+   else\r
+   {\r
+#     ifdef PNG_SIMPLIFIED_READ_SUPPORTED\r
+         png_destroy_read_struct(&c.png_ptr, &c.info_ptr, NULL);\r
+#     else\r
+         png_error(c.png_ptr, "simplified read not supported");\r
+#     endif\r
+   }\r
+\r
+   /* Success. */\r
+   return 1;\r
+}\r
+\r
+void PNGAPI\r
+png_image_free(png_imagep image)\r
+{\r
+   /* Safely call the real function, but only if doing so is safe at this point\r
+    * (if not inside an error handling context).  Otherwise assume\r
+    * png_safe_execute will call this API after the return.\r
+    */\r
+   if (image != NULL && image->opaque != NULL &&\r
+      image->opaque->error_buf == NULL)\r
+   {\r
+      /* Ignore errors here: */\r
+      (void)png_safe_execute(image, png_image_free_function, image);\r
+      image->opaque = NULL;\r
+   }\r
+}\r
+\r
+int /* PRIVATE */\r
+png_image_error(png_imagep image, png_const_charp error_message)\r
+{\r
+   /* Utility to log an error. */\r
+   png_safecat(image->message, (sizeof image->message), 0, error_message);\r
+   image->warning_or_error |= PNG_IMAGE_ERROR;\r
+   png_image_free(image);\r
+   return 0;\r
+}\r
+\r
+#endif /* SIMPLIFIED READ/WRITE */\r
+#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */\r
diff --git a/samples/fx_lpng/lpng_v163/fx_pngerror.c b/samples/fx_lpng/lpng_v163/fx_pngerror.c
new file mode 100644 (file)
index 0000000..2125e4c
--- /dev/null
@@ -0,0 +1,931 @@
+/* pngerror.c - stub functions for i/o and memory allocation\r
+ *\r
+ * Last changed in libpng 1.6.1 [March 28, 2013]\r
+ * Copyright (c) 1998-2013 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ *\r
+ * This code is released under the libpng license.\r
+ * For conditions of distribution and use, see the disclaimer\r
+ * and license in png.h\r
+ *\r
+ * This file provides a location for all error handling.  Users who\r
+ * need special error handling are expected to write replacement functions\r
+ * and use png_set_error_fn() to use those functions.  See the instructions\r
+ * at each function.\r
+ */\r
+\r
+#include "pngpriv.h"\r
+\r
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)\r
+\r
+static PNG_FUNCTION(void, png_default_error,PNGARG((png_const_structrp png_ptr,\r
+    png_const_charp error_message)),PNG_NORETURN);\r
+\r
+#ifdef PNG_WARNINGS_SUPPORTED\r
+static void /* PRIVATE */\r
+png_default_warning PNGARG((png_const_structrp png_ptr,\r
+   png_const_charp warning_message));\r
+#endif /* PNG_WARNINGS_SUPPORTED */\r
+\r
+/* This function is called whenever there is a fatal error.  This function\r
+ * should not be changed.  If there is a need to handle errors differently,\r
+ * you should supply a replacement error function and use png_set_error_fn()\r
+ * to replace the error function at run-time.\r
+ */\r
+#ifdef PNG_ERROR_TEXT_SUPPORTED\r
+PNG_FUNCTION(void,PNGAPI\r
+png_error,(png_const_structrp png_ptr, png_const_charp error_message),\r
+   PNG_NORETURN)\r
+{\r
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
+   char msg[16];\r
+   if (png_ptr != NULL)\r
+   {\r
+      if (png_ptr->flags&\r
+         (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))\r
+      {\r
+         if (*error_message == PNG_LITERAL_SHARP)\r
+         {\r
+            /* Strip "#nnnn " from beginning of error message. */\r
+            int offset;\r
+            for (offset = 1; offset<15; offset++)\r
+               if (error_message[offset] == ' ')\r
+                  break;\r
+\r
+            if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)\r
+            {\r
+               int i;\r
+               for (i = 0; i < offset - 1; i++)\r
+                  msg[i] = error_message[i + 1];\r
+               msg[i - 1] = '\0';\r
+               error_message = msg;\r
+            }\r
+\r
+            else\r
+               error_message += offset;\r
+      }\r
+\r
+      else\r
+      {\r
+         if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)\r
+         {\r
+            msg[0] = '0';\r
+            msg[1] = '\0';\r
+            error_message = msg;\r
+         }\r
+       }\r
+     }\r
+   }\r
+#endif\r
+   if (png_ptr != NULL && png_ptr->error_fn != NULL)\r
+      (*(png_ptr->error_fn))(png_constcast(png_structrp,png_ptr),\r
+          error_message);\r
+\r
+   /* If the custom handler doesn't exist, or if it returns,\r
+      use the default handler, which will not return. */\r
+   png_default_error(png_ptr, error_message);\r
+}\r
+#else\r
+PNG_FUNCTION(void,PNGAPI\r
+png_err,(png_const_structrp png_ptr),PNG_NORETURN)\r
+{\r
+   /* Prior to 1.5.2 the error_fn received a NULL pointer, expressed\r
+    * erroneously as '\0', instead of the empty string "".  This was\r
+    * apparently an error, introduced in libpng-1.2.20, and png_default_error\r
+    * will crash in this case.\r
+    */\r
+   if (png_ptr != NULL && png_ptr->error_fn != NULL)\r
+      (*(png_ptr->error_fn))(png_constcast(png_structrp,png_ptr), "");\r
+\r
+   /* If the custom handler doesn't exist, or if it returns,\r
+      use the default handler, which will not return. */\r
+   png_default_error(png_ptr, "");\r
+}\r
+#endif /* PNG_ERROR_TEXT_SUPPORTED */\r
+\r
+/* Utility to safely appends strings to a buffer.  This never errors out so\r
+ * error checking is not required in the caller.\r
+ */\r
+size_t\r
+png_safecat(png_charp buffer, size_t bufsize, size_t pos,\r
+   png_const_charp string)\r
+{\r
+   if (buffer != NULL && pos < bufsize)\r
+   {\r
+      if (string != NULL)\r
+         while (*string != '\0' && pos < bufsize-1)\r
+           buffer[pos++] = *string++;\r
+\r
+      buffer[pos] = '\0';\r
+   }\r
+\r
+   return pos;\r
+}\r
+\r
+#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_TIME_RFC1123_SUPPORTED)\r
+/* Utility to dump an unsigned value into a buffer, given a start pointer and\r
+ * and end pointer (which should point just *beyond* the end of the buffer!)\r
+ * Returns the pointer to the start of the formatted string.\r
+ */\r
+png_charp\r
+png_format_number(png_const_charp start, png_charp end, int format,\r
+   png_alloc_size_t number)\r
+{\r
+   int count = 0;    /* number of digits output */\r
+   int mincount = 1; /* minimum number required */\r
+   int output = 0;   /* digit output (for the fixed point format) */\r
+\r
+   *--end = '\0';\r
+\r
+   /* This is written so that the loop always runs at least once, even with\r
+    * number zero.\r
+    */\r
+   while (end > start && (number != 0 || count < mincount))\r
+   {\r
+\r
+      static const char digits[] = "0123456789ABCDEF";\r
+\r
+      switch (format)\r
+      {\r
+         case PNG_NUMBER_FORMAT_fixed:\r
+            /* Needs five digits (the fraction) */\r
+            mincount = 5;\r
+            if (output || number % 10 != 0)\r
+            {\r
+               *--end = digits[number % 10];\r
+               output = 1;\r
+            }\r
+            number /= 10;\r
+            break;\r
+\r
+         case PNG_NUMBER_FORMAT_02u:\r
+            /* Expects at least 2 digits. */\r
+            mincount = 2;\r
+            /* FALL THROUGH */\r
+\r
+         case PNG_NUMBER_FORMAT_u:\r
+            *--end = digits[number % 10];\r
+            number /= 10;\r
+            break;\r
+\r
+         case PNG_NUMBER_FORMAT_02x:\r
+            /* This format expects at least two digits */\r
+            mincount = 2;\r
+            /* FALL THROUGH */\r
+\r
+         case PNG_NUMBER_FORMAT_x:\r
+            *--end = digits[number & 0xf];\r
+            number >>= 4;\r
+            break;\r
+\r
+         default: /* an error */\r
+            number = 0;\r
+            break;\r
+      }\r
+\r
+      /* Keep track of the number of digits added */\r
+      ++count;\r
+\r
+      /* Float a fixed number here: */\r
+      if (format == PNG_NUMBER_FORMAT_fixed) if (count == 5) if (end > start)\r
+      {\r
+         /* End of the fraction, but maybe nothing was output?  In that case\r
+          * drop the decimal point.  If the number is a true zero handle that\r
+          * here.\r
+          */\r
+         if (output)\r
+            *--end = '.';\r
+         else if (number == 0) /* and !output */\r
+            *--end = '0';\r
+      }\r
+   }\r
+\r
+   return end;\r
+}\r
+#endif\r
+\r
+#ifdef PNG_WARNINGS_SUPPORTED\r
+/* This function is called whenever there is a non-fatal error.  This function\r
+ * should not be changed.  If there is a need to handle warnings differently,\r
+ * you should supply a replacement warning function and use\r
+ * png_set_error_fn() to replace the warning function at run-time.\r
+ */\r
+void PNGAPI\r
+png_warning(png_const_structrp png_ptr, png_const_charp warning_message)\r
+{\r
+   int offset = 0;\r
+   if (png_ptr != NULL)\r
+   {\r
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
+   if (png_ptr->flags&\r
+       (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))\r
+#endif\r
+      {\r
+         if (*warning_message == PNG_LITERAL_SHARP)\r
+         {\r
+            for (offset = 1; offset < 15; offset++)\r
+               if (warning_message[offset] == ' ')\r
+                  break;\r
+         }\r
+      }\r
+   }\r
+   if (png_ptr != NULL && png_ptr->warning_fn != NULL)\r
+      (*(png_ptr->warning_fn))(png_constcast(png_structrp,png_ptr),\r
+         warning_message + offset);\r
+   else\r
+      png_default_warning(png_ptr, warning_message + offset);\r
+}\r
+\r
+/* These functions support 'formatted' warning messages with up to\r
+ * PNG_WARNING_PARAMETER_COUNT parameters.  In the format string the parameter\r
+ * is introduced by @<number>, where 'number' starts at 1.  This follows the\r
+ * standard established by X/Open for internationalizable error messages.\r
+ */\r
+void\r
+png_warning_parameter(png_warning_parameters p, int number,\r
+   png_const_charp string)\r
+{\r
+   if (number > 0 && number <= PNG_WARNING_PARAMETER_COUNT)\r
+      (void)png_safecat(p[number-1], (sizeof p[number-1]), 0, string);\r
+}\r
+\r
+void\r
+png_warning_parameter_unsigned(png_warning_parameters p, int number, int format,\r
+   png_alloc_size_t value)\r
+{\r
+   char buffer[PNG_NUMBER_BUFFER_SIZE];\r
+   png_warning_parameter(p, number, PNG_FORMAT_NUMBER(buffer, format, value));\r
+}\r
+\r
+void\r
+png_warning_parameter_signed(png_warning_parameters p, int number, int format,\r
+   png_int_32 value)\r
+{\r
+   png_alloc_size_t u;\r
+   png_charp str;\r
+   char buffer[PNG_NUMBER_BUFFER_SIZE];\r
+\r
+   /* Avoid overflow by doing the negate in a png_alloc_size_t: */\r
+   u = (png_alloc_size_t)value;\r
+   if (value < 0)\r
+      u = ~u + 1;\r
+\r
+   str = PNG_FORMAT_NUMBER(buffer, format, u);\r
+\r
+   if (value < 0 && str > buffer)\r
+      *--str = '-';\r
+\r
+   png_warning_parameter(p, number, str);\r
+}\r
+\r
+void\r
+png_formatted_warning(png_const_structrp png_ptr, png_warning_parameters p,\r
+   png_const_charp message)\r
+{\r
+   /* The internal buffer is just 192 bytes - enough for all our messages,\r
+    * overflow doesn't happen because this code checks!  If someone figures\r
+    * out how to send us a message longer than 192 bytes, all that will\r
+    * happen is that the message will be truncated appropriately.\r
+    */\r
+   size_t i = 0; /* Index in the msg[] buffer: */\r
+   char msg[192];\r
+\r
+   /* Each iteration through the following loop writes at most one character\r
+    * to msg[i++] then returns here to validate that there is still space for\r
+    * the trailing '\0'.  It may (in the case of a parameter) read more than\r
+    * one character from message[]; it must check for '\0' and continue to the\r
+    * test if it finds the end of string.\r
+    */\r
+   while (i<(sizeof msg)-1 && *message != '\0')\r
+   {\r
+      /* '@' at end of string is now just printed (previously it was skipped);\r
+       * it is an error in the calling code to terminate the string with @.\r
+       */\r
+      if (p != NULL && *message == '@' && message[1] != '\0')\r
+      {\r
+         int parameter_char = *++message; /* Consume the '@' */\r
+         static const char valid_parameters[] = "123456789";\r
+         int parameter = 0;\r
+\r
+         /* Search for the parameter digit, the index in the string is the\r
+          * parameter to use.\r
+          */\r
+         while (valid_parameters[parameter] != parameter_char &&\r
+            valid_parameters[parameter] != '\0')\r
+            ++parameter;\r
+\r
+         /* If the parameter digit is out of range it will just get printed. */\r
+         if (parameter < PNG_WARNING_PARAMETER_COUNT)\r
+         {\r
+            /* Append this parameter */\r
+            png_const_charp parm = p[parameter];\r
+            png_const_charp pend = p[parameter] + (sizeof p[parameter]);\r
+\r
+            /* No need to copy the trailing '\0' here, but there is no guarantee\r
+             * that parm[] has been initialized, so there is no guarantee of a\r
+             * trailing '\0':\r
+             */\r
+            while (i<(sizeof msg)-1 && *parm != '\0' && parm < pend)\r
+               msg[i++] = *parm++;\r
+\r
+            /* Consume the parameter digit too: */\r
+            ++message;\r
+            continue;\r
+         }\r
+\r
+         /* else not a parameter and there is a character after the @ sign; just\r
+          * copy that.  This is known not to be '\0' because of the test above.\r
+          */\r
+      }\r
+\r
+      /* At this point *message can't be '\0', even in the bad parameter case\r
+       * above where there is a lone '@' at the end of the message string.\r
+       */\r
+      msg[i++] = *message++;\r
+   }\r
+\r
+   /* i is always less than (sizeof msg), so: */\r
+   msg[i] = '\0';\r
+\r
+   /* And this is the formatted message. It may be larger than\r
+    * PNG_MAX_ERROR_TEXT, but that is only used for 'chunk' errors and these\r
+    * are not (currently) formatted.\r
+    */\r
+   png_warning(png_ptr, msg);\r
+}\r
+#endif /* PNG_WARNINGS_SUPPORTED */\r
+\r
+#ifdef PNG_BENIGN_ERRORS_SUPPORTED\r
+void PNGAPI\r
+png_benign_error(png_const_structrp png_ptr, png_const_charp error_message)\r
+{\r
+   if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)\r
+   {\r
+#     ifdef PNG_READ_SUPPORTED\r
+         if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&\r
+            png_ptr->chunk_name != 0)\r
+            png_chunk_warning(png_ptr, error_message);\r
+         else\r
+#     endif\r
+      png_warning(png_ptr, error_message);\r
+   }\r
+\r
+   else\r
+   {\r
+#     ifdef PNG_READ_SUPPORTED\r
+         if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&\r
+            png_ptr->chunk_name != 0)\r
+            png_chunk_error(png_ptr, error_message);\r
+         else\r
+#     endif\r
+      png_error(png_ptr, error_message);\r
+   }\r
+}\r
+\r
+void /* PRIVATE */\r
+png_app_warning(png_const_structrp png_ptr, png_const_charp error_message)\r
+{\r
+  if (png_ptr->flags & PNG_FLAG_APP_WARNINGS_WARN)\r
+     png_warning(png_ptr, error_message);\r
+  else\r
+     png_error(png_ptr, error_message);\r
+}\r
+\r
+void /* PRIVATE */\r
+png_app_error(png_const_structrp png_ptr, png_const_charp error_message)\r
+{\r
+  if (png_ptr->flags & PNG_FLAG_APP_ERRORS_WARN)\r
+     png_warning(png_ptr, error_message);\r
+  else\r
+     png_error(png_ptr, error_message);\r
+}\r
+#endif /* BENIGN_ERRORS */\r
+\r
+/* These utilities are used internally to build an error message that relates\r
+ * to the current chunk.  The chunk name comes from png_ptr->chunk_name,\r
+ * this is used to prefix the message.  The message is limited in length\r
+ * to 63 bytes, the name characters are output as hex digits wrapped in []\r
+ * if the character is invalid.\r
+ */\r
+#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))\r
+static PNG_CONST char png_digit[16] = {\r
+   '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',\r
+   'A', 'B', 'C', 'D', 'E', 'F'\r
+};\r
+\r
+#define PNG_MAX_ERROR_TEXT 196 /* Currently limited be profile_error in png.c */\r
+#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)\r
+static void /* PRIVATE */\r
+png_format_buffer(png_const_structrp png_ptr, png_charp buffer, png_const_charp\r
+    error_message)\r
+{\r
+   png_uint_32 chunk_name = png_ptr->chunk_name;\r
+   int iout = 0, ishift = 24;\r
+\r
+   while (ishift >= 0)\r
+   {\r
+      int c = (int)(chunk_name >> ishift) & 0xff;\r
+\r
+      ishift -= 8;\r
+      if (isnonalpha(c))\r
+      {\r
+         buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET;\r
+         buffer[iout++] = png_digit[(c & 0xf0) >> 4];\r
+         buffer[iout++] = png_digit[c & 0x0f];\r
+         buffer[iout++] = PNG_LITERAL_RIGHT_SQUARE_BRACKET;\r
+      }\r
+\r
+      else\r
+      {\r
+         buffer[iout++] = (char)c;\r
+      }\r
+   }\r
+\r
+   if (error_message == NULL)\r
+      buffer[iout] = '\0';\r
+\r
+   else\r
+   {\r
+      int iin = 0;\r
+\r
+      buffer[iout++] = ':';\r
+      buffer[iout++] = ' ';\r
+\r
+      while (iin < PNG_MAX_ERROR_TEXT-1 && error_message[iin] != '\0')\r
+         buffer[iout++] = error_message[iin++];\r
+\r
+      /* iin < PNG_MAX_ERROR_TEXT, so the following is safe: */\r
+      buffer[iout] = '\0';\r
+   }\r
+}\r
+#endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */\r
+\r
+#if defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED)\r
+PNG_FUNCTION(void,PNGAPI\r
+png_chunk_error,(png_const_structrp png_ptr, png_const_charp error_message),\r
+   PNG_NORETURN)\r
+{\r
+   char msg[18+PNG_MAX_ERROR_TEXT];\r
+   if (png_ptr == NULL)\r
+      png_error(png_ptr, error_message);\r
+\r
+   else\r
+   {\r
+      png_format_buffer(png_ptr, msg, error_message);\r
+      png_error(png_ptr, msg);\r
+   }\r
+}\r
+#endif /* PNG_READ_SUPPORTED && PNG_ERROR_TEXT_SUPPORTED */\r
+\r
+#ifdef PNG_WARNINGS_SUPPORTED\r
+void PNGAPI\r
+png_chunk_warning(png_const_structrp png_ptr, png_const_charp warning_message)\r
+{\r
+   char msg[18+PNG_MAX_ERROR_TEXT];\r
+   if (png_ptr == NULL)\r
+      png_warning(png_ptr, warning_message);\r
+\r
+   else\r
+   {\r
+      png_format_buffer(png_ptr, msg, warning_message);\r
+      png_warning(png_ptr, msg);\r
+   }\r
+}\r
+#endif /* PNG_WARNINGS_SUPPORTED */\r
+\r
+#ifdef PNG_READ_SUPPORTED\r
+#ifdef PNG_BENIGN_ERRORS_SUPPORTED\r
+void PNGAPI\r
+png_chunk_benign_error(png_const_structrp png_ptr, png_const_charp\r
+    error_message)\r
+{\r
+   if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)\r
+      png_chunk_warning(png_ptr, error_message);\r
+\r
+   else\r
+      png_chunk_error(png_ptr, error_message);\r
+}\r
+#endif\r
+#endif /* PNG_READ_SUPPORTED */\r
+\r
+void /* PRIVATE */\r
+png_chunk_report(png_const_structrp png_ptr, png_const_charp message, int error)\r
+{\r
+   /* This is always supported, but for just read or just write it\r
+    * unconditionally does the right thing.\r
+    */\r
+#  if defined(PNG_READ_SUPPORTED) && defined(PNG_WRITE_SUPPORTED)\r
+      if (png_ptr->mode & PNG_IS_READ_STRUCT)\r
+#  endif\r
+\r
+#  ifdef PNG_READ_SUPPORTED\r
+      {\r
+         if (error < PNG_CHUNK_ERROR)\r
+            png_chunk_warning(png_ptr, message);\r
+\r
+         else\r
+            png_chunk_benign_error(png_ptr, message);\r
+      }\r
+#  endif\r
+\r
+#  if defined(PNG_READ_SUPPORTED) && defined(PNG_WRITE_SUPPORTED)\r
+      else if (!(png_ptr->mode & PNG_IS_READ_STRUCT))\r
+#  endif\r
+\r
+#  ifdef PNG_WRITE_SUPPORTED\r
+      {\r
+         if (error < PNG_CHUNK_WRITE_ERROR)\r
+            png_app_warning(png_ptr, message);\r
+\r
+         else\r
+            png_app_error(png_ptr, message);\r
+      }\r
+#  endif\r
+}\r
+\r
+#ifdef PNG_ERROR_TEXT_SUPPORTED\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+PNG_FUNCTION(void,\r
+png_fixed_error,(png_const_structrp png_ptr, png_const_charp name),PNG_NORETURN)\r
+{\r
+#  define fixed_message "fixed point overflow in "\r
+#  define fixed_message_ln ((sizeof fixed_message)-1)\r
+   int  iin;\r
+   char msg[fixed_message_ln+PNG_MAX_ERROR_TEXT];\r
+   memcpy(msg, fixed_message, fixed_message_ln);\r
+   iin = 0;\r
+   if (name != NULL) while (iin < (PNG_MAX_ERROR_TEXT-1) && name[iin] != 0)\r
+   {\r
+      msg[fixed_message_ln + iin] = name[iin];\r
+      ++iin;\r
+   }\r
+   msg[fixed_message_ln + iin] = 0;\r
+   png_error(png_ptr, msg);\r
+}\r
+#endif\r
+#endif\r
+\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+/* This API only exists if ANSI-C style error handling is used,\r
+ * otherwise it is necessary for png_default_error to be overridden.\r
+ */\r
+jmp_buf* PNGAPI\r
+png_set_longjmp_fn(png_structrp png_ptr, png_longjmp_ptr longjmp_fn,\r
+    size_t jmp_buf_size)\r
+{\r
+   /* From libpng 1.6.0 the app gets one chance to set a 'jmpbuf_size' value\r
+    * and it must not change after that.  Libpng doesn't care how big the\r
+    * buffer is, just that it doesn't change.\r
+    *\r
+    * If the buffer size is no *larger* than the size of jmp_buf when libpng is\r
+    * compiled a built in jmp_buf is returned; this preserves the pre-1.6.0\r
+    * semantics that this call will not fail.  If the size is larger, however,\r
+    * the buffer is allocated and this may fail, causing the function to return\r
+    * NULL.\r
+    */\r
+   if (png_ptr == NULL)\r
+      return NULL;\r
+\r
+   if (png_ptr->jmp_buf_ptr == NULL)\r
+   {\r
+      png_ptr->jmp_buf_size = 0; /* not allocated */\r
+\r
+      if (jmp_buf_size <= (sizeof png_ptr->jmp_buf_local))\r
+         png_ptr->jmp_buf_ptr = &png_ptr->jmp_buf_local;\r
+\r
+      else\r
+      {\r
+         png_ptr->jmp_buf_ptr = png_voidcast(jmp_buf *,\r
+            png_malloc_warn(png_ptr, jmp_buf_size));\r
+\r
+         if (png_ptr->jmp_buf_ptr == NULL)\r
+            return NULL; /* new NULL return on OOM */\r
+\r
+         png_ptr->jmp_buf_size = jmp_buf_size;\r
+      }\r
+   }\r
+\r
+   else /* Already allocated: check the size */\r
+   {\r
+      size_t size = png_ptr->jmp_buf_size;\r
+\r
+      if (size == 0)\r
+      {\r
+         size = (sizeof png_ptr->jmp_buf_local);\r
+         if (png_ptr->jmp_buf_ptr != &png_ptr->jmp_buf_local)\r
+         {\r
+            /* This is an internal error in libpng: somehow we have been left\r
+             * with a stack allocated jmp_buf when the application regained\r
+             * control.  It's always possible to fix this up, but for the moment\r
+             * this is a png_error because that makes it easy to detect.\r
+             */\r
+            png_error(png_ptr, "Libpng jmp_buf still allocated");\r
+            /* png_ptr->jmp_buf_ptr = &png_ptr->jmp_buf_local; */\r
+         }\r
+      }\r
+\r
+      if (size != jmp_buf_size)\r
+      {\r
+         png_warning(png_ptr, "Application jmp_buf size changed");\r
+         return NULL; /* caller will probably crash: no choice here */\r
+      }\r
+   }\r
+\r
+   /* Finally fill in the function, now we have a satisfactory buffer. It is\r
+    * valid to change the function on every call.\r
+    */\r
+   png_ptr->longjmp_fn = longjmp_fn;\r
+   return png_ptr->jmp_buf_ptr;\r
+}\r
+\r
+void /* PRIVATE */\r
+png_free_jmpbuf(png_structrp png_ptr)\r
+{\r
+   if (png_ptr != NULL)\r
+   {\r
+      jmp_buf *jb = png_ptr->jmp_buf_ptr;\r
+\r
+      /* A size of 0 is used to indicate a local, stack, allocation of the\r
+       * pointer; used here and in png.c\r
+       */\r
+      if (jb != NULL && png_ptr->jmp_buf_size > 0)\r
+      {\r
+\r
+         /* This stuff is so that a failure to free the error control structure\r
+          * does not leave libpng in a state with no valid error handling: the\r
+          * free always succeeds, if there is an error it gets ignored.\r
+          */\r
+         if (jb != &png_ptr->jmp_buf_local)\r
+         {\r
+            /* Make an internal, libpng, jmp_buf to return here */\r
+            jmp_buf free_jmp_buf;\r
+\r
+            if (!setjmp(free_jmp_buf))\r
+            {\r
+               png_ptr->jmp_buf_ptr = &free_jmp_buf; /* come back here */\r
+               png_ptr->jmp_buf_size = 0; /* stack allocation */\r
+               png_ptr->longjmp_fn = longjmp;\r
+               png_free(png_ptr, jb); /* Return to setjmp on error */\r
+            }\r
+         }\r
+      }\r
+\r
+      /* *Always* cancel everything out: */\r
+      png_ptr->jmp_buf_size = 0;\r
+      png_ptr->jmp_buf_ptr = NULL;\r
+      png_ptr->longjmp_fn = 0;\r
+   }\r
+}\r
+#endif\r
+\r
+/* This is the default error handling function.  Note that replacements for\r
+ * this function MUST NOT RETURN, or the program will likely crash.  This\r
+ * function is used by default, or if the program supplies NULL for the\r
+ * error function pointer in png_set_error_fn().\r
+ */\r
+static PNG_FUNCTION(void /* PRIVATE */,\r
+png_default_error,(png_const_structrp png_ptr, png_const_charp error_message),\r
+   PNG_NORETURN)\r
+{\r
+#ifdef PNG_CONSOLE_IO_SUPPORTED\r
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
+   /* Check on NULL only added in 1.5.4 */\r
+   if (error_message != NULL && *error_message == PNG_LITERAL_SHARP)\r
+   {\r
+      /* Strip "#nnnn " from beginning of error message. */\r
+      int offset;\r
+      char error_number[16];\r
+      for (offset = 0; offset<15; offset++)\r
+      {\r
+         error_number[offset] = error_message[offset + 1];\r
+         if (error_message[offset] == ' ')\r
+            break;\r
+      }\r
+\r
+      if ((offset > 1) && (offset < 15))\r
+      {\r
+         error_number[offset - 1] = '\0';\r
+         fprintf(stderr, "libpng error no. %s: %s",\r
+             error_number, error_message + offset + 1);\r
+         fprintf(stderr, PNG_STRING_NEWLINE);\r
+      }\r
+\r
+      else\r
+      {\r
+         fprintf(stderr, "libpng error: %s, offset=%d",\r
+             error_message, offset);\r
+         fprintf(stderr, PNG_STRING_NEWLINE);\r
+      }\r
+   }\r
+   else\r
+#endif\r
+   {\r
+      fprintf(stderr, "libpng error: %s", error_message ? error_message :\r
+         "undefined");\r
+      fprintf(stderr, PNG_STRING_NEWLINE);\r
+   }\r
+#else\r
+   PNG_UNUSED(error_message) /* Make compiler happy */\r
+#endif\r
+   png_longjmp(png_ptr, 1);\r
+}\r
+\r
+PNG_FUNCTION(void,PNGAPI\r
+png_longjmp,(png_const_structrp png_ptr, int val),PNG_NORETURN)\r
+{\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+   if (png_ptr && png_ptr->longjmp_fn && png_ptr->jmp_buf_ptr)\r
+      png_ptr->longjmp_fn(*png_ptr->jmp_buf_ptr, val);\r
+#endif\r
+\r
+   /* Here if not setjmp support or if png_ptr is null. */\r
+   PNG_ABORT();\r
+}\r
+\r
+#ifdef PNG_WARNINGS_SUPPORTED\r
+/* This function is called when there is a warning, but the library thinks\r
+ * it can continue anyway.  Replacement functions don't have to do anything\r
+ * here if you don't want them to.  In the default configuration, png_ptr is\r
+ * not used, but it is passed in case it may be useful.\r
+ */\r
+static void /* PRIVATE */\r
+png_default_warning(png_const_structrp png_ptr, png_const_charp warning_message)\r
+{\r
+#ifdef PNG_CONSOLE_IO_SUPPORTED\r
+#  ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
+   if (*warning_message == PNG_LITERAL_SHARP)\r
+   {\r
+      int offset;\r
+      char warning_number[16];\r
+      for (offset = 0; offset < 15; offset++)\r
+      {\r
+         warning_number[offset] = warning_message[offset + 1];\r
+         if (warning_message[offset] == ' ')\r
+            break;\r
+      }\r
+\r
+      if ((offset > 1) && (offset < 15))\r
+      {\r
+         warning_number[offset + 1] = '\0';\r
+         fprintf(stderr, "libpng warning no. %s: %s",\r
+             warning_number, warning_message + offset);\r
+         fprintf(stderr, PNG_STRING_NEWLINE);\r
+      }\r
+\r
+      else\r
+      {\r
+         fprintf(stderr, "libpng warning: %s",\r
+             warning_message);\r
+         fprintf(stderr, PNG_STRING_NEWLINE);\r
+      }\r
+   }\r
+   else\r
+#  endif\r
+\r
+   {\r
+      fprintf(stderr, "libpng warning: %s", warning_message);\r
+      fprintf(stderr, PNG_STRING_NEWLINE);\r
+   }\r
+#else\r
+   PNG_UNUSED(warning_message) /* Make compiler happy */\r
+#endif\r
+   PNG_UNUSED(png_ptr) /* Make compiler happy */\r
+}\r
+#endif /* PNG_WARNINGS_SUPPORTED */\r
+\r
+/* This function is called when the application wants to use another method\r
+ * of handling errors and warnings.  Note that the error function MUST NOT\r
+ * return to the calling routine or serious problems will occur.  The return\r
+ * method used in the default routine calls longjmp(png_ptr->jmp_buf_ptr, 1)\r
+ */\r
+void PNGAPI\r
+png_set_error_fn(png_structrp png_ptr, png_voidp error_ptr,\r
+    png_error_ptr error_fn, png_error_ptr warning_fn)\r
+{\r
+   if (png_ptr == NULL)\r
+      return;\r
+\r
+   png_ptr->error_ptr = error_ptr;\r
+   png_ptr->error_fn = error_fn;\r
+#ifdef PNG_WARNINGS_SUPPORTED\r
+   png_ptr->warning_fn = warning_fn;\r
+#else\r
+   PNG_UNUSED(warning_fn)\r
+#endif\r
+}\r
+\r
+\r
+/* This function returns a pointer to the error_ptr associated with the user\r
+ * functions.  The application should free any memory associated with this\r
+ * pointer before png_write_destroy and png_read_destroy are called.\r
+ */\r
+png_voidp PNGAPI\r
+png_get_error_ptr(png_const_structrp png_ptr)\r
+{\r
+   if (png_ptr == NULL)\r
+      return NULL;\r
+\r
+   return ((png_voidp)png_ptr->error_ptr);\r
+}\r
+\r
+\r
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
+void PNGAPI\r
+png_set_strip_error_numbers(png_structrp png_ptr, png_uint_32 strip_mode)\r
+{\r
+   if (png_ptr != NULL)\r
+   {\r
+      png_ptr->flags &=\r
+         ((~(PNG_FLAG_STRIP_ERROR_NUMBERS |\r
+         PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);\r
+   }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\\r
+   defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)\r
+   /* Currently the above both depend on SETJMP_SUPPORTED, however it would be\r
+    * possible to implement without setjmp support just so long as there is some\r
+    * way to handle the error return here:\r
+    */\r
+PNG_FUNCTION(void /* PRIVATE */,\r
+png_safe_error,(png_structp png_nonconst_ptr, png_const_charp error_message),\r
+   PNG_NORETURN)\r
+{\r
+   const png_const_structrp png_ptr = png_nonconst_ptr;\r
+   png_imagep image = png_voidcast(png_imagep, png_ptr->error_ptr);\r
+\r
+   /* An error is always logged here, overwriting anything (typically a warning)\r
+    * that is already there:\r
+    */\r
+   if (image != NULL)\r
+   {\r
+      png_safecat(image->message, (sizeof image->message), 0, error_message);\r
+      image->warning_or_error |= PNG_IMAGE_ERROR;\r
+\r
+      /* Retrieve the jmp_buf from within the png_control, making this work for\r
+       * C++ compilation too is pretty tricky: C++ wants a pointer to the first\r
+       * element of a jmp_buf, but C doesn't tell us the type of that.\r
+       */\r
+      if (image->opaque != NULL && image->opaque->error_buf != NULL)\r
+         longjmp(png_control_jmp_buf(image->opaque), 1);\r
+\r
+      /* Missing longjmp buffer, the following is to help debugging: */\r
+      {\r
+         size_t pos = png_safecat(image->message, (sizeof image->message), 0,\r
+            "bad longjmp: ");\r
+         png_safecat(image->message, (sizeof image->message), pos,\r
+             error_message);\r
+      }\r
+   }\r
+\r
+   /* Here on an internal programming error. */\r
+   abort();\r
+}\r
+\r
+#ifdef PNG_WARNINGS_SUPPORTED\r
+void /* PRIVATE */\r
+png_safe_warning(png_structp png_nonconst_ptr, png_const_charp warning_message)\r
+{\r
+   const png_const_structrp png_ptr = png_nonconst_ptr;\r
+   png_imagep image = png_voidcast(png_imagep, png_ptr->error_ptr);\r
+\r
+   /* A warning is only logged if there is no prior warning or error. */\r
+   if (image->warning_or_error == 0)\r
+   {\r
+      png_safecat(image->message, (sizeof image->message), 0, warning_message);\r
+      image->warning_or_error |= PNG_IMAGE_WARNING;\r
+   }\r
+}\r
+#endif\r
+\r
+int /* PRIVATE */\r
+png_safe_execute(png_imagep image_in, int (*function)(png_voidp), png_voidp arg)\r
+{\r
+   volatile png_imagep image = image_in;\r
+   volatile int result;\r
+   volatile png_voidp saved_error_buf;\r
+   jmp_buf safe_jmpbuf;\r
+\r
+   /* Safely execute function(arg) with png_error returning to this function. */\r
+   saved_error_buf = image->opaque->error_buf;\r
+   result = setjmp(safe_jmpbuf) == 0;\r
+\r
+   if (result)\r
+   {\r
+\r
+      image->opaque->error_buf = safe_jmpbuf;\r
+      result = function(arg);\r
+   }\r
+\r
+   image->opaque->error_buf = saved_error_buf;\r
+\r
+   /* And do the cleanup prior to any failure return. */\r
+   if (!result)\r
+      png_image_free(image);\r
+\r
+   return result;\r
+}\r
+#endif /* SIMPLIFIED READ/WRITE */\r
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */\r
diff --git a/samples/fx_lpng/lpng_v163/fx_pngget.c b/samples/fx_lpng/lpng_v163/fx_pngget.c
new file mode 100644 (file)
index 0000000..6839f6b
--- /dev/null
@@ -0,0 +1,1176 @@
+/* pngget.c - retrieval of values from info struct\r
+ *\r
+ * Last changed in libpng 1.6.1 [March 28, 2013]\r
+ * Copyright (c) 1998-2013 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ *\r
+ * This code is released under the libpng license.\r
+ * For conditions of distribution and use, see the disclaimer\r
+ * and license in png.h\r
+ *\r
+ */\r
+\r
+#include "pngpriv.h"\r
+\r
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)\r
+\r
+png_uint_32 PNGAPI\r
+png_get_valid(png_const_structrp png_ptr, png_const_inforp info_ptr,\r
+    png_uint_32 flag)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL)\r
+      return(info_ptr->valid & flag);\r
+\r
+   return(0);\r
+}\r
+\r
+png_size_t PNGAPI\r
+png_get_rowbytes(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL)\r
+      return(info_ptr->rowbytes);\r
+\r
+   return(0);\r
+}\r
+\r
+#ifdef PNG_INFO_IMAGE_SUPPORTED\r
+png_bytepp PNGAPI\r
+png_get_rows(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL)\r
+      return(info_ptr->row_pointers);\r
+\r
+   return(0);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_EASY_ACCESS_SUPPORTED\r
+/* Easy access to info, added in libpng-0.99 */\r
+png_uint_32 PNGAPI\r
+png_get_image_width(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL)\r
+      return info_ptr->width;\r
+\r
+   return (0);\r
+}\r
+\r
+png_uint_32 PNGAPI\r
+png_get_image_height(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL)\r
+      return info_ptr->height;\r
+\r
+   return (0);\r
+}\r
+\r
+png_byte PNGAPI\r
+png_get_bit_depth(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL)\r
+      return info_ptr->bit_depth;\r
+\r
+   return (0);\r
+}\r
+\r
+png_byte PNGAPI\r
+png_get_color_type(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL)\r
+      return info_ptr->color_type;\r
+\r
+   return (0);\r
+}\r
+\r
+png_byte PNGAPI\r
+png_get_filter_type(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL)\r
+      return info_ptr->filter_type;\r
+\r
+   return (0);\r
+}\r
+\r
+png_byte PNGAPI\r
+png_get_interlace_type(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL)\r
+      return info_ptr->interlace_type;\r
+\r
+   return (0);\r
+}\r
+\r
+png_byte PNGAPI\r
+png_get_compression_type(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL)\r
+      return info_ptr->compression_type;\r
+\r
+   return (0);\r
+}\r
+\r
+png_uint_32 PNGAPI\r
+png_get_x_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp\r
+   info_ptr)\r
+{\r
+#ifdef PNG_pHYs_SUPPORTED\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))\r
+      {\r
+         png_debug1(1, "in %s retrieval function",\r
+             "png_get_x_pixels_per_meter");\r
+\r
+         if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)\r
+            return (info_ptr->x_pixels_per_unit);\r
+      }\r
+#endif\r
+\r
+   return (0);\r
+}\r
+\r
+png_uint_32 PNGAPI\r
+png_get_y_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp\r
+    info_ptr)\r
+{\r
+#ifdef PNG_pHYs_SUPPORTED\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))\r
+   {\r
+      png_debug1(1, "in %s retrieval function",\r
+          "png_get_y_pixels_per_meter");\r
+\r
+      if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)\r
+         return (info_ptr->y_pixels_per_unit);\r
+   }\r
+#endif\r
+\r
+   return (0);\r
+}\r
+\r
+png_uint_32 PNGAPI\r
+png_get_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+#ifdef PNG_pHYs_SUPPORTED\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))\r
+   {\r
+      png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");\r
+\r
+      if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER &&\r
+          info_ptr->x_pixels_per_unit == info_ptr->y_pixels_per_unit)\r
+         return (info_ptr->x_pixels_per_unit);\r
+   }\r
+#endif\r
+\r
+   return (0);\r
+}\r
+\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+float PNGAPI\r
+png_get_pixel_aspect_ratio(png_const_structrp png_ptr, png_const_inforp\r
+   info_ptr)\r
+{\r
+#ifdef PNG_READ_pHYs_SUPPORTED\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))\r
+   {\r
+      png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");\r
+\r
+      if (info_ptr->x_pixels_per_unit != 0)\r
+         return ((float)((float)info_ptr->y_pixels_per_unit\r
+             /(float)info_ptr->x_pixels_per_unit));\r
+   }\r
+#else\r
+   PNG_UNUSED(png_ptr)\r
+   PNG_UNUSED(info_ptr)\r
+#endif\r
+\r
+   return ((float)0.0);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+png_fixed_point PNGAPI\r
+png_get_pixel_aspect_ratio_fixed(png_const_structrp png_ptr,\r
+    png_const_inforp info_ptr)\r
+{\r
+#ifdef PNG_READ_pHYs_SUPPORTED\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)\r
+       && info_ptr->x_pixels_per_unit > 0 && info_ptr->y_pixels_per_unit > 0\r
+       && info_ptr->x_pixels_per_unit <= PNG_UINT_31_MAX\r
+       && info_ptr->y_pixels_per_unit <= PNG_UINT_31_MAX)\r
+   {\r
+      png_fixed_point res;\r
+\r
+      png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio_fixed");\r
+\r
+      /* The following casts work because a PNG 4 byte integer only has a valid\r
+       * range of 0..2^31-1; otherwise the cast might overflow.\r
+       */\r
+      if (png_muldiv(&res, (png_int_32)info_ptr->y_pixels_per_unit, PNG_FP_1,\r
+          (png_int_32)info_ptr->x_pixels_per_unit))\r
+         return res;\r
+   }\r
+#else\r
+   PNG_UNUSED(png_ptr)\r
+   PNG_UNUSED(info_ptr)\r
+#endif\r
+\r
+   return 0;\r
+}\r
+#endif\r
+\r
+png_int_32 PNGAPI\r
+png_get_x_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+#ifdef PNG_oFFs_SUPPORTED\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))\r
+   {\r
+      png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");\r
+\r
+      if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)\r
+         return (info_ptr->x_offset);\r
+   }\r
+#endif\r
+\r
+   return (0);\r
+}\r
+\r
+png_int_32 PNGAPI\r
+png_get_y_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+#ifdef PNG_oFFs_SUPPORTED\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))\r
+   {\r
+      png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");\r
+\r
+      if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)\r
+         return (info_ptr->y_offset);\r
+   }\r
+#endif\r
+\r
+   return (0);\r
+}\r
+\r
+png_int_32 PNGAPI\r
+png_get_x_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+#ifdef PNG_oFFs_SUPPORTED\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))\r
+   {\r
+      png_debug1(1, "in %s retrieval function", "png_get_x_offset_pixels");\r
+\r
+      if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)\r
+         return (info_ptr->x_offset);\r
+   }\r
+#endif\r
+\r
+   return (0);\r
+}\r
+\r
+png_int_32 PNGAPI\r
+png_get_y_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+#ifdef PNG_oFFs_SUPPORTED\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))\r
+   {\r
+      png_debug1(1, "in %s retrieval function", "png_get_y_offset_pixels");\r
+\r
+      if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)\r
+         return (info_ptr->y_offset);\r
+   }\r
+#endif\r
+\r
+   return (0);\r
+}\r
+\r
+#ifdef PNG_INCH_CONVERSIONS_SUPPORTED\r
+static png_uint_32\r
+ppi_from_ppm(png_uint_32 ppm)\r
+{\r
+#if 0\r
+   /* The conversion is *(2.54/100), in binary (32 digits):\r
+    * .00000110100000001001110101001001\r
+    */\r
+   png_uint_32 t1001, t1101;\r
+   ppm >>= 1;                  /* .1 */\r
+   t1001 = ppm + (ppm >> 3);   /* .1001 */\r
+   t1101 = t1001 + (ppm >> 1); /* .1101 */\r
+   ppm >>= 20;                 /* .000000000000000000001 */\r
+   t1101 += t1101 >> 15;       /* .1101000000000001101 */\r
+   t1001 >>= 11;               /* .000000000001001 */\r
+   t1001 += t1001 >> 12;       /* .000000000001001000000001001 */\r
+   ppm += t1001;               /* .000000000001001000001001001 */\r
+   ppm += t1101;               /* .110100000001001110101001001 */\r
+   return (ppm + 16) >> 5;/* .00000110100000001001110101001001 */\r
+#else\r
+   /* The argument is a PNG unsigned integer, so it is not permitted\r
+    * to be bigger than 2^31.\r
+    */\r
+   png_fixed_point result;\r
+   if (ppm <= PNG_UINT_31_MAX && png_muldiv(&result, (png_int_32)ppm, 127,\r
+       5000))\r
+      return result;\r
+\r
+   /* Overflow. */\r
+   return 0;\r
+#endif\r
+}\r
+\r
+png_uint_32 PNGAPI\r
+png_get_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+   return ppi_from_ppm(png_get_pixels_per_meter(png_ptr, info_ptr));\r
+}\r
+\r
+png_uint_32 PNGAPI\r
+png_get_x_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+   return ppi_from_ppm(png_get_x_pixels_per_meter(png_ptr, info_ptr));\r
+}\r
+\r
+png_uint_32 PNGAPI\r
+png_get_y_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+   return ppi_from_ppm(png_get_y_pixels_per_meter(png_ptr, info_ptr));\r
+}\r
+\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+static png_fixed_point\r
+png_fixed_inches_from_microns(png_const_structrp png_ptr, png_int_32 microns)\r
+{\r
+   /* Convert from metres * 1,000,000 to inches * 100,000, meters to\r
+    * inches is simply *(100/2.54), so we want *(10/2.54) == 500/127.\r
+    * Notice that this can overflow - a warning is output and 0 is\r
+    * returned.\r
+    */\r
+   return png_muldiv_warn(png_ptr, microns, 500, 127);\r
+}\r
+\r
+png_fixed_point PNGAPI\r
+png_get_x_offset_inches_fixed(png_const_structrp png_ptr,\r
+    png_const_inforp info_ptr)\r
+{\r
+   return png_fixed_inches_from_microns(png_ptr,\r
+       png_get_x_offset_microns(png_ptr, info_ptr));\r
+}\r
+#endif\r
+\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+png_fixed_point PNGAPI\r
+png_get_y_offset_inches_fixed(png_const_structrp png_ptr,\r
+    png_const_inforp info_ptr)\r
+{\r
+   return png_fixed_inches_from_microns(png_ptr,\r
+       png_get_y_offset_microns(png_ptr, info_ptr));\r
+}\r
+#endif\r
+\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+float PNGAPI\r
+png_get_x_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+   /* To avoid the overflow do the conversion directly in floating\r
+    * point.\r
+    */\r
+   return (float)(png_get_x_offset_microns(png_ptr, info_ptr) * .00003937);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+float PNGAPI\r
+png_get_y_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+   /* To avoid the overflow do the conversion directly in floating\r
+    * point.\r
+    */\r
+   return (float)(png_get_y_offset_microns(png_ptr, info_ptr) * .00003937);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_pHYs_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_pHYs_dpi(png_const_structrp png_ptr, png_const_inforp info_ptr,\r
+    png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)\r
+{\r
+   png_uint_32 retval = 0;\r
+\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))\r
+   {\r
+      png_debug1(1, "in %s retrieval function", "pHYs");\r
+\r
+      if (res_x != NULL)\r
+      {\r
+         *res_x = info_ptr->x_pixels_per_unit;\r
+         retval |= PNG_INFO_pHYs;\r
+      }\r
+\r
+      if (res_y != NULL)\r
+      {\r
+         *res_y = info_ptr->y_pixels_per_unit;\r
+         retval |= PNG_INFO_pHYs;\r
+      }\r
+\r
+      if (unit_type != NULL)\r
+      {\r
+         *unit_type = (int)info_ptr->phys_unit_type;\r
+         retval |= PNG_INFO_pHYs;\r
+\r
+         if (*unit_type == 1)\r
+         {\r
+            if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);\r
+            if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);\r
+         }\r
+      }\r
+   }\r
+\r
+   return (retval);\r
+}\r
+#endif /* PNG_pHYs_SUPPORTED */\r
+#endif  /* PNG_INCH_CONVERSIONS_SUPPORTED */\r
+\r
+/* png_get_channels really belongs in here, too, but it's been around longer */\r
+\r
+#endif  /* PNG_EASY_ACCESS_SUPPORTED */\r
+\r
+\r
+png_byte PNGAPI\r
+png_get_channels(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL)\r
+      return(info_ptr->channels);\r
+\r
+   return (0);\r
+}\r
+\r
+#ifdef PNG_READ_SUPPORTED\r
+png_const_bytep PNGAPI\r
+png_get_signature(png_const_structrp png_ptr, png_const_inforp info_ptr)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL)\r
+      return(info_ptr->signature);\r
+\r
+   return (NULL);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_bKGD_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_bKGD(png_const_structrp png_ptr, png_inforp info_ptr,\r
+   png_color_16p *background)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)\r
+       && background != NULL)\r
+   {\r
+      png_debug1(1, "in %s retrieval function", "bKGD");\r
+\r
+      *background = &(info_ptr->background);\r
+      return (PNG_INFO_bKGD);\r
+   }\r
+\r
+   return (0);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_cHRM_SUPPORTED\r
+/* The XYZ APIs were added in 1.5.5 to take advantage of the code added at the\r
+ * same time to correct the rgb grayscale coefficient defaults obtained from the\r
+ * cHRM chunk in 1.5.4\r
+ */\r
+#  ifdef PNG_FLOATING_POINT_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_cHRM(png_const_structrp png_ptr, png_const_inforp info_ptr,\r
+    double *white_x, double *white_y, double *red_x, double *red_y,\r
+    double *green_x, double *green_y, double *blue_x, double *blue_y)\r
+{\r
+   /* Quiet API change: this code used to only return the end points if a cHRM\r
+    * chunk was present, but the end points can also come from iCCP or sRGB\r
+    * chunks, so in 1.6.0 the png_get_ APIs return the end points regardless and\r
+    * the png_set_ APIs merely check that set end points are mutually\r
+    * consistent.\r
+    */\r
+   if (png_ptr != NULL && info_ptr != NULL &&\r
+      (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS))\r
+   {\r
+      png_debug1(1, "in %s retrieval function", "cHRM");\r
+\r
+      if (white_x != NULL)\r
+         *white_x = png_float(png_ptr,\r
+            info_ptr->colorspace.end_points_xy.whitex, "cHRM white X");\r
+      if (white_y != NULL)\r
+         *white_y = png_float(png_ptr,\r
+            info_ptr->colorspace.end_points_xy.whitey, "cHRM white Y");\r
+      if (red_x != NULL)\r
+         *red_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redx,\r
+            "cHRM red X");\r
+      if (red_y != NULL)\r
+         *red_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redy,\r
+            "cHRM red Y");\r
+      if (green_x != NULL)\r
+         *green_x = png_float(png_ptr,\r
+            info_ptr->colorspace.end_points_xy.greenx, "cHRM green X");\r
+      if (green_y != NULL)\r
+         *green_y = png_float(png_ptr,\r
+            info_ptr->colorspace.end_points_xy.greeny, "cHRM green Y");\r
+      if (blue_x != NULL)\r
+         *blue_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluex,\r
+            "cHRM blue X");\r
+      if (blue_y != NULL)\r
+         *blue_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluey,\r
+            "cHRM blue Y");\r
+      return (PNG_INFO_cHRM);\r
+   }\r
+\r
+   return (0);\r
+}\r
+\r
+png_uint_32 PNGAPI\r
+png_get_cHRM_XYZ(png_const_structrp png_ptr, png_const_inforp info_ptr,\r
+   double *red_X, double *red_Y, double *red_Z, double *green_X,\r
+   double *green_Y, double *green_Z, double *blue_X, double *blue_Y,\r
+   double *blue_Z)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL &&\r
+      (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS))\r
+   {\r
+      png_debug1(1, "in %s retrieval function", "cHRM_XYZ(float)");\r
+\r
+      if (red_X != NULL)\r
+         *red_X = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_X,\r
+            "cHRM red X");\r
+      if (red_Y != NULL)\r
+         *red_Y = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Y,\r
+            "cHRM red Y");\r
+      if (red_Z != NULL)\r
+         *red_Z = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Z,\r
+            "cHRM red Z");\r
+      if (green_X != NULL)\r
+         *green_X = png_float(png_ptr,\r
+            info_ptr->colorspace.end_points_XYZ.green_X, "cHRM green X");\r
+      if (green_Y != NULL)\r
+         *green_Y = png_float(png_ptr,\r
+            info_ptr->colorspace.end_points_XYZ.green_Y, "cHRM green Y");\r
+      if (green_Z != NULL)\r
+         *green_Z = png_float(png_ptr,\r
+            info_ptr->colorspace.end_points_XYZ.green_Z, "cHRM green Z");\r
+      if (blue_X != NULL)\r
+         *blue_X = png_float(png_ptr,\r
+            info_ptr->colorspace.end_points_XYZ.blue_X, "cHRM blue X");\r
+      if (blue_Y != NULL)\r
+         *blue_Y = png_float(png_ptr,\r
+            info_ptr->colorspace.end_points_XYZ.blue_Y, "cHRM blue Y");\r
+      if (blue_Z != NULL)\r
+         *blue_Z = png_float(png_ptr,\r
+            info_ptr->colorspace.end_points_XYZ.blue_Z, "cHRM blue Z");\r
+      return (PNG_INFO_cHRM);\r
+   }\r
+\r
+   return (0);\r
+}\r
+#  endif\r
+\r
+#  ifdef PNG_FIXED_POINT_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_cHRM_XYZ_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,\r
+    png_fixed_point *int_red_X, png_fixed_point *int_red_Y,\r
+    png_fixed_point *int_red_Z, png_fixed_point *int_green_X,\r
+    png_fixed_point *int_green_Y, png_fixed_point *int_green_Z,\r
+    png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y,\r
+    png_fixed_point *int_blue_Z)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL &&\r
+      (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS))\r
+   {\r
+      png_debug1(1, "in %s retrieval function", "cHRM_XYZ");\r
+\r
+      if (int_red_X != NULL)\r
+         *int_red_X = info_ptr->colorspace.end_points_XYZ.red_X;\r
+      if (int_red_Y != NULL)\r
+         *int_red_Y = info_ptr->colorspace.end_points_XYZ.red_Y;\r
+      if (int_red_Z != NULL)\r
+         *int_red_Z = info_ptr->colorspace.end_points_XYZ.red_Z;\r
+      if (int_green_X != NULL)\r
+         *int_green_X = info_ptr->colorspace.end_points_XYZ.green_X;\r
+      if (int_green_Y != NULL)\r
+         *int_green_Y = info_ptr->colorspace.end_points_XYZ.green_Y;\r
+      if (int_green_Z != NULL)\r
+         *int_green_Z = info_ptr->colorspace.end_points_XYZ.green_Z;\r
+      if (int_blue_X != NULL)\r
+         *int_blue_X = info_ptr->colorspace.end_points_XYZ.blue_X;\r
+      if (int_blue_Y != NULL)\r
+         *int_blue_Y = info_ptr->colorspace.end_points_XYZ.blue_Y;\r
+      if (int_blue_Z != NULL)\r
+         *int_blue_Z = info_ptr->colorspace.end_points_XYZ.blue_Z;\r
+      return (PNG_INFO_cHRM);\r
+   }\r
+\r
+   return (0);\r
+}\r
+\r
+png_uint_32 PNGAPI\r
+png_get_cHRM_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,\r
+    png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x,\r
+    png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y,\r
+    png_fixed_point *blue_x, png_fixed_point *blue_y)\r
+{\r
+   png_debug1(1, "in %s retrieval function", "cHRM");\r
+\r
+   if (png_ptr != NULL && info_ptr != NULL &&\r
+      (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS))\r
+   {\r
+      if (white_x != NULL)\r
+         *white_x = info_ptr->colorspace.end_points_xy.whitex;\r
+      if (white_y != NULL)\r
+         *white_y = info_ptr->colorspace.end_points_xy.whitey;\r
+      if (red_x != NULL)\r
+         *red_x = info_ptr->colorspace.end_points_xy.redx;\r
+      if (red_y != NULL)\r
+         *red_y = info_ptr->colorspace.end_points_xy.redy;\r
+      if (green_x != NULL)\r
+         *green_x = info_ptr->colorspace.end_points_xy.greenx;\r
+      if (green_y != NULL)\r
+         *green_y = info_ptr->colorspace.end_points_xy.greeny;\r
+      if (blue_x != NULL)\r
+         *blue_x = info_ptr->colorspace.end_points_xy.bluex;\r
+      if (blue_y != NULL)\r
+         *blue_y = info_ptr->colorspace.end_points_xy.bluey;\r
+      return (PNG_INFO_cHRM);\r
+   }\r
+\r
+   return (0);\r
+}\r
+#  endif\r
+#endif\r
+\r
+#ifdef PNG_gAMA_SUPPORTED\r
+#  ifdef PNG_FIXED_POINT_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_gAMA_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,\r
+    png_fixed_point *file_gamma)\r
+{\r
+   png_debug1(1, "in %s retrieval function", "gAMA");\r
+\r
+   if (png_ptr != NULL && info_ptr != NULL &&\r
+      (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) &&\r
+      file_gamma != NULL)\r
+   {\r
+      *file_gamma = info_ptr->colorspace.gamma;\r
+      return (PNG_INFO_gAMA);\r
+   }\r
+\r
+   return (0);\r
+}\r
+#  endif\r
+\r
+#  ifdef PNG_FLOATING_POINT_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_gAMA(png_const_structrp png_ptr, png_const_inforp info_ptr,\r
+    double *file_gamma)\r
+{\r
+   png_debug1(1, "in %s retrieval function", "gAMA(float)");\r
+\r
+   if (png_ptr != NULL && info_ptr != NULL &&\r
+      (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) &&\r
+      file_gamma != NULL)\r
+   {\r
+      *file_gamma = png_float(png_ptr, info_ptr->colorspace.gamma,\r
+         "png_get_gAMA");\r
+      return (PNG_INFO_gAMA);\r
+   }\r
+\r
+   return (0);\r
+}\r
+#  endif\r
+#endif\r
+\r
+#ifdef PNG_sRGB_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_sRGB(png_const_structrp png_ptr, png_const_inforp info_ptr,\r
+    int *file_srgb_intent)\r
+{\r
+   png_debug1(1, "in %s retrieval function", "sRGB");\r
+\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)\r
+       && file_srgb_intent != NULL)\r
+   {\r
+      *file_srgb_intent = info_ptr->colorspace.rendering_intent;\r
+      return (PNG_INFO_sRGB);\r
+   }\r
+\r
+   return (0);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_iCCP_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_iCCP(png_const_structrp png_ptr, png_inforp info_ptr,\r
+    png_charpp name, int *compression_type,\r
+    png_bytepp profile, png_uint_32 *proflen)\r
+{\r
+   png_debug1(1, "in %s retrieval function", "iCCP");\r
+\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)\r
+       && name != NULL && compression_type != NULL && profile != NULL &&\r
+                proflen != NULL)\r
+   {\r
+      *name = info_ptr->iccp_name;\r
+      *profile = info_ptr->iccp_profile;\r
+      *proflen = png_get_uint_32(info_ptr->iccp_profile);\r
+      /* This is somewhat irrelevant since the profile data returned has\r
+       * actually been uncompressed.\r
+       */\r
+      *compression_type = PNG_COMPRESSION_TYPE_BASE;\r
+      return (PNG_INFO_iCCP);\r
+   }\r
+\r
+   return (0);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_sPLT_SUPPORTED\r
+int PNGAPI\r
+png_get_sPLT(png_const_structrp png_ptr, png_inforp info_ptr,\r
+    png_sPLT_tpp spalettes)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)\r
+   {\r
+      *spalettes = info_ptr->splt_palettes;\r
+      return info_ptr->splt_palettes_num;\r
+   }\r
+\r
+   return (0);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_hIST_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_hIST(png_const_structrp png_ptr, png_inforp info_ptr,\r
+    png_uint_16p *hist)\r
+{\r
+   png_debug1(1, "in %s retrieval function", "hIST");\r
+\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)\r
+       && hist != NULL)\r
+   {\r
+      *hist = info_ptr->hist;\r
+      return (PNG_INFO_hIST);\r
+   }\r
+\r
+   return (0);\r
+}\r
+#endif\r
+\r
+png_uint_32 PNGAPI\r
+png_get_IHDR(png_const_structrp png_ptr, png_const_inforp info_ptr,\r
+    png_uint_32 *width, png_uint_32 *height, int *bit_depth,\r
+    int *color_type, int *interlace_type, int *compression_type,\r
+    int *filter_type)\r
+{\r
+   png_debug1(1, "in %s retrieval function", "IHDR");\r
+\r
+   if (png_ptr == NULL || info_ptr == NULL || width == NULL ||\r
+       height == NULL || bit_depth == NULL || color_type == NULL)\r
+      return (0);\r
+\r
+   *width = info_ptr->width;\r
+   *height = info_ptr->height;\r
+   *bit_depth = info_ptr->bit_depth;\r
+   *color_type = info_ptr->color_type;\r
+\r
+   if (compression_type != NULL)\r
+      *compression_type = info_ptr->compression_type;\r
+\r
+   if (filter_type != NULL)\r
+      *filter_type = info_ptr->filter_type;\r
+\r
+   if (interlace_type != NULL)\r
+      *interlace_type = info_ptr->interlace_type;\r
+\r
+   /* This is redundant if we can be sure that the info_ptr values were all\r
+    * assigned in png_set_IHDR().  We do the check anyhow in case an\r
+    * application has ignored our advice not to mess with the members\r
+    * of info_ptr directly.\r
+    */\r
+   png_check_IHDR(png_ptr, info_ptr->width, info_ptr->height,\r
+       info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,\r
+       info_ptr->compression_type, info_ptr->filter_type);\r
+\r
+   return (1);\r
+}\r
+\r
+#ifdef PNG_oFFs_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_oFFs(png_const_structrp png_ptr, png_const_inforp info_ptr,\r
+    png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)\r
+{\r
+   png_debug1(1, "in %s retrieval function", "oFFs");\r
+\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)\r
+       && offset_x != NULL && offset_y != NULL && unit_type != NULL)\r
+   {\r
+      *offset_x = info_ptr->x_offset;\r
+      *offset_y = info_ptr->y_offset;\r
+      *unit_type = (int)info_ptr->offset_unit_type;\r
+      return (PNG_INFO_oFFs);\r
+   }\r
+\r
+   return (0);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_pCAL_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_pCAL(png_const_structrp png_ptr, png_inforp info_ptr,\r
+    png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,\r
+    png_charp *units, png_charpp *params)\r
+{\r
+   png_debug1(1, "in %s retrieval function", "pCAL");\r
+\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)\r
+       && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&\r
+       nparams != NULL && units != NULL && params != NULL)\r
+   {\r
+      *purpose = info_ptr->pcal_purpose;\r
+      *X0 = info_ptr->pcal_X0;\r
+      *X1 = info_ptr->pcal_X1;\r
+      *type = (int)info_ptr->pcal_type;\r
+      *nparams = (int)info_ptr->pcal_nparams;\r
+      *units = info_ptr->pcal_units;\r
+      *params = info_ptr->pcal_params;\r
+      return (PNG_INFO_pCAL);\r
+   }\r
+\r
+   return (0);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_sCAL_SUPPORTED\r
+#  ifdef PNG_FIXED_POINT_SUPPORTED\r
+#    if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \\r
+         defined(PNG_FLOATING_POINT_SUPPORTED)\r
+png_uint_32 PNGAPI\r
+png_get_sCAL_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,\r
+    int *unit, png_fixed_point *width, png_fixed_point *height)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL &&\r
+       (info_ptr->valid & PNG_INFO_sCAL))\r
+   {\r
+      *unit = info_ptr->scal_unit;\r
+      /*TODO: make this work without FP support; the API is currently eliminated\r
+       * if neither floating point APIs nor internal floating point arithmetic\r
+       * are enabled.\r
+       */\r
+      *width = png_fixed(png_ptr, atof(info_ptr->scal_s_width), "sCAL width");\r
+      *height = png_fixed(png_ptr, atof(info_ptr->scal_s_height),\r
+         "sCAL height");\r
+      return (PNG_INFO_sCAL);\r
+   }\r
+\r
+   return(0);\r
+}\r
+#    endif /* FLOATING_ARITHMETIC */\r
+#  endif /* FIXED_POINT */\r
+#  ifdef PNG_FLOATING_POINT_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_sCAL(png_const_structrp png_ptr, png_const_inforp info_ptr,\r
+    int *unit, double *width, double *height)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL &&\r
+       (info_ptr->valid & PNG_INFO_sCAL))\r
+   {\r
+      *unit = info_ptr->scal_unit;\r
+      *width = atof(info_ptr->scal_s_width);\r
+      *height = atof(info_ptr->scal_s_height);\r
+      return (PNG_INFO_sCAL);\r
+   }\r
+\r
+   return(0);\r
+}\r
+#  endif /* FLOATING POINT */\r
+png_uint_32 PNGAPI\r
+png_get_sCAL_s(png_const_structrp png_ptr, png_const_inforp info_ptr,\r
+    int *unit, png_charpp width, png_charpp height)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL &&\r
+       (info_ptr->valid & PNG_INFO_sCAL))\r
+   {\r
+      *unit = info_ptr->scal_unit;\r
+      *width = info_ptr->scal_s_width;\r
+      *height = info_ptr->scal_s_height;\r
+      return (PNG_INFO_sCAL);\r
+   }\r
+\r
+   return(0);\r
+}\r
+#endif /* sCAL */\r
+\r
+#ifdef PNG_pHYs_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_pHYs(png_const_structrp png_ptr, png_const_inforp info_ptr,\r
+    png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)\r
+{\r
+   png_uint_32 retval = 0;\r
+\r
+   png_debug1(1, "in %s retrieval function", "pHYs");\r
+\r
+   if (png_ptr != NULL && info_ptr != NULL &&\r
+       (info_ptr->valid & PNG_INFO_pHYs))\r
+   {\r
+      if (res_x != NULL)\r
+      {\r
+         *res_x = info_ptr->x_pixels_per_unit;\r
+         retval |= PNG_INFO_pHYs;\r
+      }\r
+\r
+      if (res_y != NULL)\r
+      {\r
+         *res_y = info_ptr->y_pixels_per_unit;\r
+         retval |= PNG_INFO_pHYs;\r
+      }\r
+\r
+      if (unit_type != NULL)\r
+      {\r
+         *unit_type = (int)info_ptr->phys_unit_type;\r
+         retval |= PNG_INFO_pHYs;\r
+      }\r
+   }\r
+\r
+   return (retval);\r
+}\r
+#endif /* pHYs */\r
+\r
+png_uint_32 PNGAPI\r
+png_get_PLTE(png_const_structrp png_ptr, png_inforp info_ptr,\r
+    png_colorp *palette, int *num_palette)\r
+{\r
+   png_debug1(1, "in %s retrieval function", "PLTE");\r
+\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)\r
+       && palette != NULL)\r
+   {\r
+      *palette = info_ptr->palette;\r
+      *num_palette = info_ptr->num_palette;\r
+      png_debug1(3, "num_palette = %d", *num_palette);\r
+      return (PNG_INFO_PLTE);\r
+   }\r
+\r
+   return (0);\r
+}\r
+\r
+#ifdef PNG_sBIT_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_sBIT(png_const_structrp png_ptr, png_inforp info_ptr,\r
+    png_color_8p *sig_bit)\r
+{\r
+   png_debug1(1, "in %s retrieval function", "sBIT");\r
+\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)\r
+       && sig_bit != NULL)\r
+   {\r
+      *sig_bit = &(info_ptr->sig_bit);\r
+      return (PNG_INFO_sBIT);\r
+   }\r
+\r
+   return (0);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_TEXT_SUPPORTED\r
+int PNGAPI\r
+png_get_text(png_const_structrp png_ptr, png_inforp info_ptr,\r
+    png_textp *text_ptr, int *num_text)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)\r
+   {\r
+      png_debug1(1, "in 0x%lx retrieval function",\r
+         (unsigned long)png_ptr->chunk_name);\r
+\r
+      if (text_ptr != NULL)\r
+         *text_ptr = info_ptr->text;\r
+\r
+      if (num_text != NULL)\r
+         *num_text = info_ptr->num_text;\r
+\r
+      return info_ptr->num_text;\r
+   }\r
+\r
+   if (num_text != NULL)\r
+      *num_text = 0;\r
+\r
+   return(0);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_tIME_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_tIME(png_const_structrp png_ptr, png_inforp info_ptr,\r
+    png_timep *mod_time)\r
+{\r
+   png_debug1(1, "in %s retrieval function", "tIME");\r
+\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)\r
+       && mod_time != NULL)\r
+   {\r
+      *mod_time = &(info_ptr->mod_time);\r
+      return (PNG_INFO_tIME);\r
+   }\r
+\r
+   return (0);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_tRNS_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_tRNS(png_const_structrp png_ptr, png_inforp info_ptr,\r
+    png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)\r
+{\r
+   png_uint_32 retval = 0;\r
+   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))\r
+   {\r
+      png_debug1(1, "in %s retrieval function", "tRNS");\r
+\r
+      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+      {\r
+         if (trans_alpha != NULL)\r
+         {\r
+            *trans_alpha = info_ptr->trans_alpha;\r
+            retval |= PNG_INFO_tRNS;\r
+         }\r
+\r
+         if (trans_color != NULL)\r
+            *trans_color = &(info_ptr->trans_color);\r
+      }\r
+\r
+      else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */\r
+      {\r
+         if (trans_color != NULL)\r
+         {\r
+            *trans_color = &(info_ptr->trans_color);\r
+            retval |= PNG_INFO_tRNS;\r
+         }\r
+\r
+         if (trans_alpha != NULL)\r
+            *trans_alpha = NULL;\r
+      }\r
+\r
+      if (num_trans != NULL)\r
+      {\r
+         *num_trans = info_ptr->num_trans;\r
+         retval |= PNG_INFO_tRNS;\r
+      }\r
+   }\r
+\r
+   return (retval);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED\r
+int PNGAPI\r
+png_get_unknown_chunks(png_const_structrp png_ptr, png_inforp info_ptr,\r
+    png_unknown_chunkpp unknowns)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)\r
+   {\r
+      *unknowns = info_ptr->unknown_chunks;\r
+      return info_ptr->unknown_chunks_num;\r
+   }\r
+\r
+   return (0);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED\r
+png_byte PNGAPI\r
+png_get_rgb_to_gray_status (png_const_structrp png_ptr)\r
+{\r
+   return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_USER_CHUNKS_SUPPORTED\r
+png_voidp PNGAPI\r
+png_get_user_chunk_ptr(png_const_structrp png_ptr)\r
+{\r
+   return (png_ptr ? png_ptr->user_chunk_ptr : NULL);\r
+}\r
+#endif\r
+\r
+png_size_t PNGAPI\r
+png_get_compression_buffer_size(png_const_structrp png_ptr)\r
+{\r
+   if (png_ptr == NULL)\r
+      return 0;\r
+\r
+#  ifdef PNG_WRITE_SUPPORTED\r
+      if (png_ptr->mode & PNG_IS_READ_STRUCT)\r
+#  endif\r
+   {\r
+#     ifdef PNG_SEQUENTIAL_READ_SUPPORTED\r
+         return png_ptr->IDAT_read_size;\r
+#     else\r
+         return PNG_IDAT_READ_SIZE;\r
+#     endif\r
+   }\r
+\r
+#  ifdef PNG_WRITE_SUPPORTED\r
+      else\r
+         return png_ptr->zbuffer_size;\r
+#  endif\r
+}\r
+\r
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED\r
+/* These functions were added to libpng 1.2.6 and were enabled\r
+ * by default in libpng-1.4.0 */\r
+png_uint_32 PNGAPI\r
+png_get_user_width_max (png_const_structrp png_ptr)\r
+{\r
+   return (png_ptr ? png_ptr->user_width_max : 0);\r
+}\r
+\r
+png_uint_32 PNGAPI\r
+png_get_user_height_max (png_const_structrp png_ptr)\r
+{\r
+   return (png_ptr ? png_ptr->user_height_max : 0);\r
+}\r
+\r
+/* This function was added to libpng 1.4.0 */\r
+png_uint_32 PNGAPI\r
+png_get_chunk_cache_max (png_const_structrp png_ptr)\r
+{\r
+   return (png_ptr ? png_ptr->user_chunk_cache_max : 0);\r
+}\r
+\r
+/* This function was added to libpng 1.4.1 */\r
+png_alloc_size_t PNGAPI\r
+png_get_chunk_malloc_max (png_const_structrp png_ptr)\r
+{\r
+   return (png_ptr ? png_ptr->user_chunk_malloc_max : 0);\r
+}\r
+#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */\r
+\r
+/* These functions were added to libpng 1.4.0 */\r
+#ifdef PNG_IO_STATE_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_io_state (png_const_structrp png_ptr)\r
+{\r
+   return png_ptr->io_state;\r
+}\r
+\r
+png_uint_32 PNGAPI\r
+png_get_io_chunk_type (png_const_structrp png_ptr)\r
+{\r
+   return png_ptr->chunk_name;\r
+}\r
+#endif /* ?PNG_IO_STATE_SUPPORTED */\r
+\r
+#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED\r
+#  ifdef PNG_GET_PALETTE_MAX_SUPPORTED\r
+int PNGAPI\r
+png_get_palette_max(png_const_structp png_ptr, png_const_infop info_ptr)\r
+{\r
+   if (png_ptr != NULL && info_ptr != NULL)\r
+      return png_ptr->num_palette_max;\r
+\r
+   return (-1);\r
+}\r
+#  endif\r
+#endif\r
+\r
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */\r
diff --git a/samples/fx_lpng/lpng_v163/fx_pngmem.c b/samples/fx_lpng/lpng_v163/fx_pngmem.c
new file mode 100644 (file)
index 0000000..9be5803
--- /dev/null
@@ -0,0 +1,289 @@
+/* pngmem.c - stub functions for memory allocation\r
+ *\r
+ * Last changed in libpng 1.6.0 [February 14, 2013]\r
+ * Copyright (c) 1998-2013 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ *\r
+ * This code is released under the libpng license.\r
+ * For conditions of distribution and use, see the disclaimer\r
+ * and license in png.h\r
+ *\r
+ * This file provides a location for all memory allocation.  Users who\r
+ * need special memory handling are expected to supply replacement\r
+ * functions for png_malloc() and png_free(), and to use\r
+ * png_create_read_struct_2() and png_create_write_struct_2() to\r
+ * identify the replacement functions.\r
+ */\r
+\r
+#include "pngpriv.h"\r
+\r
+#if defined(_FX_MANAGED_CODE_) && defined(__cplusplus)\r
+extern "C" {\r
+#endif\r
+\r
+void*  FXMEM_DefaultAlloc(int byte_size, int);\r
+void   FXMEM_DefaultFree(void* pointer, int);\r
+\r
+#if defined(_FX_MANAGED_CODE_) && defined(__cplusplus)\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)\r
+/* Free a png_struct */\r
+void /* PRIVATE */\r
+png_destroy_png_struct(png_structrp png_ptr)\r
+{\r
+   if (png_ptr != NULL)\r
+   {\r
+      /* png_free might call png_error and may certainly call\r
+       * png_get_mem_ptr, so fake a temporary png_struct to support this.\r
+       */\r
+      png_struct dummy_struct = *png_ptr;\r
+      memset(png_ptr, 0, (sizeof *png_ptr));\r
+      png_free(&dummy_struct, png_ptr);\r
+\r
+#     ifdef PNG_SETJMP_SUPPORTED\r
+         /* We may have a jmp_buf left to deallocate. */\r
+         png_free_jmpbuf(&dummy_struct);\r
+#     endif\r
+   }\r
+}\r
+\r
+/* Allocate memory.  For reasonable files, size should never exceed\r
+ * 64K.  However, zlib may allocate more then 64K if you don't tell\r
+ * it not to.  See zconf.h and png.h for more information.  zlib does\r
+ * need to allocate exactly 64K, so whatever you call here must\r
+ * have the ability to do that.\r
+ */\r
+PNG_FUNCTION(png_voidp,PNGAPI\r
+png_calloc,(png_const_structrp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)\r
+{\r
+   png_voidp ret;\r
+\r
+   ret = png_malloc(png_ptr, size);\r
+\r
+   if (ret != NULL)\r
+      memset(ret, 0, size);\r
+\r
+   return ret;\r
+}\r
+\r
+/* png_malloc_base, an internal function added at libpng 1.6.0, does the work of\r
+ * allocating memory, taking into account limits and PNG_USER_MEM_SUPPORTED.\r
+ * Checking and error handling must happen outside this routine; it returns NULL\r
+ * if the allocation cannot be done (for any reason.)\r
+ */\r
+PNG_FUNCTION(png_voidp /* PRIVATE */,\r
+png_malloc_base,(png_const_structrp png_ptr, png_alloc_size_t size),\r
+   PNG_ALLOCATED)\r
+{\r
+   /* Moved to png_malloc_base from png_malloc_default in 1.6.0; the DOS\r
+    * allocators have also been removed in 1.6.0, so any 16-bit system now has\r
+    * to implement a user memory handler.  This checks to be sure it isn't\r
+    * called with big numbers.\r
+    */\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+   PNG_UNUSED(png_ptr)\r
+#endif\r
+   if (size > 0 && size <= PNG_SIZE_MAX\r
+#     ifdef PNG_MAX_MALLOC_64K\r
+         && size <= 65536U\r
+#     endif\r
+      )\r
+   {\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+      if (png_ptr != NULL && png_ptr->malloc_fn != NULL)\r
+         return png_ptr->malloc_fn(png_constcast(png_structrp,png_ptr), size);\r
+\r
+      else\r
+#endif\r
+         return FXMEM_DefaultAlloc((int)size, 0);\r
+         //return malloc((size_t)size); /* checked for truncation above */\r
+   }\r
+\r
+   else\r
+      return NULL;\r
+}\r
+\r
+/* This is really here only to work round a spurious warning in GCC 4.6 and 4.7\r
+ * that arises because of the checks in png_realloc_array that are repeated in\r
+ * png_malloc_array.\r
+ */\r
+static png_voidp\r
+png_malloc_array_checked(png_const_structrp png_ptr, int nelements,\r
+   size_t element_size)\r
+{\r
+   png_alloc_size_t req = nelements; /* known to be > 0 */\r
+\r
+   if (req <= PNG_SIZE_MAX/element_size)\r
+      return png_malloc_base(png_ptr, req * element_size);\r
+\r
+   /* The failure case when the request is too large */\r
+   return NULL;\r
+}\r
+\r
+PNG_FUNCTION(png_voidp /* PRIVATE */,\r
+png_malloc_array,(png_const_structrp png_ptr, int nelements,\r
+   size_t element_size),PNG_ALLOCATED)\r
+{\r
+   if (nelements <= 0 || element_size == 0)\r
+      png_error(png_ptr, "internal error: array alloc");\r
+\r
+   return png_malloc_array_checked(png_ptr, nelements, element_size);\r
+}\r
+\r
+PNG_FUNCTION(png_voidp /* PRIVATE */,\r
+png_realloc_array,(png_const_structrp png_ptr, png_const_voidp old_array,\r
+   int old_elements, int add_elements, size_t element_size),PNG_ALLOCATED)\r
+{\r
+   /* These are internal errors: */\r
+   if (add_elements <= 0 || element_size == 0 || old_elements < 0 ||\r
+      (old_array == NULL && old_elements > 0))\r
+      png_error(png_ptr, "internal error: array realloc");\r
+\r
+   /* Check for overflow on the elements count (so the caller does not have to\r
+    * check.)\r
+    */\r
+   if (add_elements <= INT_MAX - old_elements)\r
+   {\r
+      png_voidp new_array = png_malloc_array_checked(png_ptr,\r
+         old_elements+add_elements, element_size);\r
+\r
+      if (new_array != NULL)\r
+      {\r
+         /* Because png_malloc_array worked the size calculations below cannot\r
+          * overflow.\r
+          */\r
+         if (old_elements > 0)\r
+            memcpy(new_array, old_array, element_size*(unsigned)old_elements);\r
+\r
+         memset((char*)new_array + element_size*(unsigned)old_elements, 0,\r
+            element_size*(unsigned)add_elements);\r
+\r
+         return new_array;\r
+      }\r
+   }\r
+\r
+   return NULL; /* error */\r
+}\r
+\r
+/* Various functions that have different error handling are derived from this.\r
+ * png_malloc always exists, but if PNG_USER_MEM_SUPPORTED is defined a separate\r
+ * function png_malloc_default is also provided.\r
+ */\r
+PNG_FUNCTION(png_voidp,PNGAPI\r
+png_malloc,(png_const_structrp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)\r
+{\r
+   png_voidp ret;\r
+\r
+   if (png_ptr == NULL)\r
+      return NULL;\r
+\r
+   ret = png_malloc_base(png_ptr, size);\r
+\r
+   if (ret == NULL)\r
+       png_error(png_ptr, "Out of memory"); /* 'm' means png_malloc */\r
+\r
+   return ret;\r
+}\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+PNG_FUNCTION(png_voidp,PNGAPI\r
+png_malloc_default,(png_const_structrp png_ptr, png_alloc_size_t size),\r
+   PNG_ALLOCATED PNG_DEPRECATED)\r
+{\r
+   png_voidp ret;\r
+\r
+   if (png_ptr == NULL)\r
+      return NULL;\r
+\r
+   /* Passing 'NULL' here bypasses the application provided memory handler. */\r
+   ret = png_malloc_base(NULL/*use malloc*/, size);\r
+\r
+   if (ret == NULL)\r
+      png_error(png_ptr, "Out of Memory"); /* 'M' means png_malloc_default */\r
+\r
+   return ret;\r
+}\r
+#endif /* PNG_USER_MEM_SUPPORTED */\r
+\r
+/* This function was added at libpng version 1.2.3.  The png_malloc_warn()\r
+ * function will issue a png_warning and return NULL instead of issuing a\r
+ * png_error, if it fails to allocate the requested memory.\r
+ */\r
+PNG_FUNCTION(png_voidp,PNGAPI\r
+png_malloc_warn,(png_const_structrp png_ptr, png_alloc_size_t size),\r
+   PNG_ALLOCATED)\r
+{\r
+   if (png_ptr != NULL)\r
+   {\r
+      png_voidp ret = png_malloc_base(png_ptr, size);\r
+\r
+      if (ret != NULL)\r
+         return ret;\r
+\r
+      png_warning(png_ptr, "Out of memory");\r
+   }\r
+\r
+   return NULL;\r
+}\r
+\r
+/* Free a pointer allocated by png_malloc().  If ptr is NULL, return\r
+ * without taking any action.\r
+ */\r
+void PNGAPI\r
+png_free(png_const_structrp png_ptr, png_voidp ptr)\r
+{\r
+   if (png_ptr == NULL || ptr == NULL)\r
+      return;\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+   if (png_ptr->free_fn != NULL)\r
+      png_ptr->free_fn(png_constcast(png_structrp,png_ptr), ptr);\r
+\r
+   else\r
+      png_free_default(png_ptr, ptr);\r
+}\r
+\r
+PNG_FUNCTION(void,PNGAPI\r
+png_free_default,(png_const_structrp png_ptr, png_voidp ptr),PNG_DEPRECATED)\r
+{\r
+   if (png_ptr == NULL || ptr == NULL)\r
+      return;\r
+#endif /* PNG_USER_MEM_SUPPORTED */\r
+\r
+   FXMEM_DefaultFree(ptr, 0);\r
+   //free(ptr);\r
+}\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+/* This function is called when the application wants to use another method\r
+ * of allocating and freeing memory.\r
+ */\r
+void PNGAPI\r
+png_set_mem_fn(png_structrp png_ptr, png_voidp mem_ptr, png_malloc_ptr\r
+  malloc_fn, png_free_ptr free_fn)\r
+{\r
+   if (png_ptr != NULL)\r
+   {\r
+      png_ptr->mem_ptr = mem_ptr;\r
+      png_ptr->malloc_fn = malloc_fn;\r
+      png_ptr->free_fn = free_fn;\r
+   }\r
+}\r
+\r
+/* This function returns a pointer to the mem_ptr associated with the user\r
+ * functions.  The application should free any memory associated with this\r
+ * pointer before png_write_destroy and png_read_destroy are called.\r
+ */\r
+png_voidp PNGAPI\r
+png_get_mem_ptr(png_const_structrp png_ptr)\r
+{\r
+   if (png_ptr == NULL)\r
+      return NULL;\r
+\r
+   return png_ptr->mem_ptr;\r
+}\r
+#endif /* PNG_USER_MEM_SUPPORTED */\r
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */\r
diff --git a/samples/fx_lpng/lpng_v163/fx_pngpread.c b/samples/fx_lpng/lpng_v163/fx_pngpread.c
new file mode 100644 (file)
index 0000000..afb2abf
--- /dev/null
@@ -0,0 +1,1290 @@
+/* pngpread.c - read a png file in push mode\r
+ *\r
+ * Last changed in libpng 1.6.0 [February 14, 2013]\r
+ * Copyright (c) 1998-2013 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ *\r
+ * This code is released under the libpng license.\r
+ * For conditions of distribution and use, see the disclaimer\r
+ * and license in png.h\r
+ */\r
+\r
+#include "pngpriv.h"\r
+\r
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED\r
+\r
+/* Push model modes */\r
+#define PNG_READ_SIG_MODE   0\r
+#define PNG_READ_CHUNK_MODE 1\r
+#define PNG_READ_IDAT_MODE  2\r
+#define PNG_SKIP_MODE       3\r
+#define PNG_READ_tEXt_MODE  4\r
+#define PNG_READ_zTXt_MODE  5\r
+#define PNG_READ_DONE_MODE  6\r
+#define PNG_READ_iTXt_MODE  7\r
+#define PNG_ERROR_MODE      8\r
+\r
+void PNGAPI\r
+png_process_data(png_structrp png_ptr, png_inforp info_ptr,\r
+    png_bytep buffer, png_size_t buffer_size)\r
+{\r
+   if (png_ptr == NULL || info_ptr == NULL)\r
+      return;\r
+\r
+   png_push_restore_buffer(png_ptr, buffer, buffer_size);\r
+\r
+   while (png_ptr->buffer_size)\r
+   {\r
+      png_process_some_data(png_ptr, info_ptr);\r
+   }\r
+}\r
+\r
+png_size_t PNGAPI\r
+png_process_data_pause(png_structrp png_ptr, int save)\r
+{\r
+   if (png_ptr != NULL)\r
+   {\r
+      /* It's easiest for the caller if we do the save, then the caller doesn't\r
+       * have to supply the same data again:\r
+       */\r
+      if (save)\r
+         png_push_save_buffer(png_ptr);\r
+      else\r
+      {\r
+         /* This includes any pending saved bytes: */\r
+         png_size_t remaining = png_ptr->buffer_size;\r
+         png_ptr->buffer_size = 0;\r
+\r
+         /* So subtract the saved buffer size, unless all the data\r
+          * is actually 'saved', in which case we just return 0\r
+          */\r
+         if (png_ptr->save_buffer_size < remaining)\r
+            return remaining - png_ptr->save_buffer_size;\r
+      }\r
+   }\r
+\r
+   return 0;\r
+}\r
+\r
+png_uint_32 PNGAPI\r
+png_process_data_skip(png_structrp png_ptr)\r
+{\r
+   png_uint_32 remaining = 0;\r
+\r
+   if (png_ptr != NULL && png_ptr->process_mode == PNG_SKIP_MODE &&\r
+      png_ptr->skip_length > 0)\r
+   {\r
+      /* At the end of png_process_data the buffer size must be 0 (see the loop\r
+       * above) so we can detect a broken call here:\r
+       */\r
+      if (png_ptr->buffer_size != 0)\r
+         png_error(png_ptr,\r
+            "png_process_data_skip called inside png_process_data");\r
+\r
+      /* If is impossible for there to be a saved buffer at this point -\r
+       * otherwise we could not be in SKIP mode.  This will also happen if\r
+       * png_process_skip is called inside png_process_data (but only very\r
+       * rarely.)\r
+       */\r
+      if (png_ptr->save_buffer_size != 0)\r
+         png_error(png_ptr, "png_process_data_skip called with saved data");\r
+\r
+      remaining = png_ptr->skip_length;\r
+      png_ptr->skip_length = 0;\r
+      png_ptr->process_mode = PNG_READ_CHUNK_MODE;\r
+   }\r
+\r
+   return remaining;\r
+}\r
+\r
+/* What we do with the incoming data depends on what we were previously\r
+ * doing before we ran out of data...\r
+ */\r
+void /* PRIVATE */\r
+png_process_some_data(png_structrp png_ptr, png_inforp info_ptr)\r
+{\r
+   if (png_ptr == NULL)\r
+      return;\r
+\r
+   switch (png_ptr->process_mode)\r
+   {\r
+      case PNG_READ_SIG_MODE:\r
+      {\r
+         png_push_read_sig(png_ptr, info_ptr);\r
+         break;\r
+      }\r
+\r
+      case PNG_READ_CHUNK_MODE:\r
+      {\r
+         png_push_read_chunk(png_ptr, info_ptr);\r
+         break;\r
+      }\r
+\r
+      case PNG_READ_IDAT_MODE:\r
+      {\r
+         png_push_read_IDAT(png_ptr);\r
+         break;\r
+      }\r
+\r
+      case PNG_SKIP_MODE:\r
+      {\r
+         png_push_crc_finish(png_ptr);\r
+         break;\r
+      }\r
+\r
+      default:\r
+      {\r
+         png_ptr->buffer_size = 0;\r
+         break;\r
+      }\r
+   }\r
+}\r
+\r
+/* Read any remaining signature bytes from the stream and compare them with\r
+ * the correct PNG signature.  It is possible that this routine is called\r
+ * with bytes already read from the signature, either because they have been\r
+ * checked by the calling application, or because of multiple calls to this\r
+ * routine.\r
+ */\r
+void /* PRIVATE */\r
+png_push_read_sig(png_structrp png_ptr, png_inforp info_ptr)\r
+{\r
+   png_size_t num_checked = png_ptr->sig_bytes, /* SAFE, does not exceed 8 */ \r
+             num_to_check = 8 - num_checked;\r
+\r
+   if (png_ptr->buffer_size < num_to_check)\r
+   {\r
+      num_to_check = png_ptr->buffer_size;\r
+   }\r
+\r
+   png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),\r
+       num_to_check);\r
+   png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check);\r
+\r
+   if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))\r
+   {\r
+      if (num_checked < 4 &&\r
+          png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))\r
+         png_error(png_ptr, "Not a PNG file");\r
+\r
+      else\r
+         png_error(png_ptr, "PNG file corrupted by ASCII conversion");\r
+   }\r
+   else\r
+   {\r
+      if (png_ptr->sig_bytes >= 8)\r
+      {\r
+         png_ptr->process_mode = PNG_READ_CHUNK_MODE;\r
+      }\r
+   }\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)\r
+{\r
+   png_uint_32 chunk_name;\r
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED\r
+   int keep; /* unknown handling method */\r
+#endif\r
+\r
+   /* First we make sure we have enough data for the 4 byte chunk name\r
+    * and the 4 byte chunk length before proceeding with decoding the\r
+    * chunk data.  To fully decode each of these chunks, we also make\r
+    * sure we have enough data in the buffer for the 4 byte CRC at the\r
+    * end of every chunk (except IDAT, which is handled separately).\r
+    */\r
+   if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))\r
+   {\r
+      png_byte chunk_length[4];\r
+      png_byte chunk_tag[4];\r
+\r
+      if (png_ptr->buffer_size < 8)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_push_fill_buffer(png_ptr, chunk_length, 4);\r
+      png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);\r
+      png_reset_crc(png_ptr);\r
+      png_crc_read(png_ptr, chunk_tag, 4);\r
+      png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(chunk_tag);\r
+      png_check_chunk_name(png_ptr, png_ptr->chunk_name);\r
+      png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;\r
+   }\r
+\r
+   chunk_name = png_ptr->chunk_name;\r
+\r
+   if (chunk_name == png_IDAT)\r
+   {\r
+      if (png_ptr->mode & PNG_AFTER_IDAT)\r
+         png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;\r
+\r
+      /* If we reach an IDAT chunk, this means we have read all of the\r
+       * header chunks, and we can start reading the image (or if this\r
+       * is called after the image has been read - we have an error).\r
+       */\r
+      if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+         png_error(png_ptr, "Missing IHDR before IDAT");\r
+\r
+      else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&\r
+          !(png_ptr->mode & PNG_HAVE_PLTE))\r
+         png_error(png_ptr, "Missing PLTE before IDAT");\r
+\r
+      png_ptr->mode |= PNG_HAVE_IDAT;\r
+\r
+      if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))\r
+         if (png_ptr->push_length == 0)\r
+            return;\r
+\r
+      if (png_ptr->mode & PNG_AFTER_IDAT)\r
+         png_benign_error(png_ptr, "Too many IDATs found");\r
+   }\r
+\r
+   if (chunk_name == png_IHDR)\r
+   {\r
+      if (png_ptr->push_length != 13)\r
+         png_error(png_ptr, "Invalid IHDR length");\r
+\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);\r
+   }\r
+\r
+   else if (chunk_name == png_IEND)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);\r
+\r
+      png_ptr->process_mode = PNG_READ_DONE_MODE;\r
+      png_push_have_end(png_ptr, info_ptr);\r
+   }\r
+\r
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED\r
+   else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length, keep);\r
+\r
+      if (chunk_name == png_PLTE)\r
+         png_ptr->mode |= PNG_HAVE_PLTE;\r
+   }\r
+\r
+#endif\r
+   else if (chunk_name == png_PLTE)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+      png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);\r
+   }\r
+\r
+   else if (chunk_name == png_IDAT)\r
+   {\r
+      png_ptr->idat_size = png_ptr->push_length;\r
+      png_ptr->process_mode = PNG_READ_IDAT_MODE;\r
+      png_push_have_info(png_ptr, info_ptr);\r
+      png_ptr->zstream.avail_out =\r
+          (uInt) PNG_ROWBYTES(png_ptr->pixel_depth,\r
+          png_ptr->iwidth) + 1;\r
+      png_ptr->zstream.next_out = png_ptr->row_buf;\r
+      return;\r
+   }\r
+\r
+#ifdef PNG_READ_gAMA_SUPPORTED\r
+   else if (png_ptr->chunk_name == png_gAMA)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);\r
+   }\r
+\r
+#endif\r
+#ifdef PNG_READ_sBIT_SUPPORTED\r
+   else if (png_ptr->chunk_name == png_sBIT)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);\r
+   }\r
+\r
+#endif\r
+#ifdef PNG_READ_cHRM_SUPPORTED\r
+   else if (png_ptr->chunk_name == png_cHRM)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);\r
+   }\r
+\r
+#endif\r
+#ifdef PNG_READ_sRGB_SUPPORTED\r
+   else if (chunk_name == png_sRGB)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);\r
+   }\r
+\r
+#endif\r
+#ifdef PNG_READ_iCCP_SUPPORTED\r
+   else if (png_ptr->chunk_name == png_iCCP)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);\r
+   }\r
+\r
+#endif\r
+#ifdef PNG_READ_sPLT_SUPPORTED\r
+   else if (chunk_name == png_sPLT)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);\r
+   }\r
+\r
+#endif\r
+#ifdef PNG_READ_tRNS_SUPPORTED\r
+   else if (chunk_name == png_tRNS)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);\r
+   }\r
+\r
+#endif\r
+#ifdef PNG_READ_bKGD_SUPPORTED\r
+   else if (chunk_name == png_bKGD)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);\r
+   }\r
+\r
+#endif\r
+#ifdef PNG_READ_hIST_SUPPORTED\r
+   else if (chunk_name == png_hIST)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);\r
+   }\r
+\r
+#endif\r
+#ifdef PNG_READ_pHYs_SUPPORTED\r
+   else if (chunk_name == png_pHYs)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);\r
+   }\r
+\r
+#endif\r
+#ifdef PNG_READ_oFFs_SUPPORTED\r
+   else if (chunk_name == png_oFFs)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);\r
+   }\r
+#endif\r
+\r
+#ifdef PNG_READ_pCAL_SUPPORTED\r
+   else if (chunk_name == png_pCAL)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);\r
+   }\r
+\r
+#endif\r
+#ifdef PNG_READ_sCAL_SUPPORTED\r
+   else if (chunk_name == png_sCAL)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);\r
+   }\r
+\r
+#endif\r
+#ifdef PNG_READ_tIME_SUPPORTED\r
+   else if (chunk_name == png_tIME)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);\r
+   }\r
+\r
+#endif\r
+#ifdef PNG_READ_tEXt_SUPPORTED\r
+   else if (chunk_name == png_tEXt)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);\r
+   }\r
+\r
+#endif\r
+#ifdef PNG_READ_zTXt_SUPPORTED\r
+   else if (chunk_name == png_zTXt)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);\r
+   }\r
+\r
+#endif\r
+#ifdef PNG_READ_iTXt_SUPPORTED\r
+   else if (chunk_name == png_iTXt)\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);\r
+   }\r
+\r
+#endif\r
+   else\r
+   {\r
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+      png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length,\r
+         PNG_HANDLE_CHUNK_AS_DEFAULT);\r
+   }\r
+\r
+   png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_crc_skip(png_structrp png_ptr, png_uint_32 skip)\r
+{\r
+   png_ptr->process_mode = PNG_SKIP_MODE;\r
+   png_ptr->skip_length = skip;\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_crc_finish(png_structrp png_ptr)\r
+{\r
+   if (png_ptr->skip_length && png_ptr->save_buffer_size)\r
+   {\r
+      png_size_t save_size = png_ptr->save_buffer_size;\r
+      png_uint_32 skip_length = png_ptr->skip_length;\r
+\r
+      /* We want the smaller of 'skip_length' and 'save_buffer_size', but\r
+       * they are of different types and we don't know which variable has the\r
+       * fewest bits.  Carefully select the smaller and cast it to the type of\r
+       * the larger - this cannot overflow.  Do not cast in the following test\r
+       * - it will break on either 16 or 64 bit platforms.\r
+       */\r
+      if (skip_length < save_size)\r
+         save_size = (png_size_t)skip_length;\r
+\r
+      else\r
+         skip_length = (png_uint_32)save_size;\r
+\r
+      png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);\r
+\r
+      png_ptr->skip_length -= skip_length;\r
+      png_ptr->buffer_size -= save_size;\r
+      png_ptr->save_buffer_size -= save_size;\r
+      png_ptr->save_buffer_ptr += save_size;\r
+   }\r
+   if (png_ptr->skip_length && png_ptr->current_buffer_size)\r
+   {\r
+      png_size_t save_size = png_ptr->current_buffer_size;\r
+      png_uint_32 skip_length = png_ptr->skip_length;\r
+\r
+      /* We want the smaller of 'skip_length' and 'current_buffer_size', here,\r
+       * the same problem exists as above and the same solution.\r
+       */\r
+      if (skip_length < save_size)\r
+         save_size = (png_size_t)skip_length;\r
+\r
+      else\r
+         skip_length = (png_uint_32)save_size;\r
+\r
+      png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);\r
+\r
+      png_ptr->skip_length -= skip_length;\r
+      png_ptr->buffer_size -= save_size;\r
+      png_ptr->current_buffer_size -= save_size;\r
+      png_ptr->current_buffer_ptr += save_size;\r
+   }\r
+   if (!png_ptr->skip_length)\r
+   {\r
+      if (png_ptr->buffer_size < 4)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_crc_finish(png_ptr, 0);\r
+      png_ptr->process_mode = PNG_READ_CHUNK_MODE;\r
+   }\r
+}\r
+\r
+void PNGCBAPI\r
+png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)\r
+{\r
+   png_bytep ptr;\r
+\r
+   if (png_ptr == NULL)\r
+      return;\r
+\r
+   ptr = buffer;\r
+   if (png_ptr->save_buffer_size)\r
+   {\r
+      png_size_t save_size;\r
+\r
+      if (length < png_ptr->save_buffer_size)\r
+         save_size = length;\r
+\r
+      else\r
+         save_size = png_ptr->save_buffer_size;\r
+\r
+      memcpy(ptr, png_ptr->save_buffer_ptr, save_size);\r
+      length -= save_size;\r
+      ptr += save_size;\r
+      png_ptr->buffer_size -= save_size;\r
+      png_ptr->save_buffer_size -= save_size;\r
+      png_ptr->save_buffer_ptr += save_size;\r
+   }\r
+   if (length && png_ptr->current_buffer_size)\r
+   {\r
+      png_size_t save_size;\r
+\r
+      if (length < png_ptr->current_buffer_size)\r
+         save_size = length;\r
+\r
+      else\r
+         save_size = png_ptr->current_buffer_size;\r
+\r
+      memcpy(ptr, png_ptr->current_buffer_ptr, save_size);\r
+      png_ptr->buffer_size -= save_size;\r
+      png_ptr->current_buffer_size -= save_size;\r
+      png_ptr->current_buffer_ptr += save_size;\r
+   }\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_save_buffer(png_structrp png_ptr)\r
+{\r
+   if (png_ptr->save_buffer_size)\r
+   {\r
+      if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)\r
+      {\r
+         png_size_t i, istop;\r
+         png_bytep sp;\r
+         png_bytep dp;\r
+\r
+         istop = png_ptr->save_buffer_size;\r
+         for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer;\r
+             i < istop; i++, sp++, dp++)\r
+         {\r
+            *dp = *sp;\r
+         }\r
+      }\r
+   }\r
+   if (png_ptr->save_buffer_size + png_ptr->current_buffer_size >\r
+       png_ptr->save_buffer_max)\r
+   {\r
+      png_size_t new_max;\r
+      png_bytep old_buffer;\r
+\r
+      if (png_ptr->save_buffer_size > PNG_SIZE_MAX -\r
+          (png_ptr->current_buffer_size + 256))\r
+      {\r
+         png_error(png_ptr, "Potential overflow of save_buffer");\r
+      }\r
+\r
+      new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;\r
+      old_buffer = png_ptr->save_buffer;\r
+      png_ptr->save_buffer = (png_bytep)png_malloc_warn(png_ptr,\r
+          (png_size_t)new_max);\r
+\r
+      if (png_ptr->save_buffer == NULL)\r
+      {\r
+         png_free(png_ptr, old_buffer);\r
+         png_error(png_ptr, "Insufficient memory for save_buffer");\r
+      }\r
+\r
+      memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);\r
+      png_free(png_ptr, old_buffer);\r
+      png_ptr->save_buffer_max = new_max;\r
+   }\r
+   if (png_ptr->current_buffer_size)\r
+   {\r
+      memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size,\r
+         png_ptr->current_buffer_ptr, png_ptr->current_buffer_size);\r
+      png_ptr->save_buffer_size += png_ptr->current_buffer_size;\r
+      png_ptr->current_buffer_size = 0;\r
+   }\r
+   png_ptr->save_buffer_ptr = png_ptr->save_buffer;\r
+   png_ptr->buffer_size = 0;\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_restore_buffer(png_structrp png_ptr, png_bytep buffer,\r
+   png_size_t buffer_length)\r
+{\r
+   png_ptr->current_buffer = buffer;\r
+   png_ptr->current_buffer_size = buffer_length;\r
+   png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size;\r
+   png_ptr->current_buffer_ptr = png_ptr->current_buffer;\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_read_IDAT(png_structrp png_ptr)\r
+{\r
+   if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))\r
+   {\r
+      png_byte chunk_length[4];\r
+      png_byte chunk_tag[4];\r
+\r
+      /* TODO: this code can be commoned up with the same code in push_read */\r
+      if (png_ptr->buffer_size < 8)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_push_fill_buffer(png_ptr, chunk_length, 4);\r
+      png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);\r
+      png_reset_crc(png_ptr);\r
+      png_crc_read(png_ptr, chunk_tag, 4);\r
+      png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(chunk_tag);\r
+      png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;\r
+\r
+      if (png_ptr->chunk_name != png_IDAT)\r
+      {\r
+         png_ptr->process_mode = PNG_READ_CHUNK_MODE;\r
+\r
+         if (!(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))\r
+            png_error(png_ptr, "Not enough compressed data");\r
+\r
+         return;\r
+      }\r
+\r
+      png_ptr->idat_size = png_ptr->push_length;\r
+   }\r
+\r
+   if (png_ptr->idat_size && png_ptr->save_buffer_size)\r
+   {\r
+      png_size_t save_size = png_ptr->save_buffer_size;\r
+      png_uint_32 idat_size = png_ptr->idat_size;\r
+\r
+      /* We want the smaller of 'idat_size' and 'current_buffer_size', but they\r
+       * are of different types and we don't know which variable has the fewest\r
+       * bits.  Carefully select the smaller and cast it to the type of the\r
+       * larger - this cannot overflow.  Do not cast in the following test - it\r
+       * will break on either 16 or 64 bit platforms.\r
+       */\r
+      if (idat_size < save_size)\r
+         save_size = (png_size_t)idat_size;\r
+\r
+      else\r
+         idat_size = (png_uint_32)save_size;\r
+\r
+      png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);\r
+\r
+      png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size);\r
+\r
+      png_ptr->idat_size -= idat_size;\r
+      png_ptr->buffer_size -= save_size;\r
+      png_ptr->save_buffer_size -= save_size;\r
+      png_ptr->save_buffer_ptr += save_size;\r
+   }\r
+\r
+   if (png_ptr->idat_size && png_ptr->current_buffer_size)\r
+   {\r
+      png_size_t save_size = png_ptr->current_buffer_size;\r
+      png_uint_32 idat_size = png_ptr->idat_size;\r
+\r
+      /* We want the smaller of 'idat_size' and 'current_buffer_size', but they\r
+       * are of different types and we don't know which variable has the fewest\r
+       * bits.  Carefully select the smaller and cast it to the type of the\r
+       * larger - this cannot overflow.\r
+       */\r
+      if (idat_size < save_size)\r
+         save_size = (png_size_t)idat_size;\r
+\r
+      else\r
+         idat_size = (png_uint_32)save_size;\r
+\r
+      png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);\r
+\r
+      png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size);\r
+\r
+      png_ptr->idat_size -= idat_size;\r
+      png_ptr->buffer_size -= save_size;\r
+      png_ptr->current_buffer_size -= save_size;\r
+      png_ptr->current_buffer_ptr += save_size;\r
+   }\r
+   if (!png_ptr->idat_size)\r
+   {\r
+      if (png_ptr->buffer_size < 4)\r
+      {\r
+         png_push_save_buffer(png_ptr);\r
+         return;\r
+      }\r
+\r
+      png_crc_finish(png_ptr, 0);\r
+      png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;\r
+      png_ptr->mode |= PNG_AFTER_IDAT;\r
+      png_ptr->zowner = 0;\r
+   }\r
+}\r
+\r
+void /* PRIVATE */\r
+png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer,\r
+   png_size_t buffer_length)\r
+{\r
+   /* The caller checks for a non-zero buffer length. */\r
+   if (!(buffer_length > 0) || buffer == NULL)\r
+      png_error(png_ptr, "No IDAT data (internal error)");\r
+\r
+   /* This routine must process all the data it has been given\r
+    * before returning, calling the row callback as required to\r
+    * handle the uncompressed results.\r
+    */\r
+   png_ptr->zstream.next_in = buffer;\r
+   /* TODO: WARNING: TRUNCATION ERROR: DANGER WILL ROBINSON: */\r
+   png_ptr->zstream.avail_in = (uInt)buffer_length;\r
+\r
+   /* Keep going until the decompressed data is all processed\r
+    * or the stream marked as finished.\r
+    */\r
+   while (png_ptr->zstream.avail_in > 0 &&\r
+      !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))\r
+   {\r
+      int ret;\r
+\r
+      /* We have data for zlib, but we must check that zlib\r
+       * has someplace to put the results.  It doesn't matter\r
+       * if we don't expect any results -- it may be the input\r
+       * data is just the LZ end code.\r
+       */\r
+      if (!(png_ptr->zstream.avail_out > 0))\r
+      {\r
+         /* TODO: WARNING: TRUNCATION ERROR: DANGER WILL ROBINSON: */\r
+         png_ptr->zstream.avail_out = (uInt)(PNG_ROWBYTES(png_ptr->pixel_depth,\r
+             png_ptr->iwidth) + 1);\r
+\r
+         png_ptr->zstream.next_out = png_ptr->row_buf;\r
+      }\r
+\r
+      /* Using Z_SYNC_FLUSH here means that an unterminated\r
+       * LZ stream (a stream with a missing end code) can still\r
+       * be handled, otherwise (Z_NO_FLUSH) a future zlib\r
+       * implementation might defer output and therefore\r
+       * change the current behavior (see comments in inflate.c\r
+       * for why this doesn't happen at present with zlib 1.2.5).\r
+       */\r
+      ret = inflate(&png_ptr->zstream, Z_SYNC_FLUSH);\r
+\r
+      /* Check for any failure before proceeding. */\r
+      if (ret != Z_OK && ret != Z_STREAM_END)\r
+      {\r
+         /* Terminate the decompression. */\r
+         png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;\r
+         png_ptr->zowner = 0;\r
+\r
+         /* This may be a truncated stream (missing or\r
+          * damaged end code).  Treat that as a warning.\r
+          */\r
+         if (png_ptr->row_number >= png_ptr->num_rows ||\r
+             png_ptr->pass > 6)\r
+            png_warning(png_ptr, "Truncated compressed data in IDAT");\r
+\r
+         else\r
+            png_error(png_ptr, "Decompression error in IDAT");\r
+\r
+         /* Skip the check on unprocessed input */\r
+         return;\r
+      }\r
+\r
+      /* Did inflate output any data? */\r
+      if (png_ptr->zstream.next_out != png_ptr->row_buf)\r
+      {\r
+         /* Is this unexpected data after the last row?\r
+          * If it is, artificially terminate the LZ output\r
+          * here.\r
+          */\r
+         if (png_ptr->row_number >= png_ptr->num_rows ||\r
+             png_ptr->pass > 6)\r
+         {\r
+            /* Extra data. */\r
+            png_warning(png_ptr, "Extra compressed data in IDAT");\r
+            png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;\r
+            png_ptr->zowner = 0;\r
+\r
+            /* Do no more processing; skip the unprocessed\r
+             * input check below.\r
+             */\r
+            return;\r
+         }\r
+\r
+         /* Do we have a complete row? */\r
+         if (png_ptr->zstream.avail_out == 0)\r
+            png_push_process_row(png_ptr);\r
+      }\r
+\r
+      /* And check for the end of the stream. */\r
+      if (ret == Z_STREAM_END)\r
+         png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;\r
+   }\r
+\r
+   /* All the data should have been processed, if anything\r
+    * is left at this point we have bytes of IDAT data\r
+    * after the zlib end code.\r
+    */\r
+   if (png_ptr->zstream.avail_in > 0)\r
+      png_warning(png_ptr, "Extra compression data in IDAT");\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_process_row(png_structrp png_ptr)\r
+{\r
+   /* 1.5.6: row_info moved out of png_struct to a local here. */\r
+   png_row_info row_info;\r
+\r
+   row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */\r
+   row_info.color_type = png_ptr->color_type;\r
+   row_info.bit_depth = png_ptr->bit_depth;\r
+   row_info.channels = png_ptr->channels;\r
+   row_info.pixel_depth = png_ptr->pixel_depth;\r
+   row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width);\r
+\r
+   if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE)\r
+   {\r
+      if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST)\r
+         png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1,\r
+            png_ptr->prev_row + 1, png_ptr->row_buf[0]);\r
+      else\r
+         png_error(png_ptr, "bad adaptive filter value");\r
+   }\r
+\r
+   /* libpng 1.5.6: the following line was copying png_ptr->rowbytes before\r
+    * 1.5.6, while the buffer really is this big in current versions of libpng\r
+    * it may not be in the future, so this was changed just to copy the\r
+    * interlaced row count:\r
+    */\r
+   memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);\r
+\r
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED\r
+   if (png_ptr->transformations)\r
+      png_do_read_transformations(png_ptr, &row_info);\r
+#endif\r
+\r
+   /* The transformed pixel depth should match the depth now in row_info. */\r
+   if (png_ptr->transformed_pixel_depth == 0)\r
+   {\r
+      png_ptr->transformed_pixel_depth = row_info.pixel_depth;\r
+      if (row_info.pixel_depth > png_ptr->maximum_pixel_depth)\r
+         png_error(png_ptr, "progressive row overflow");\r
+   }\r
+\r
+   else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth)\r
+      png_error(png_ptr, "internal progressive row size calculation error");\r
+\r
+\r
+#ifdef PNG_READ_INTERLACING_SUPPORTED\r
+   /* Blow up interlaced rows to full size */\r
+   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))\r
+   {\r
+      if (png_ptr->pass < 6)\r
+         png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,\r
+            png_ptr->transformations);\r
+\r
+    switch (png_ptr->pass)\r
+    {\r
+         case 0:\r
+         {\r
+            int i;\r
+            for (i = 0; i < 8 && png_ptr->pass == 0; i++)\r
+            {\r
+               png_push_have_row(png_ptr, png_ptr->row_buf + 1);\r
+               png_read_push_finish_row(png_ptr); /* Updates png_ptr->pass */\r
+            }\r
+\r
+            if (png_ptr->pass == 2) /* Pass 1 might be empty */\r
+            {\r
+               for (i = 0; i < 4 && png_ptr->pass == 2; i++)\r
+               {\r
+                  png_push_have_row(png_ptr, NULL);\r
+                  png_read_push_finish_row(png_ptr);\r
+               }\r
+            }\r
+\r
+            if (png_ptr->pass == 4 && png_ptr->height <= 4)\r
+            {\r
+               for (i = 0; i < 2 && png_ptr->pass == 4; i++)\r
+               {\r
+                  png_push_have_row(png_ptr, NULL);\r
+                  png_read_push_finish_row(png_ptr);\r
+               }\r
+            }\r
+\r
+            if (png_ptr->pass == 6 && png_ptr->height <= 4)\r
+            {\r
+                png_push_have_row(png_ptr, NULL);\r
+                png_read_push_finish_row(png_ptr);\r
+            }\r
+\r
+            break;\r
+         }\r
+\r
+         case 1:\r
+         {\r
+            int i;\r
+            for (i = 0; i < 8 && png_ptr->pass == 1; i++)\r
+            {\r
+               png_push_have_row(png_ptr, png_ptr->row_buf + 1);\r
+               png_read_push_finish_row(png_ptr);\r
+            }\r
+\r
+            if (png_ptr->pass == 2) /* Skip top 4 generated rows */\r
+            {\r
+               for (i = 0; i < 4 && png_ptr->pass == 2; i++)\r
+               {\r
+                  png_push_have_row(png_ptr, NULL);\r
+                  png_read_push_finish_row(png_ptr);\r
+               }\r
+            }\r
+\r
+            break;\r
+         }\r
+\r
+         case 2:\r
+         {\r
+            int i;\r
+\r
+            for (i = 0; i < 4 && png_ptr->pass == 2; i++)\r
+            {\r
+               png_push_have_row(png_ptr, png_ptr->row_buf + 1);\r
+               png_read_push_finish_row(png_ptr);\r
+            }\r
+\r
+            for (i = 0; i < 4 && png_ptr->pass == 2; i++)\r
+            {\r
+               png_push_have_row(png_ptr, NULL);\r
+               png_read_push_finish_row(png_ptr);\r
+            }\r
+\r
+            if (png_ptr->pass == 4) /* Pass 3 might be empty */\r
+            {\r
+               for (i = 0; i < 2 && png_ptr->pass == 4; i++)\r
+               {\r
+                  png_push_have_row(png_ptr, NULL);\r
+                  png_read_push_finish_row(png_ptr);\r
+               }\r
+            }\r
+\r
+            break;\r
+         }\r
+\r
+         case 3:\r
+         {\r
+            int i;\r
+\r
+            for (i = 0; i < 4 && png_ptr->pass == 3; i++)\r
+            {\r
+               png_push_have_row(png_ptr, png_ptr->row_buf + 1);\r
+               png_read_push_finish_row(png_ptr);\r
+            }\r
+\r
+            if (png_ptr->pass == 4) /* Skip top two generated rows */\r
+            {\r
+               for (i = 0; i < 2 && png_ptr->pass == 4; i++)\r
+               {\r
+                  png_push_have_row(png_ptr, NULL);\r
+                  png_read_push_finish_row(png_ptr);\r
+               }\r
+            }\r
+\r
+            break;\r
+         }\r
+\r
+         case 4:\r
+         {\r
+            int i;\r
+\r
+            for (i = 0; i < 2 && png_ptr->pass == 4; i++)\r
+            {\r
+               png_push_have_row(png_ptr, png_ptr->row_buf + 1);\r
+               png_read_push_finish_row(png_ptr);\r
+            }\r
+\r
+            for (i = 0; i < 2 && png_ptr->pass == 4; i++)\r
+            {\r
+               png_push_have_row(png_ptr, NULL);\r
+               png_read_push_finish_row(png_ptr);\r
+            }\r
+\r
+            if (png_ptr->pass == 6) /* Pass 5 might be empty */\r
+            {\r
+               png_push_have_row(png_ptr, NULL);\r
+               png_read_push_finish_row(png_ptr);\r
+            }\r
+\r
+            break;\r
+         }\r
+\r
+         case 5:\r
+         {\r
+            int i;\r
+\r
+            for (i = 0; i < 2 && png_ptr->pass == 5; i++)\r
+            {\r
+               png_push_have_row(png_ptr, png_ptr->row_buf + 1);\r
+               png_read_push_finish_row(png_ptr);\r
+            }\r
+\r
+            if (png_ptr->pass == 6) /* Skip top generated row */\r
+            {\r
+               png_push_have_row(png_ptr, NULL);\r
+               png_read_push_finish_row(png_ptr);\r
+            }\r
+\r
+            break;\r
+         }\r
+\r
+         default:\r
+         case 6:\r
+         {\r
+            png_push_have_row(png_ptr, png_ptr->row_buf + 1);\r
+            png_read_push_finish_row(png_ptr);\r
+\r
+            if (png_ptr->pass != 6)\r
+               break;\r
+\r
+            png_push_have_row(png_ptr, NULL);\r
+            png_read_push_finish_row(png_ptr);\r
+         }\r
+      }\r
+   }\r
+   else\r
+#endif\r
+   {\r
+      png_push_have_row(png_ptr, png_ptr->row_buf + 1);\r
+      png_read_push_finish_row(png_ptr);\r
+   }\r
+}\r
+\r
+void /* PRIVATE */\r
+png_read_push_finish_row(png_structrp png_ptr)\r
+{\r
+#ifdef PNG_READ_INTERLACING_SUPPORTED\r
+   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */\r
+\r
+   /* Start of interlace block */\r
+   static PNG_CONST png_byte png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};\r
+\r
+   /* Offset to next interlace block */\r
+   static PNG_CONST png_byte png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};\r
+\r
+   /* Start of interlace block in the y direction */\r
+   static PNG_CONST png_byte png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};\r
+\r
+   /* Offset to next interlace block in the y direction */\r
+   static PNG_CONST png_byte png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};\r
+\r
+   /* Height of interlace block.  This is not currently used - if you need\r
+    * it, uncomment it here and in png.h\r
+   static PNG_CONST png_byte png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};\r
+   */\r
+#endif\r
+\r
+   png_ptr->row_number++;\r
+   if (png_ptr->row_number < png_ptr->num_rows)\r
+      return;\r
+\r
+#ifdef PNG_READ_INTERLACING_SUPPORTED\r
+   if (png_ptr->interlaced)\r
+   {\r
+      png_ptr->row_number = 0;\r
+      memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);\r
+\r
+      do\r
+      {\r
+         png_ptr->pass++;\r
+         if ((png_ptr->pass == 1 && png_ptr->width < 5) ||\r
+             (png_ptr->pass == 3 && png_ptr->width < 3) ||\r
+             (png_ptr->pass == 5 && png_ptr->width < 2))\r
+            png_ptr->pass++;\r
+\r
+         if (png_ptr->pass > 7)\r
+            png_ptr->pass--;\r
+\r
+         if (png_ptr->pass >= 7)\r
+            break;\r
+\r
+         png_ptr->iwidth = (png_ptr->width +\r
+             png_pass_inc[png_ptr->pass] - 1 -\r
+             png_pass_start[png_ptr->pass]) /\r
+             png_pass_inc[png_ptr->pass];\r
+\r
+         if (png_ptr->transformations & PNG_INTERLACE)\r
+            break;\r
+\r
+         png_ptr->num_rows = (png_ptr->height +\r
+             png_pass_yinc[png_ptr->pass] - 1 -\r
+             png_pass_ystart[png_ptr->pass]) /\r
+             png_pass_yinc[png_ptr->pass];\r
+\r
+      } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);\r
+   }\r
+#endif /* PNG_READ_INTERLACING_SUPPORTED */\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_have_info(png_structrp png_ptr, png_inforp info_ptr)\r
+{\r
+   if (png_ptr->info_fn != NULL)\r
+      (*(png_ptr->info_fn))(png_ptr, info_ptr);\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_have_end(png_structrp png_ptr, png_inforp info_ptr)\r
+{\r
+   if (png_ptr->end_fn != NULL)\r
+      (*(png_ptr->end_fn))(png_ptr, info_ptr);\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_have_row(png_structrp png_ptr, png_bytep row)\r
+{\r
+   if (png_ptr->row_fn != NULL)\r
+ &nbs