This repository has been archived on 2023-11-11. You can view files and clone it, but cannot push or open issues or pull requests.
libpng/pngmem.c

386 lines
9.5 KiB
C
Raw Normal View History

1995-07-20 07:43:20 +00:00
1995-11-28 17:22:13 +00:00
/* pngmem.c - stub functions for memory allocation
1995-07-20 07:43:20 +00:00
1996-06-05 20:50:50 +00:00
libpng 1.0 beta 3 - version 0.89
1995-07-20 07:43:20 +00:00
For conditions of distribution and use, see copyright notice in png.h
1996-01-26 07:38:47 +00:00
Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
1996-06-05 20:50:50 +00:00
May 25, 1996
1995-07-20 07:43:20 +00:00
1995-09-26 10:22:39 +00:00
This file provides a location for all memory allocation. Users which
1996-01-26 07:38:47 +00:00
need special memory handling are expected to modify the code in this file
to meet their needs. See the instructions at each function. */
1995-07-20 07:43:20 +00:00
#define PNG_INTERNAL
#include "png.h"
1996-01-16 07:51:56 +00:00
/* 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 */
1996-06-05 20:50:50 +00:00
/* 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_create_struct(uInt type)
{
png_size_t type;
png_voidp struct_ptr;
if (type == PNG_STRUCT_INFO)
size = sizeof(png_info);
else if (type == PNG_STRUCT_PNG)
size = sizeof(png_struct);
else
return (png_voidp)NULL;
if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL)
{
png_memset(struct_ptr, 0, size);
}
return (struct_ptr);
}
/* Free memory allocated by a png_create_struct() call */
void
png_destroy_struct(png_voidp struct_ptr)
{
if (struct_ptr)
farfree (struct_ptr);
}
1995-07-20 07:43:20 +00:00
/* Allocate memory. For reasonable files, size should never exceed
1996-01-26 07:38:47 +00:00
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. */
1995-07-20 07:43:20 +00:00
1996-01-16 07:51:56 +00:00
/* Borland seems to have a problem in DOS mode for exactly 64K.
1996-01-26 07:38:47 +00:00
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
1996-06-05 20:50:50 +00:00
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.
1996-01-16 07:51:56 +00:00
*/
1995-07-20 07:43:20 +00:00
1995-12-19 09:22:19 +00:00
png_voidp
png_large_malloc(png_structp png_ptr, png_uint_32 size)
1995-07-20 07:43:20 +00:00
{
1996-01-26 07:38:47 +00:00
png_voidp ret;
if (!png_ptr || !size)
1996-06-05 20:50:50 +00:00
return ((voidp)NULL);
1995-07-20 07:43:20 +00:00
#ifdef PNG_MAX_MALLOC_64K
1996-01-26 07:38:47 +00:00
if (size > (png_uint_32)65536L)
png_error(png_ptr, "Cannot Allocate > 64K");
1996-01-16 07:51:56 +00:00
#endif
1996-01-26 07:38:47 +00:00
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;
1996-01-16 07:51:56 +00:00
png_byte huge * hptr;
1996-01-26 07:38:47 +00:00
if (ret)
farfree(ret);
1996-06-05 20:50:50 +00:00
ret = NULL;
1996-01-26 07:38:47 +00:00
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++;
1996-06-05 20:50:50 +00:00
total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;
1996-01-26 07:38:47 +00:00
table = farmalloc(total_size);
if (!table)
{
png_error(png_ptr, "Out of Memory");
}
1996-06-05 20:50:50 +00:00
if ((long)table & 0xfff0)
1996-01-26 07:38:47 +00:00
{
1996-06-05 20:50:50 +00:00
png_error(png_ptr, "Farmalloc didn't return normalized pointer");
1996-01-26 07:38:47 +00:00
}
1996-06-05 20:50:50 +00:00
png_ptr->offset_table = table;
png_ptr->offset_table_ptr = farmalloc(
num_blocks * sizeof (png_bytep));
1996-01-26 07:38:47 +00:00
1996-06-05 20:50:50 +00:00
if (!png_ptr->offset_table_ptr)
1996-01-26 07:38:47 +00:00
{
1996-06-05 20:50:50 +00:00
png_error(png_ptr, "Out of memory");
1996-01-26 07:38:47 +00:00
}
hptr = (png_byte huge *)table;
1996-06-05 20:50:50 +00:00
if ((long)hptr & 0xf)
1996-01-26 07:38:47 +00:00
{
1996-06-05 20:50:50 +00:00
hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
hptr += 16L;
1996-01-26 07:38:47 +00:00
}
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;
}
1996-06-05 20:50:50 +00:00
}
1996-01-26 07:38:47 +00:00
1996-06-05 20:50:50 +00:00
if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
png_error(png_ptr, "Out of Memory");
1996-01-16 07:51:56 +00:00
1996-06-05 20:50:50 +00:00
ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
1996-01-26 07:38:47 +00:00
}
else
ret = farmalloc(size);
1996-01-16 07:51:56 +00:00
1996-01-26 07:38:47 +00:00
if (ret == NULL)
{
png_error(png_ptr, "Out of Memory");
}
1996-01-16 07:51:56 +00:00
1996-01-26 07:38:47 +00:00
return ret;
1996-01-16 07:51:56 +00:00
}
/* 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)
{
1996-01-26 07:38:47 +00:00
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])
1996-01-16 07:51:56 +00:00
{
1996-01-26 07:38:47 +00:00
ptr = 0;
1996-01-16 07:51:56 +00:00
png_ptr->offset_table_count_free++;
1996-01-26 07:38:47 +00:00
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;
1996-01-16 07:51:56 +00:00
}
1996-01-26 07:38:47 +00:00
}
1996-01-16 07:51:56 +00:00
1996-01-26 07:38:47 +00:00
if (ptr)
farfree(ptr);
}
1996-01-16 07:51:56 +00:00
}
#else /* Not the Borland DOS special memory handler */
1996-06-05 20:50:50 +00:00
/* 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
png_create_struct(uInt type)
{
size_t size;
png_voidp struct_ptr;
if (type == PNG_STRUCT_INFO)
size = sizeof(png_info);
else if (type == PNG_STRUCT_PNG)
size = sizeof(png_struct);
else
return (png_voidp)NULL;
#if defined(__TURBOC__) && !defined(__FLAT__)
if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL)
#else
# if defined(_MSC_VER) && defined(MAXSEG_64K)
if ((struct_ptr = (png_voidp)halloc(size)) != NULL)
# else
if ((struct_ptr = (png_voidp)malloc(size)) != NULL)
# endif
#endif
{
png_memset(struct_ptr, 0, size);
}
return (struct_ptr);
}
/* Free memory allocated by a png_create_struct() call */
void
png_destroy_struct(png_voidp struct_ptr)
{
if (struct_ptr)
#if defined(__TURBOC__) && !defined(__FLAT__)
farfree(struct_ptr);
#else
# if defined(_MSC_VER) && defined(MAXSEG_64K)
hfree(struct_ptr);
# else
free(struct_ptr);
# endif
#endif
}
1996-01-16 07:51:56 +00:00
/* Allocate memory. For reasonable files, size should never exceed
1996-01-26 07:38:47 +00:00
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. */
1996-01-16 07:51:56 +00:00
png_voidp
png_large_malloc(png_structp png_ptr, png_uint_32 size)
{
1996-01-26 07:38:47 +00:00
png_voidp ret;
if (!png_ptr || !size)
return ((voidp)0);
1996-01-16 07:51:56 +00:00
#ifdef PNG_MAX_MALLOC_64K
1996-01-26 07:38:47 +00:00
if (size > (png_uint_32)65536L)
png_error(png_ptr, "Cannot Allocate > 64K");
1995-07-20 07:43:20 +00:00
#endif
1995-12-19 09:22:19 +00:00
#if defined(__TURBOC__) && !defined(__FLAT__)
1996-01-26 07:38:47 +00:00
ret = farmalloc(size);
1995-12-19 09:22:19 +00:00
#else
1996-01-16 07:51:56 +00:00
# if defined(_MSC_VER) && defined(MAXSEG_64K)
1996-01-26 07:38:47 +00:00
ret = halloc(size, 1);
1996-01-16 07:51:56 +00:00
# else
1996-01-26 07:38:47 +00:00
ret = malloc(size);
1996-01-16 07:51:56 +00:00
# endif
1995-07-20 07:43:20 +00:00
#endif
1995-09-26 10:22:39 +00:00
if (ret == NULL)
1995-07-20 07:43:20 +00:00
{
1995-12-19 09:22:19 +00:00
png_error(png_ptr, "Out of Memory");
1995-07-20 07:43:20 +00:00
}
1996-01-26 07:38:47 +00:00
return ret;
1995-07-20 07:43:20 +00:00
}
/* 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
1995-12-19 09:22:19 +00:00
png_large_free(png_structp png_ptr, png_voidp ptr)
1995-07-20 07:43:20 +00:00
{
if (!png_ptr)
1996-01-26 07:38:47 +00:00
return;
1995-07-20 07:43:20 +00:00
1995-12-19 09:22:19 +00:00
if (ptr != NULL)
1995-07-20 07:43:20 +00:00
{
1995-12-19 09:22:19 +00:00
#if defined(__TURBOC__) && !defined(__FLAT__)
1996-01-26 07:38:47 +00:00
farfree(ptr);
1995-07-20 07:43:20 +00:00
#else
1996-01-16 07:51:56 +00:00
# if defined(_MSC_VER) && defined(MAXSEG_64K)
1996-01-26 07:38:47 +00:00
hfree(ptr);
1996-01-16 07:51:56 +00:00
# else
1996-01-26 07:38:47 +00:00
free(ptr);
1996-01-16 07:51:56 +00:00
# endif
1995-07-20 07:43:20 +00:00
#endif
1996-01-26 07:38:47 +00:00
}
1995-07-20 07:43:20 +00:00
}
1996-01-16 07:51:56 +00:00
#endif /* Not Borland DOS special memory handler */
1995-12-19 09:22:19 +00:00
1995-07-20 07:43:20 +00:00
/* Allocate memory. This is called for smallish blocks only It
1996-01-26 07:38:47 +00:00
should not get anywhere near 64K. On segmented machines, this
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. */
1995-07-20 07:43:20 +00:00
void *
1995-12-19 09:22:19 +00:00
png_malloc(png_structp png_ptr, png_uint_32 size)
1995-07-20 07:43:20 +00:00
{
void *ret;
1995-09-26 10:22:39 +00:00
if (!png_ptr || !size)
1995-12-19 09:22:19 +00:00
{
1995-07-20 07:43:20 +00:00
return ((void *)0);
1995-12-19 09:22:19 +00:00
}
1995-07-20 07:43:20 +00:00
#ifdef PNG_MAX_MALLOC_64K
if (size > (png_uint_32)65536L)
1995-12-19 09:22:19 +00:00
png_error(png_ptr, "Cannot Allocate > 64K");
1995-07-20 07:43:20 +00:00
#endif
1995-12-19 09:22:19 +00:00
1995-07-20 07:43:20 +00:00
ret = malloc((png_size_t)size);
1996-01-26 07:38:47 +00:00
if (!ret)
1995-07-20 07:43:20 +00:00
{
1996-01-26 07:38:47 +00:00
png_error(png_ptr, "Out of Memory");
1995-07-20 07:43:20 +00:00
}
return ret;
}
/* Reallocate memory. This will not get near 64K on a
1996-01-26 07:38:47 +00:00
even marginally reasonable file. This is not used in
the current version of the library. */
1995-07-20 07:43:20 +00:00
void *
1995-12-19 09:22:19 +00:00
png_realloc(png_structp png_ptr, void * ptr, png_uint_32 size,
1996-01-26 07:38:47 +00:00
png_uint_32 old_size)
1995-07-20 07:43:20 +00:00
{
1996-01-26 07:38:47 +00:00
void *ret;
1995-07-20 07:43:20 +00:00
1996-01-26 07:38:47 +00:00
if (!png_ptr || !old_size || !ptr || !size)
return ((void *)0);
1995-07-20 07:43:20 +00:00
#ifdef PNG_MAX_MALLOC_64K
1996-01-26 07:38:47 +00:00
if (size > (png_uint_32)65536L)
png_error(png_ptr, "Cannot Allocate > 64K");
1995-07-20 07:43:20 +00:00
#endif
1996-01-26 07:38:47 +00:00
ret = realloc(ptr, (png_size_t)size);
1995-07-20 07:43:20 +00:00
1996-01-26 07:38:47 +00:00
if (!ret)
{
png_error(png_ptr, "Out of Memory 7");
}
1995-07-20 07:43:20 +00:00
1996-01-26 07:38:47 +00:00
return ret;
1995-07-20 07:43:20 +00:00
}
/* free a pointer allocated by png_malloc(). In the default
configuration, png_ptr is not used, but is passed incase it
is needed. If ptr is NULL, return without taking any action. */
void
1995-12-19 09:22:19 +00:00
png_free(png_structp png_ptr, void * ptr)
1995-07-20 07:43:20 +00:00
{
1996-01-26 07:38:47 +00:00
if (!png_ptr)
return;
1995-07-20 07:43:20 +00:00
1996-01-26 07:38:47 +00:00
if (ptr != (void *)0)
free(ptr);
1995-07-20 07:43:20 +00:00
}