compilation fix for wxUSE_RESOURCE_LOADING_IN_MSW == 0

[wxWidgets.git] / src / png / pngmem.c

diff --git a/src/png/pngmem.c b/src/png/pngmem.c
index b92fcc8ae08ac4f583d684533eaef576981d4249..02a8e337d1e9777dd389a575b5d4f534efcbd26b 100644 (file)
--- a/src/png/pngmem.c
+++ b/src/png/pngmem.c
@@ -1,30 +1,21 @@
 
 /* pngmem.c - stub functions for memory allocation
  *
 
 /* pngmem.c - stub functions for memory allocation
  *

- * libpng 1.0.1
+ * libpng 1.2.5rc3 - September 18, 2002

  * For conditions of distribution and use, see copyright notice in png.h
  * For conditions of distribution and use, see copyright notice in png.h

- * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
- * Copyright (c) 1996, 1997 Andreas Dilger
- * Copyright (c) 1998, Glenn Randers-Pehrson
- * March 15, 1998
+ * Copyright (c) 1998-2002 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

  *
  *

- * This file provides a location for all memory allocation.  Users which
- * need special memory handling are expected to modify the code in this file
- * to meet their needs.  See the instructions at each function.
+ * This file provides a location for all memory allocation.  Users who
+ * need special memory handling are expected to supply replacement
+ * functions for png_malloc() and png_free(), and to use
+ * png_create_read_struct_2() and png_create_write_struct_2() to
+ * identify the replacement functions.

  */
 
 #define PNG_INTERNAL
  */
 
 #define PNG_INTERNAL

-#include "../png/png.h"
-
-/* The following "hides" PNG_MALLOC and PNG_FREE thus allowing the pngtest
-   application to put a wrapper on top of them. */
-#ifdef PNGTEST_MEMORY_DEBUG
-#define PNG_MALLOC png_debug_malloc
-#define PNG_FREE   png_debug_free
-#else
-#define PNG_MALLOC png_malloc
-#define PNG_FREE   png_free
-#endif
+#include "png.h"

 
 /* Borland DOS special memory handler */
 #if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
 
 /* Borland DOS special memory handler */
 #if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)


@@ -32,9 +23,18 @@
 
 /* Allocate memory for a png_struct.  The malloc and memset can be replaced
    by a single call to calloc() if this is thought to improve performance. */
 
 /* Allocate memory for a png_struct.  The malloc and memset can be replaced
    by a single call to calloc() if this is thought to improve performance. */

-png_voidp
+png_voidp /* PRIVATE */

 png_create_struct(int type)
 {
 png_create_struct(int type)
 {

+#ifdef PNG_USER_MEM_SUPPORTED
+   return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));
+}
+
+/* Alternate version of png_create_struct, for use with user-defined malloc. */
+png_voidp /* PRIVATE */
+png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */

    png_size_t size;
    png_voidp struct_ptr;
 
    png_size_t size;
    png_voidp struct_ptr;
 


@@ -43,25 +43,51 @@ png_create_struct(int type)
    else if (type == PNG_STRUCT_PNG)
      size = sizeof(png_struct);
    else
    else if (type == PNG_STRUCT_PNG)
      size = sizeof(png_struct);
    else

-     return ((png_voidp)NULL);
+     return (png_get_copyright());

 
 

-   if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL)
+#ifdef PNG_USER_MEM_SUPPORTED
+   if(malloc_fn != NULL)

    {
    {

-      png_memset(struct_ptr, 0, size);
+      png_struct dummy_struct;
+      png_structp png_ptr = &dummy_struct;
+      png_ptr->mem_ptr=mem_ptr;
+      struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size);

    }
    }

-
+   else
+#endif /* PNG_USER_MEM_SUPPORTED */
+      struct_ptr = (png_voidp)farmalloc(size));
+   if (struct_ptr != NULL)
+      png_memset(struct_ptr, 0, size);

    return (struct_ptr);
 }
 
    return (struct_ptr);
 }
 

-

 /* Free memory allocated by a png_create_struct() call */
 /* Free memory allocated by a png_create_struct() call */

-void
+void /* PRIVATE */

 png_destroy_struct(png_voidp struct_ptr)
 {
 png_destroy_struct(png_voidp struct_ptr)
 {

+#ifdef PNG_USER_MEM_SUPPORTED
+   png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL);
+}
+
+/* Free memory allocated by a png_create_struct() call */
+void /* PRIVATE */
+png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
+    png_voidp mem_ptr)
+{
+#endif

    if (struct_ptr != NULL)
    {
    if (struct_ptr != NULL)
    {

+#ifdef PNG_USER_MEM_SUPPORTED
+      if(free_fn != NULL)
+      {
+         png_struct dummy_struct;
+         png_structp png_ptr = &dummy_struct;
+         png_ptr->mem_ptr=mem_ptr;
+         (*(free_fn))(png_ptr, struct_ptr);
+         return;
+      }
+#endif /* PNG_USER_MEM_SUPPORTED */

       farfree (struct_ptr);
       farfree (struct_ptr);

-      struct_ptr = NULL;

    }
 }
 
    }
 }
 


@@ -72,7 +98,7 @@ png_destroy_struct(png_voidp struct_ptr)
  * have the ability to do that.
  *
  * Borland seems to have a problem in DOS mode for exactly 64K.
  * have the ability to do that.
  *
  * Borland seems to have a problem in DOS mode for exactly 64K.

- * It gives you a segment with an offset of 8 (perhaps to store it's
+ * It gives you a segment with an offset of 8 (perhaps to store its

  * memory stuff).  zlib doesn't like this at all, so we have to
  * detect and deal with it.  This code should not be needed in
  * Windows or OS/2 modes, and only in 16 bit mode.  This code has
  * memory stuff).  zlib doesn't like this at all, so we have to
  * detect and deal with it.  This code should not be needed in
  * Windows or OS/2 modes, and only in 16 bit mode.  This code has


@@ -84,12 +110,32 @@ png_destroy_struct(png_voidp struct_ptr)
  * result, we would be truncating potentially larger memory requests
  * (which should cause a fatal error) and introducing major problems.
  */
  * result, we would be truncating potentially larger memory requests
  * (which should cause a fatal error) and introducing major problems.
  */

-png_voidp
-PNG_MALLOC(png_structp png_ptr, png_uint_32 size)
+
+png_voidp PNGAPI
+png_malloc(png_structp png_ptr, png_uint_32 size)

 {
    png_voidp ret;
 {
    png_voidp ret;

+

    if (png_ptr == NULL || size == 0)
    if (png_ptr == NULL || size == 0)

-      return ((png_voidp)NULL);
+      return (NULL);
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   if(png_ptr->malloc_fn != NULL)
+   {
+       ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
+       if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+          png_error(png_ptr, "Out of memory!");
+       return (ret);
+   }
+   else
+       return png_malloc_default(png_ptr, size);
+}
+
+png_voidp PNGAPI
+png_malloc_default(png_structp png_ptr, png_uint_32 size)
+{
+   png_voidp ret;
+#endif /* PNG_USER_MEM_SUPPORTED */

 
 #ifdef PNG_MAX_MALLOC_64K
    if (size > (png_uint_32)65536L)
 
 #ifdef PNG_MAX_MALLOC_64K
    if (size > (png_uint_32)65536L)


@@ -116,8 +162,9 @@ PNG_MALLOC(png_structp png_ptr, png_uint_32 size)
                ret = NULL;
             }
 
                ret = NULL;
             }
 

-            num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
-            if (num_blocks < 1)
+            if(png_ptr->zlib_window_bits > 14)
+               num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
+            else

                num_blocks = 1;
             if (png_ptr->zlib_mem_level >= 7)
                num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));
                num_blocks = 1;
             if (png_ptr->zlib_mem_level >= 7)
                num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));


@@ -130,12 +177,22 @@ PNG_MALLOC(png_structp png_ptr, png_uint_32 size)
 
             if (table == NULL)
             {
 
             if (table == NULL)
             {

-               png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */
+               if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+                  png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */
+               else
+                  png_warning(png_ptr, "Out Of Memory.");
+               return (NULL);

             }
 
             if ((png_size_t)table & 0xfff0)
             {
             }
 
             if ((png_size_t)table & 0xfff0)
             {

-               png_error(png_ptr, "Farmalloc didn't return normalized pointer");
+               if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+                  png_error(png_ptr,
+                    "Farmalloc didn't return normalized pointer");
+               else
+                  png_warning(png_ptr,
+                    "Farmalloc didn't return normalized pointer");
+               return (NULL);

             }
 
             png_ptr->offset_table = table;
             }
 
             png_ptr->offset_table = table;


@@ -144,19 +201,23 @@ PNG_MALLOC(png_structp png_ptr, png_uint_32 size)
 
             if (png_ptr->offset_table_ptr == NULL)
             {
 
             if (png_ptr->offset_table_ptr == NULL)
             {

-               png_error(png_ptr, "Out Of memory.");
+               if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+                  png_error(png_ptr, "Out Of memory."); /* Note "O" and "M" */
+               else
+                  png_warning(png_ptr, "Out Of memory.");
+               return (NULL);

             }
 
             hptr = (png_byte huge *)table;
             if ((png_size_t)hptr & 0xf)
             {
                hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
             }
 
             hptr = (png_byte huge *)table;
             if ((png_size_t)hptr & 0xf)
             {
                hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);

-               hptr += 16L;
+               hptr = hptr + 16L;  /* "hptr += 16L" fails on Turbo C++ 3.0 */

             }
             for (i = 0; i < num_blocks; i++)
             {
                png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
             }
             for (i = 0; i < num_blocks; i++)
             {
                png_ptr->offset_table_ptr[i] = (png_bytep)hptr;

-               hptr += (png_uint_32)65536L;
+               hptr = hptr + (png_uint_32)65536L;  /* "+=" fails on TC++3.0 */

             }
 
             png_ptr->offset_table_number = num_blocks;
             }
 
             png_ptr->offset_table_number = num_blocks;


@@ -166,7 +227,13 @@ PNG_MALLOC(png_structp png_ptr, png_uint_32 size)
       }
 
       if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
       }
 
       if (png_ptr->offset_table_count >= png_ptr->offset_table_number)

-         png_error(png_ptr, "Out of Memory.");
+      {
+         if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+            png_error(png_ptr, "Out of Memory."); /* Note "o" and "M" */
+         else
+            png_warning(png_ptr, "Out of Memory.");
+         return (NULL);
+      }

 
       ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
    }
 
       ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
    }


@@ -175,21 +242,38 @@ PNG_MALLOC(png_structp png_ptr, png_uint_32 size)
 
    if (ret == NULL)
    {
 
    if (ret == NULL)
    {

-      png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */
+      if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+         png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */
+      else
+         png_warning(png_ptr, "Out of memory."); /* Note "o" and "m" */

    }
 
    return (ret);
 }
 
    }
 
    return (ret);
 }
 

-/* free a pointer allocated by PNG_MALLOC().  In the default
+/* free a pointer allocated by png_malloc().  In the default

    configuration, png_ptr is not used, but is passed in case it
    is needed.  If ptr is NULL, return without taking any action. */
    configuration, png_ptr is not used, but is passed in case it
    is needed.  If ptr is NULL, return without taking any action. */

-void
-PNG_FREE(png_structp png_ptr, png_voidp ptr)
+void PNGAPI
+png_free(png_structp png_ptr, png_voidp ptr)

 {
    if (png_ptr == NULL || ptr == NULL)
       return;
 
 {
    if (png_ptr == NULL || ptr == NULL)
       return;
 

+#ifdef PNG_USER_MEM_SUPPORTED
+   if (png_ptr->free_fn != NULL)
+   {
+      (*(png_ptr->free_fn))(png_ptr, ptr);
+      return;
+   }
+   else png_free_default(png_ptr, ptr);
+}
+
+void PNGAPI
+png_free_default(png_structp png_ptr, png_voidp ptr)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */
+

    if (png_ptr->offset_table != NULL)
    {
       int i;
    if (png_ptr->offset_table != NULL)
    {
       int i;


@@ -215,7 +299,6 @@ PNG_FREE(png_structp png_ptr, png_voidp ptr)
    if (ptr != NULL)
    {
       farfree(ptr);
    if (ptr != NULL)
    {
       farfree(ptr);

-      ptr = NULL;

    }
 }
 
    }
 }
 


@@ -223,10 +306,21 @@ PNG_FREE(png_structp png_ptr, png_voidp ptr)
 
 /* Allocate memory for a png_struct or a png_info.  The malloc and
    memset can be replaced by a single call to calloc() if this is thought
 
 /* Allocate memory for a png_struct or a png_info.  The malloc and
    memset can be replaced by a single call to calloc() if this is thought

-   to improve performance noticably.*/
-png_voidp
+   to improve performance noticably. */
+png_voidp /* PRIVATE */

 png_create_struct(int type)
 {
 png_create_struct(int type)
 {

+#ifdef PNG_USER_MEM_SUPPORTED
+   return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));
+}
+
+/* Allocate memory for a png_struct or a png_info.  The malloc and
+   memset can be replaced by a single call to calloc() if this is thought
+   to improve performance noticably. */
+png_voidp /* PRIVATE */
+png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */

    png_size_t size;
    png_voidp struct_ptr;
 
    png_size_t size;
    png_voidp struct_ptr;
 


@@ -235,7 +329,20 @@ png_create_struct(int type)
    else if (type == PNG_STRUCT_PNG)
       size = sizeof(png_struct);
    else
    else if (type == PNG_STRUCT_PNG)
       size = sizeof(png_struct);
    else

-      return ((png_voidp)NULL);
+      return (NULL);
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   if(malloc_fn != NULL)
+   {
+      png_struct dummy_struct;
+      png_structp png_ptr = &dummy_struct;
+      png_ptr->mem_ptr=mem_ptr;
+      struct_ptr = (*(malloc_fn))(png_ptr, size);
+      if (struct_ptr != NULL)
+         png_memset(struct_ptr, 0, size);
+      return (struct_ptr);
+   }
+#endif /* PNG_USER_MEM_SUPPORTED */

 
 #if defined(__TURBOC__) && !defined(__FLAT__)
    if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL)
 
 #if defined(__TURBOC__) && !defined(__FLAT__)
    if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL)


@@ -255,11 +362,31 @@ png_create_struct(int type)
 
 
 /* Free memory allocated by a png_create_struct() call */
 
 
 /* Free memory allocated by a png_create_struct() call */

-void
+void /* PRIVATE */

 png_destroy_struct(png_voidp struct_ptr)
 {
 png_destroy_struct(png_voidp struct_ptr)
 {

+#ifdef PNG_USER_MEM_SUPPORTED
+   png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL);
+}
+
+/* Free memory allocated by a png_create_struct() call */
+void /* PRIVATE */
+png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
+    png_voidp mem_ptr)
+{
+#endif /* PNG_USER_MEM_SUPPORTED */

    if (struct_ptr != NULL)
    {
    if (struct_ptr != NULL)
    {

+#ifdef PNG_USER_MEM_SUPPORTED
+      if(free_fn != NULL)
+      {
+         png_struct dummy_struct;
+         png_structp png_ptr = &dummy_struct;
+         png_ptr->mem_ptr=mem_ptr;
+         (*(free_fn))(png_ptr, struct_ptr);
+         return;
+      }
+#endif /* PNG_USER_MEM_SUPPORTED */

 #if defined(__TURBOC__) && !defined(__FLAT__)
       farfree(struct_ptr);
 #else
 #if defined(__TURBOC__) && !defined(__FLAT__)
       farfree(struct_ptr);
 #else


@@ -272,24 +399,46 @@ png_destroy_struct(png_voidp struct_ptr)
    }
 }
 
    }
 }
 

-

 /* Allocate memory.  For reasonable files, size should never exceed
    64K.  However, zlib may allocate more then 64K if you don't tell
    it not to.  See zconf.h and png.h for more information.  zlib does
    need to allocate exactly 64K, so whatever you call here must
    have the ability to do that. */
 
 /* Allocate memory.  For reasonable files, size should never exceed
    64K.  However, zlib may allocate more then 64K if you don't tell
    it not to.  See zconf.h and png.h for more information.  zlib does
    need to allocate exactly 64K, so whatever you call here must
    have the ability to do that. */
 

-png_voidp
-PNG_MALLOC(png_structp png_ptr, png_uint_32 size)
+png_voidp PNGAPI
+png_malloc(png_structp png_ptr, png_uint_32 size)

 {
    png_voidp ret;
 
    if (png_ptr == NULL || size == 0)
 {
    png_voidp ret;
 
    if (png_ptr == NULL || size == 0)

-      return ((png_voidp)NULL);
+      return (NULL);
+
+#ifdef PNG_USER_MEM_SUPPORTED
+   if(png_ptr->malloc_fn != NULL)
+   {
+       ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
+       if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+          png_error(png_ptr, "Out of Memory!");
+       return (ret);
+   }
+   else
+       return (png_malloc_default(png_ptr, size));
+}
+
+png_voidp PNGAPI
+png_malloc_default(png_structp png_ptr, png_uint_32 size)
+{
+   png_voidp ret;
+#endif /* PNG_USER_MEM_SUPPORTED */

 
 #ifdef PNG_MAX_MALLOC_64K
    if (size > (png_uint_32)65536L)
 
 #ifdef PNG_MAX_MALLOC_64K
    if (size > (png_uint_32)65536L)

-      png_error(png_ptr, "Cannot Allocate > 64K");
+   {
+      if(png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+         png_error(png_ptr, "Cannot Allocate > 64K");
+      else
+         return NULL;
+   }

 #endif
 
 #if defined(__TURBOC__) && !defined(__FLAT__)
 #endif
 
 #if defined(__TURBOC__) && !defined(__FLAT__)


@@ -302,23 +451,36 @@ PNG_MALLOC(png_structp png_ptr, png_uint_32 size)
 # endif
 #endif
 
 # endif
 #endif
 

-   if (ret == NULL)
-   {
+   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

       png_error(png_ptr, "Out of Memory");
       png_error(png_ptr, "Out of Memory");

-   }

 
    return (ret);
 }
 
 
    return (ret);
 }
 

-/* Free a pointer allocated by PNG_MALLOC().  In the default
-  configuration, png_ptr is not used, but is passed in case it
-  is needed.  If ptr is NULL, return without taking any action. */
-void
-PNG_FREE(png_structp png_ptr, png_voidp ptr)
+/* Free a pointer allocated by png_malloc().  If ptr is NULL, return
+   without taking any action. */
+void PNGAPI
+png_free(png_structp png_ptr, png_voidp ptr)

 {
    if (png_ptr == NULL || ptr == NULL)
       return;
 
 {
    if (png_ptr == NULL || ptr == NULL)
       return;
 

+#ifdef PNG_USER_MEM_SUPPORTED
+   if (png_ptr->free_fn != NULL)
+   {
+      (*(png_ptr->free_fn))(png_ptr, ptr);
+      return;
+   }
+   else png_free_default(png_ptr, ptr);
+}
+void PNGAPI
+png_free_default(png_structp png_ptr, png_voidp ptr)
+{
+   if (png_ptr == NULL || ptr == NULL)
+      return;
+
+#endif /* PNG_USER_MEM_SUPPORTED */
+

 #if defined(__TURBOC__) && !defined(__FLAT__)
    farfree(ptr);
 #else
 #if defined(__TURBOC__) && !defined(__FLAT__)
    farfree(ptr);
 #else


@@ -332,7 +494,27 @@ PNG_FREE(png_structp png_ptr, png_voidp ptr)
 
 #endif /* Not Borland DOS special memory handler */
 
 
 #endif /* Not Borland DOS special memory handler */
 

-png_voidp
+#if defined(PNG_1_0_X)
+#  define png_malloc_warn png_malloc
+#else
+/* This function was added at libpng version 1.2.3.  The png_malloc_warn()
+ * function will issue a png_warning and return NULL instead of issuing a
+ * png_error, if it fails to allocate the requested memory.
+ */
+png_voidp PNGAPI
+png_malloc_warn(png_structp png_ptr, png_uint_32 size)
+{
+   png_voidp ptr;
+   png_uint_32 save_flags=png_ptr->flags;
+
+   png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
+   ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);
+   png_ptr->flags=save_flags;
+   return(ptr);
+}
+#endif
+
+png_voidp PNGAPI

 png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2,
    png_uint_32 length)
 {
 png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2,
    png_uint_32 length)
 {


@@ -341,11 +523,11 @@ png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2,
    size = (png_size_t)length;
    if ((png_uint_32)size != length)
       png_error(png_ptr,"Overflow in png_memcpy_check.");
    size = (png_size_t)length;
    if ((png_uint_32)size != length)
       png_error(png_ptr,"Overflow in png_memcpy_check.");

-  
+

    return(png_memcpy (s1, s2, size));
 }
 
    return(png_memcpy (s1, s2, size));
 }
 

-png_voidp
+png_voidp PNGAPI

 png_memset_check (png_structp png_ptr, png_voidp s1, int value,
    png_uint_32 length)
 {
 png_memset_check (png_structp png_ptr, png_voidp s1, int value,
    png_uint_32 length)
 {


@@ -358,3 +540,27 @@ png_memset_check (png_structp png_ptr, png_voidp s1, int value,
    return (png_memset (s1, value, size));
 
 }
    return (png_memset (s1, value, size));
 
 }

+
+#ifdef PNG_USER_MEM_SUPPORTED
+/* This function is called when the application wants to use another method
+ * of allocating and freeing memory.
+ */
+void PNGAPI
+png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
+  malloc_fn, png_free_ptr free_fn)
+{
+   png_ptr->mem_ptr = mem_ptr;
+   png_ptr->malloc_fn = malloc_fn;
+   png_ptr->free_fn = free_fn;
+}
+
+/* This function returns a pointer to the mem_ptr associated with the user
+ * functions.  The application should free any memory associated with this
+ * pointer before png_write_destroy and png_read_destroy are called.
+ */
+png_voidp PNGAPI
+png_get_mem_ptr(png_structp png_ptr)
+{
+   return ((png_voidp)png_ptr->mem_ptr);
+}
+#endif /* PNG_USER_MEM_SUPPORTED */