/* pngmem.c - stub functions for memory allocation * * libpng version 1.2.8 - December 3, 2004 * For conditions of distribution and use, see copyright notice in png.h * Copyright (c) 1998-2004 Glenn Randers-Pehrson * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * * This file provides a location for all memory allocation.  Users who * need special memory handling are expected to supply replacement * functions for png_malloc() and png_free(), and to use * png_create_read_struct_2() and png_create_write_struct_2() to * identify the replacement functions. */#define PNG_INTERNAL#include "png.h"/* Borland DOS special memory handler */#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)/* if you change this, be sure to change the one in png.h also *//* Allocate memory for a png_struct.  The malloc and memset can be replaced   by a single call to calloc() if this is thought to improve performance. */png_voidp /* PRIVATE */png_create_struct(int type){#ifdef PNG_USER_MEM_SUPPORTED   return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));}/* Alternate version of png_create_struct, for use with user-defined malloc. */png_voidp /* PRIVATE */png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr){#endif /* PNG_USER_MEM_SUPPORTED */   png_size_t size;   png_voidp struct_ptr;   if (type == PNG_STRUCT_INFO)     size = png_sizeof(png_info);   else if (type == PNG_STRUCT_PNG)     size = png_sizeof(png_struct);   else     return (png_get_copyright(NULL));#ifdef PNG_USER_MEM_SUPPORTED   if(malloc_fn != NULL)   {      png_struct dummy_struct;      png_structp png_ptr = &dummy_struct;      png_ptr->mem_ptr=mem_ptr;      struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size);   }   else#endif /* PNG_USER_MEM_SUPPORTED */      struct_ptr = (png_voidp)farmalloc(size);   if (struct_ptr != NULL)      png_memset(struct_ptr, 0, size);   return (struct_ptr);}/* Free memory allocated by a png_create_struct() call */void /* PRIVATE */png_destroy_struct(png_voidp struct_ptr){#ifdef PNG_USER_MEM_SUPPORTED   png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL);}/* Free memory allocated by a png_create_struct() call */void /* PRIVATE */png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,    png_voidp mem_ptr){#endif   if (struct_ptr != NULL)   {#ifdef PNG_USER_MEM_SUPPORTED      if(free_fn != NULL)      {         png_struct dummy_struct;         png_structp png_ptr = &dummy_struct;         png_ptr->mem_ptr=mem_ptr;         (*(free_fn))(png_ptr, struct_ptr);         return;      }#endif /* PNG_USER_MEM_SUPPORTED */      farfree (struct_ptr);   }}/* Allocate memory.  For reasonable files, size should never exceed * 64K.  However, zlib may allocate more then 64K if you don't tell * it not to.  See zconf.h and png.h for more information. zlib does * need to allocate exactly 64K, so whatever you call here must * have the ability to do that. * * Borland seems to have a problem in DOS mode for exactly 64K. * It gives you a segment with an offset of 8 (perhaps to store its * memory stuff).  zlib doesn't like this at all, so we have to * detect and deal with it.  This code should not be needed in * Windows or OS/2 modes, and only in 16 bit mode.  This code has * been updated by Alexander Lehmann for version 0.89 to waste less * memory. * * Note that we can't use png_size_t for the "size" declaration, * since on some systems a png_size_t is a 16-bit quantity, and as a * result, we would be truncating potentially larger memory requests * (which should cause a fatal error) and introducing major problems. */png_voidp PNGAPIpng_malloc(png_structp png_ptr, png_uint_32 size){   png_voidp ret;   if (png_ptr == NULL || size == 0)      return (NULL);#ifdef PNG_USER_MEM_SUPPORTED   if(png_ptr->malloc_fn != NULL)       ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));   else       ret = (png_malloc_default(png_ptr, size));   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)       png_error(png_ptr, "Out of memory!");   return (ret);}png_voidp PNGAPIpng_malloc_default(png_structp png_ptr, png_uint_32 size){   png_voidp ret;#endif /* PNG_USER_MEM_SUPPORTED */#ifdef PNG_MAX_MALLOC_64K   if (size > (png_uint_32)65536L)   {      png_warning(png_ptr, "Cannot Allocate > 64K");      ret = NULL;   }   else#endif   if (size != (size_t)size)     ret = NULL;   else if (size == (png_uint_32)65536L)   {      if (png_ptr->offset_table == NULL)      {         /* try to see if we need to do any of this fancy stuff */         ret = farmalloc(size);         if (ret == NULL || ((png_size_t)ret & 0xffff))         {            int num_blocks;            png_uint_32 total_size;            png_bytep table;            int i;            png_byte huge * hptr;            if (ret != NULL)            {               farfree(ret);               ret = NULL;            }            if(png_ptr->zlib_window_bits > 14)               num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));            else               num_blocks = 1;            if (png_ptr->zlib_mem_level >= 7)               num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));            else               num_blocks++;            total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;            table = farmalloc(total_size);            if (table == NULL)            {#ifndef PNG_USER_MEM_SUPPORTED               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)                  png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */               else                  png_warning(png_ptr, "Out Of Memory.");#endif               return (NULL);            }            if ((png_size_t)table & 0xfff0)            {#ifndef PNG_USER_MEM_SUPPORTED               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)                  png_error(png_ptr,                    "Farmalloc didn't return normalized pointer");               else                  png_warning(png_ptr,                    "Farmalloc didn't return normalized pointer");#endif               return (NULL);            }            png_ptr->offset_table = table;            png_ptr->offset_table_ptr = farmalloc(num_blocks *               png_sizeof (png_bytep));            if (png_ptr->offset_table_ptr == NULL)            {#ifndef PNG_USER_MEM_SUPPORTED               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)                  png_error(png_ptr, "Out Of memory."); /* Note "O" and "M" */               else                  png_warning(png_ptr, "Out Of memory.");#endif               return (NULL);            }            hptr = (png_byte huge *)table;            if ((png_size_t)hptr & 0xf)            {               hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);               hptr = hptr + 16L;  /* "hptr += 16L" fails on Turbo C++ 3.0 */            }            for (i = 0; i < num_blocks; i++)            {               png_ptr->offset_table_ptr[i] = (png_bytep)hptr;               hptr = hptr + (png_uint_32)65536L;  /* "+=" fails on TC++3.0 */            }            png_ptr->offset_table_number = num_blocks;            png_ptr->offset_table_count = 0;            png_ptr->offset_table_count_free = 0;         }      }      if (png_ptr->offset_table_count >= png_ptr->offset_table_number)      {#ifndef PNG_USER_MEM_SUPPORTED         if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)            png_error(png_ptr, "Out of Memory."); /* Note "o" and "M" */         else            png_warning(png_ptr, "Out of Memory.");#endif         return (NULL);      }      ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];   }   else      ret = farmalloc(size);#ifndef PNG_USER_MEM_SUPPORTED   if (ret == NULL)   {      if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)         png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */      else         png_warning(png_ptr, "Out of memory."); /* Note "o" and "m" */   }#endif   return (ret);}/* free a pointer allocated by png_malloc().  In the default   configuration, png_ptr is not used, but is passed in case it   is needed.  If ptr is NULL, return without taking any action. */void PNGAPIpng_free(png_structp png_ptr, png_voidp ptr){   if (png_ptr == NULL || ptr == NULL)      return;#ifdef PNG_USER_MEM_SUPPORTED   if (png_ptr->free_fn != NULL)   {      (*(png_ptr->free_fn))(png_ptr, ptr);      return;   }   else png_free_default(png_ptr, ptr);}void PNGAPIpng_free_default(png_structp png_ptr, png_voidp ptr){#endif /* PNG_USER_MEM_SUPPORTED */   if (png_ptr->offset_table != NULL)   {      int i;      for (i = 0; i < png_ptr->offset_table_count; i++)      {         if (ptr == png_ptr->offset_table_ptr[i])         {