mewin/libpng
1
0
Fork 0
mirror of https://git.code.sf.net/p/libpng/code.git synced 2025-07-10 18:04:09 +02:00
Code Issues Projects Releases Wiki Activity

Imported from libpng-0.85.tar

Browse Source
This commit is contained in:
Guy Schalnat
1995-12-19 03:22:19 -06:00
committed by Glenn Randers-Pehrson
parent 0f71645dfe
commit 6d76471acd
24 changed files with 3505 additions and 2324 deletions
Download Patch File Download Diff File Expand all files Collapse all files

274
pngmem.c
View File

@@ -1,13 +1,13 @@
/* pngmem.c - stub functions for memory allocation
libpng 1.0 beta 2 - version 0.81
libpng 1.0 beta 2 - version 0.85
For conditions of distribution and use, see copyright notice in png.h
Copyright (c) 1995 Guy Eric Schalnat, Group 42, Inc.
August 24, 1995
December 19, 1995
This file provides a location for all memory allocation. Users which
need special memory handling are expected to modify the code in this file
need special memory handling are expected to modify the code in this file
to meet their needs. See the instructions at each function. */
#define PNG_INTERNAL
@@ -19,168 +19,28 @@
need to allocate exactly 64K, so whatever you call here must
have the ability to do that. */
/* Borland compilers have this habit of not giving you 64K chunks
that start on the segment in DOS mode. This has not been observed
in Windows, and of course it doesn't matter in 32 bit mode, as there
are no segments. Now libpng doesn't need that much memory normally,
but zlib does, so we have to normalize it, if necessary. It would be
better if zlib worked in less then 64K, but it doesn't, so we
have to deal with it. Truely, we are misusing farmalloc here,
as it is designed for use with huge pointers, which don't care
about segments. So we allocate a large amount of memory, and
divvy off segments when needed.
*/
#ifdef __TURBOC__
#ifndef __WIN32__
#ifndef __FLAT__
/* NUM_SEG is the number of segments allocated at once */
#define NUM_SEG 4
typedef struct borland_seg_struct
png_voidp
png_large_malloc(png_structp png_ptr, png_uint_32 size)
{
void *mem_ptr;
void *seg_ptr[NUM_SEG];
int seg_used[NUM_SEG];
int num_used;
} borland_seg;
borland_seg *save_array;
int num_save_array;
int max_save_array;
#endif
#endif
#endif
voidpf
png_large_malloc(png_structf *png_ptr, png_uint_32 size)
{
voidpf ret;
png_voidp ret;
if (!png_ptr || !size)
return ((void *)0);
return ((voidp)0);
#ifdef PNG_MAX_MALLOC_64K
if (size > (png_uint_32)65536L)
(*(png_ptr->error_fn))(png_ptr, "Cannot Allocate > 64K");
png_error(png_ptr, "Cannot Allocate > 64K");
#endif
#ifdef __TURBOC__
# if defined(__WIN32__) || defined(__FLAT__)
ret = malloc(size);
# else
if (size == 65536L)
{
unsigned long offset;
if (!save_array)
{
ret = farmalloc(size);
offset = (unsigned long)(ret);
offset &= 0xffffL;
}
else
{
ret = (void *)0;
}
if (save_array || offset)
{
int i, j;
if (ret)
farfree(ret);
ret = (void *)0;
if (!save_array)
{
unsigned long offset;
png_byte huge *ptr;
int i;
num_save_array = 1;
save_array = malloc(num_save_array * sizeof (borland_seg));
if (!save_array)
(*(png_ptr->error_fn))(png_ptr, "Out of Memory 1");
save_array->mem_ptr = farmalloc(
(unsigned long)(NUM_SEG) * 65536L + 65532L);
if (!save_array->mem_ptr)
(*(png_ptr->error_fn))(png_ptr, "Out of Memory 2");
offset = (unsigned long)(ret);
offset &= 0xffffL;
ptr = save_array->mem_ptr;
if (offset)
ptr += 65536L - offset;
for (i = 0; i < NUM_SEG; i++, ptr += 65536L)
{
save_array->seg_ptr[i] = ptr;
save_array->seg_used[i] = 0;
}
save_array->num_used = 0;
}
for (i = 0; i < num_save_array; i++)
{
for (j = 0; j < NUM_SEG; j++)
{
if (!save_array[i].seg_used[j])
{
ret = save_array[i].seg_ptr[j];
save_array[i].seg_used[j] = 1;
save_array[i].num_used++;
break;
}
}
if (ret)
break;
}
if (!ret)
{
unsigned long offset;
png_byte huge *ptr;
save_array = realloc(save_array,
(num_save_array + 1) * sizeof (borland_seg));
if (!save_array)
(*(png_ptr->error_fn))(png_ptr, "Out of Memory 3");
save_array[num_save_array].mem_ptr = farmalloc(
(unsigned long)(NUM_SEG) * 65536L + 65532L);
if (!save_array[num_save_array].mem_ptr)
(*(png_ptr->error_fn))(png_ptr, "Out of Memory 4");
offset = (unsigned long)(ret);
offset &= 0xffffL;
ptr = save_array[num_save_array].mem_ptr;
if (offset)
ptr += 65536L - offset;
for (i = 0; i < NUM_SEG; i++, ptr += 65536L)
{
save_array[num_save_array].seg_ptr[i] = ptr;
save_array[num_save_array].seg_used[i] = 0;
}
ret = save_array[num_save_array].seg_ptr[0];
save_array[num_save_array].seg_used[0] = 1;
save_array[num_save_array].num_used = 1;
num_save_array++;
}
}
}
else
{
ret = farmalloc(size);
}
# endif /* __WIN32__ */
#else /* __TURBOC__ */
# ifdef _MSC_VER
ret = halloc(size, 1);
# else
/* everybody else, so normal malloc should do it. */
ret = malloc(size);
# endif
#if defined(__TURBOC__) && !defined(__FLAT__)
ret = farmalloc(size);
#else
ret = malloc(size);
#endif
if (ret == NULL)
{
(*(png_ptr->error_fn))(png_ptr, "Out of Memory");
png_error(png_ptr, "Out of Memory");
}
return ret;
@@ -190,124 +50,88 @@ png_large_malloc(png_structf *png_ptr, png_uint_32 size)
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_structf *png_ptr, voidpf ptr)
png_large_free(png_structp png_ptr, png_voidp ptr)
{
if (!png_ptr)
return;
return;
if (ptr != (void *)0)
if (ptr != NULL)
{
#ifdef __TURBOC__
# if defined(__WIN32__) || defined(__FLAT__)
if (ptr)
free(ptr);
# else
int i, j;
for (i = 0; i < num_save_array; i++)
{
for (j = 0; j < NUM_SEG; j++)
{
if (ptr == save_array[i].seg_ptr[j])
{
save_array[i].seg_used[j] = 0;
ptr = 0;
save_array[i].num_used--;
if (!save_array[i].num_used)
{
int k;
num_save_array--;
farfree(save_array[i].mem_ptr);
for (k = i; k < num_save_array; k++)
save_array[k] = save_array[k + 1];
if (!num_save_array)
{
free(save_array);
save_array = 0;
}
}
break;
}
}
if (!ptr)
break;
}
if (ptr)
farfree(ptr);
# endif
#if defined(__TURBOC__) && !defined(__FLAT__)
farfree(ptr);
#else
# ifdef _MSC_VER
hfree(ptr);
# else
free(ptr);
# endif
free(ptr);
#endif
}
}
/* Allocate memory. This is called for smallish blocks only It
should not get anywhere near 64K. */
should not get anywhere near 64K. On segmented machines, this
must come from the local heap (for zlib). */
void *
png_malloc(png_struct *png_ptr, png_uint_32 size)
png_malloc(png_structp png_ptr, png_uint_32 size)
{
void *ret;
if (!png_ptr || !size)
{
return ((void *)0);
}
#ifdef PNG_MAX_MALLOC_64K
if (size > (png_uint_32)65536L)
(*(png_ptr->error_fn))(png_ptr, "Cannot Allocate > 64K");
png_error(png_ptr, "Cannot Allocate > 64K");
#endif
ret = malloc((png_size_t)size);
if (!ret)
if (!ret)
{
(*(png_ptr->error_fn))(png_ptr, "Out of Memory 6");
png_error(png_ptr, "Out of Memory");
}
return ret;
}
/* Reallocate memory. This will not get near 64K on a
even marginally reasonable file. */
even marginally reasonable file. */
void *
png_realloc(png_struct *png_ptr, void *ptr, png_uint_32 size,
png_uint_32 old_size)
png_realloc(png_structp png_ptr, void * ptr, png_uint_32 size,
png_uint_32 old_size)
{
void *ret;
void *ret;
if (!png_ptr || !old_size || !ptr || !size)
return ((void *)0);
if (!png_ptr || !old_size || !ptr || !size)
return ((void *)0);
#ifdef PNG_MAX_MALLOC_64K
if (size > (png_uint_32)65536L)
(*(png_ptr->error_fn))(png_ptr, "Cannot Allocate > 64K");
if (size > (png_uint_32)65536L)
png_error(png_ptr, "Cannot Allocate > 64K");
#endif
ret = realloc(ptr, (png_size_t)size);
ret = realloc(ptr, (png_size_t)size);
if (!ret)
{
(*(png_ptr->error_fn))(png_ptr, "Out of Memory 7");
}
if (!ret)
{
png_error(png_ptr, "Out of Memory 7");
}
return ret;
return ret;
}
/* 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
png_free(png_struct *png_ptr, void *ptr)
png_free(png_structp png_ptr, void * ptr)
{
if (!png_ptr)
return;
if (!png_ptr)
return;
if (ptr != (void *)0)
free(ptr);
if (ptr != (void *)0)
free(ptr);
}