Imported from libpng-0.87.tar
diff --git a/pngmem.c b/pngmem.c index c7bc5d4..83b8528 100644 --- a/pngmem.c +++ b/pngmem.c
@@ -1,41 +1,199 @@ /* pngmem.c - stub functions for memory allocation - libpng 1.0 beta 2 - version 0.86 + libpng 1.0 beta 2 - version 0.87 For conditions of distribution and use, see copyright notice in png.h Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc. - January 10, 1996 + January 15, 1996 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. */ + to meet their needs. See the instructions at each function. */ #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 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. */ + 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 it's + 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. +*/ + +png_voidp +png_large_malloc(png_structp png_ptr, png_uint_32 size) +{ + png_voidp ret; + if (!png_ptr || !size) + return ((voidp)0); + +#ifdef PNG_MAX_MALLOC_64K + if (size > (png_uint_32)65536L) + png_error(png_ptr, "Cannot Allocate > 64K"); +#endif + + if (size == (png_uint_32)(65536L)) + { + if (!png_ptr->offset_table) + { + /* try to see if we need to do any of this fancy stuff */ + ret = farmalloc(size); + if (!ret || ((long)ret & 0xffff)) + { + int num_blocks; + png_uint_32 total_size; + png_bytep table; + int i; + png_byte huge * hptr; + + if (ret) + farfree(ret); + ret = 0; + + num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14)); + if (num_blocks < 1) + 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; + + table = farmalloc(total_size); + + if (!table) + { + png_error(png_ptr, "Out of Memory"); + } + + if ((long)table & 0xffff) + { + farfree(table); + total_size += (png_uint_32)65536L; + } + + table = farmalloc(total_size); + + if (!table) + { + png_error(png_ptr, "Out of Memory"); + } + + png_ptr->offset_table = table; + png_ptr->offset_table_ptr = farmalloc( + num_blocks * sizeof (png_bytep)); + hptr = (png_byte huge *)table; + if ((long)hptr & 0xffff) + { + hptr = (png_byte huge *)((long)(hptr) & 0xffff0000L); + hptr += 65536L; + } + for (i = 0; i < num_blocks; i++) + { + png_ptr->offset_table_ptr[i] = (png_bytep)hptr; + hptr += 65536L; + } + + 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) + png_error(png_ptr, "Out of Memory"); + + ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++]; + } + } + else + ret = farmalloc(size); + + if (ret == NULL) + { + png_error(png_ptr, "Out of Memory"); + } + + return ret; +} + +/* free a pointer allocated by png_large_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_large_free(png_structp png_ptr, png_voidp ptr) +{ + if (!png_ptr) + return; + + if (ptr != NULL) + { + if (png_ptr->offset_table) + { + int i; + + for (i = 0; i < png_ptr->offset_table_count; i++) + { + if (ptr == png_ptr->offset_table_ptr[i]) + { + ptr = 0; + png_ptr->offset_table_count_free++; + break; + } + } + if (png_ptr->offset_table_count_free == png_ptr->offset_table_count) + { + farfree(png_ptr->offset_table); + farfree(png_ptr->offset_table_ptr); + png_ptr->offset_table = 0; + png_ptr->offset_table_ptr = 0; + } + } + + if (ptr) + farfree(ptr); + } +} + +#else /* Not the Borland DOS special memory handler */ + +/* 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_large_malloc(png_structp png_ptr, png_uint_32 size) { - png_voidp ret; - if (!png_ptr || !size) + png_voidp ret; + if (!png_ptr || !size) return ((voidp)0); #ifdef PNG_MAX_MALLOC_64K - if (size > (png_uint_32)65536L) - png_error(png_ptr, "Cannot Allocate > 64K"); + if (size > (png_uint_32)65536L) + png_error(png_ptr, "Cannot Allocate > 64K"); #endif #if defined(__TURBOC__) && !defined(__FLAT__) ret = farmalloc(size); #else +# if defined(_MSC_VER) && defined(MAXSEG_64K) + ret = halloc(size, 1); +# else ret = malloc(size); +# endif #endif if (ret == NULL) @@ -43,7 +201,7 @@ png_error(png_ptr, "Out of Memory"); } - return ret; + return ret; } /* free a pointer allocated by png_large_malloc(). In the default @@ -60,15 +218,22 @@ #if defined(__TURBOC__) && !defined(__FLAT__) farfree(ptr); #else +# if defined(_MSC_VER) && defined(MAXSEG_64K) + hfree(ptr); +# else free(ptr); +# endif #endif - } + } } +#endif /* Not Borland DOS special memory handler */ /* Allocate memory. This is called for smallish blocks only It should not get anywhere near 64K. On segmented machines, this - must come from the local heap (for zlib). */ + must come from the local heap (for zlib). Currently, zlib is + the only one that uses this, so you should only get one call + to this, and that a small block. */ void * png_malloc(png_structp png_ptr, png_uint_32 size) { @@ -96,7 +261,8 @@ } /* Reallocate memory. This will not get near 64K on a - even marginally reasonable file. */ + even marginally reasonable file. This is not used in + the current version of the library. */ void * png_realloc(png_structp png_ptr, void * ptr, png_uint_32 size, png_uint_32 old_size)