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


/* pngmem.c - stub functions for memory allocation
 *
 * libpng 1.0.1
 * 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
 *
 * 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.
 */

#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

/* 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
png_create_struct(int type)
{
   png_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 ((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 != NULL)
   {
      farfree (struct_ptr);
      struct_ptr = NULL;
   }
}

/* 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 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.  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
PNG_MALLOC(png_structp png_ptr, png_uint_32 size)
{
   png_voidp ret;
   if (png_ptr == NULL || size == 0)
      return ((png_voidp)NULL);

#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 == 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;
            }

            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+16;

            table = farmalloc(total_size);

            if (table == NULL)
            {
               png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */
            }

            if ((png_size_t)table & 0xfff0)
            {
               png_error(png_ptr, "Farmalloc didn't return normalized pointer");
            }

            png_ptr->offset_table = table;
            png_ptr->offset_table_ptr = farmalloc(num_blocks *
               sizeof (png_bytep));

            if (png_ptr->offset_table_ptr == NULL)
            {
               png_error(png_ptr, "Out Of memory.");
            }

            hptr = (png_byte huge *)table;
            if ((png_size_t)hptr & 0xf)
            {
               hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
               hptr += 16L;
            }
            for (i = 0; i < num_blocks; i++)
            {
               png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
               hptr += (png_uint_32)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."); /* Note "o" and "m" */
   }

   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)
{
   if (png_ptr == NULL || ptr == NULL)
      return;

   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])
         {
            ptr = NULL;
            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 = NULL;
         png_ptr->offset_table_ptr = NULL;
      }
   }

   if (ptr != NULL)
   {
      farfree(ptr);
      ptr = NULL;
   }
}

#else /* Not the Borland DOS special memory handler */

/* 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(int type)
{
   png_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,1)) != 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 != NULL)
   {
#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
   }
}


/* 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 ret;

   if (png_ptr == NULL || size == 0)
      return ((png_voidp)NULL);

#ifdef PNG_MAX_MALLOC_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_t)size);
# endif
#endif

   if (ret == NULL)
   {
      png_error(png_ptr, "Out of Memory");
   }

   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)
{
   if (png_ptr == NULL || ptr == NULL)
      return;

#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 */

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

   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));
}

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

   size = (png_size_t)length;
   if ((png_uint_32)size != length)
      png_error(png_ptr,"Overflow in png_memset_check.");

   return (png_memset (s1, value, size));

}
Commit	Line	Data
c801d85f KB	1
	2	/* pngmem.c - stub functions for memory allocation
	3	*
	4	* libpng 1.0.1
	5	* For conditions of distribution and use, see copyright notice in png.h
	6	* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
	7	* Copyright (c) 1996, 1997 Andreas Dilger
	8	* Copyright (c) 1998, Glenn Randers-Pehrson
	9	* March 15, 1998
	10	*
	11	* This file provides a location for all memory allocation. Users which
	12	* need special memory handling are expected to modify the code in this file
	13	* to meet their needs. See the instructions at each function.
	14	*/
	15
	16	#define PNG_INTERNAL
1f0299c1	17	#include "../png/png.h"
c801d85f KB	18
	19	/* The following "hides" PNG_MALLOC and PNG_FREE thus allowing the pngtest
	20	application to put a wrapper on top of them. */
	21	#ifdef PNGTEST_MEMORY_DEBUG
	22	#define PNG_MALLOC png_debug_malloc
	23	#define PNG_FREE png_debug_free
	24	#else
	25	#define PNG_MALLOC png_malloc
	26	#define PNG_FREE png_free
	27	#endif
	28
	29	/* Borland DOS special memory handler */
	30	#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
	31	/* if you change this, be sure to change the one in png.h also */
	32
	33	/* Allocate memory for a png_struct. The malloc and memset can be replaced
	34	by a single call to calloc() if this is thought to improve performance. */
	35	png_voidp
	36	png_create_struct(int type)
	37	{
	38	png_size_t size;
	39	png_voidp struct_ptr;
	40
	41	if (type == PNG_STRUCT_INFO)
	42	size = sizeof(png_info);
	43	else if (type == PNG_STRUCT_PNG)
	44	size = sizeof(png_struct);
	45	else
	46	return ((png_voidp)NULL);
	47
	48	if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL)
	49	{
	50	png_memset(struct_ptr, 0, size);
	51	}
	52
	53	return (struct_ptr);
	54	}
	55
	56
	57	/* Free memory allocated by a png_create_struct() call */
	58	void
	59	png_destroy_struct(png_voidp struct_ptr)
	60	{
	61	if (struct_ptr != NULL)
	62	{
	63	farfree (struct_ptr);
	64	struct_ptr = NULL;
	65	}
	66	}
	67
	68	/* Allocate memory. For reasonable files, size should never exceed
	69	* 64K. However, zlib may allocate more then 64K if you don't tell
	70	* it not to. See zconf.h and png.h for more information. zlib does
	71	* need to allocate exactly 64K, so whatever you call here must
	72	* have the ability to do that.
	73	*
	74	* Borland seems to have a problem in DOS mode for exactly 64K.
	75	* It gives you a segment with an offset of 8 (perhaps to store it's
	76	* memory stuff). zlib doesn't like this at all, so we have to
	77	* detect and deal with it. This code should not be needed in
	78	* Windows or OS/2 modes, and only in 16 bit mode. This code has
	79	* been updated by Alexander Lehmann for version 0.89 to waste less
	80	* memory.
	81	*
82	* Note that we can't use png_size_t for the "size" declaration,
83	* since on some systems a png_size_t is a 16-bit quantity, and as a
84	* result, we would be truncating potentially larger memory requests
85	* (which should cause a fatal error) and introducing major problems.
86	*/
87	png_voidp
88	PNG_MALLOC(png_structp png_ptr, png_uint_32 size)
89	{
90	png_voidp ret;
91	if (png_ptr == NULL \|\| size == 0)
92	return ((png_voidp)NULL);
93
94	#ifdef PNG_MAX_MALLOC_64K
95	if (size > (png_uint_32)65536L)
96	png_error(png_ptr, "Cannot Allocate > 64K");
97	#endif
98
99	if (size == (png_uint_32)65536L)
100	{
101	if (png_ptr->offset_table == NULL)
102	{
103	/* try to see if we need to do any of this fancy stuff */
104	ret = farmalloc(size);
105	if (ret == NULL \|\| ((png_size_t)ret & 0xffff))
106	{
107	int num_blocks;
108	png_uint_32 total_size;
109	png_bytep table;
110	int i;
111	png_byte huge * hptr;
112
113	if (ret != NULL)
114	{
115	farfree(ret);
116	ret = NULL;
117	}
118
119	num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
120	if (num_blocks < 1)
121	num_blocks = 1;
122	if (png_ptr->zlib_mem_level >= 7)
123	num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));
124	else
125	num_blocks++;
126
127	total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;
128
129	table = farmalloc(total_size);
130
131	if (table == NULL)
132	{
133	png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */
134	}
135
136	if ((png_size_t)table & 0xfff0)
137	{
138	png_error(png_ptr, "Farmalloc didn't return normalized pointer");
139	}
140
141	png_ptr->offset_table = table;
142	png_ptr->offset_table_ptr = farmalloc(num_blocks *
143	sizeof (png_bytep));
144
145	if (png_ptr->offset_table_ptr == NULL)
146	{
147	png_error(png_ptr, "Out Of memory.");
148	}
149
150	hptr = (png_byte huge *)table;
151	if ((png_size_t)hptr & 0xf)
152	{
153	hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
154	hptr += 16L;
155	}
156	for (i = 0; i < num_blocks; i++)
157	{
158	png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
159	hptr += (png_uint_32)65536L;
160	}
161
162	png_ptr->offset_table_number = num_blocks;
163	png_ptr->offset_table_count = 0;
164	png_ptr->offset_table_count_free = 0;
165	}
166	}
167
168	if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
169	png_error(png_ptr, "Out of Memory.");
170
171	ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
172	}
173	else
174	ret = farmalloc(size);
175
176	if (ret == NULL)
177	{
178	png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */
179	}
180
181	return (ret);
182	}
183
184	/* free a pointer allocated by PNG_MALLOC(). In the default
185	configuration, png_ptr is not used, but is passed in case it
186	is needed. If ptr is NULL, return without taking any action. */
187	void
188	PNG_FREE(png_structp png_ptr, png_voidp ptr)
189	{
190	if (png_ptr == NULL \|\| ptr == NULL)
191	return;
192
193	if (png_ptr->offset_table != NULL)
194	{
195	int i;
196
197	for (i = 0; i < png_ptr->offset_table_count; i++)
198	{
199	if (ptr == png_ptr->offset_table_ptr[i])
200	{
201	ptr = NULL;
202	png_ptr->offset_table_count_free++;
203	break;
204	}
205	}
206	if (png_ptr->offset_table_count_free == png_ptr->offset_table_count)
207	{
208	farfree(png_ptr->offset_table);
209	farfree(png_ptr->offset_table_ptr);
210	png_ptr->offset_table = NULL;
211	png_ptr->offset_table_ptr = NULL;
212	}
213	}
214
215	if (ptr != NULL)
216	{
217	farfree(ptr);
218	ptr = NULL;
219	}
220	}
221
222	#else /* Not the Borland DOS special memory handler */
223
224	/* Allocate memory for a png_struct or a png_info. The malloc and
225	memset can be replaced by a single call to calloc() if this is thought
226	to improve performance noticably.*/
227	png_voidp
228	png_create_struct(int type)
229	{
230	png_size_t size;
231	png_voidp struct_ptr;
232
233	if (type == PNG_STRUCT_INFO)
234	size = sizeof(png_info);
235	else if (type == PNG_STRUCT_PNG)
236	size = sizeof(png_struct);
237	else
238	return ((png_voidp)NULL);
239
240	#if defined(__TURBOC__) && !defined(__FLAT__)
241	if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL)
242	#else
243	# if defined(_MSC_VER) && defined(MAXSEG_64K)
244	if ((struct_ptr = (png_voidp)halloc(size,1)) != NULL)
245	# else
246	if ((struct_ptr = (png_voidp)malloc(size)) != NULL)
247	# endif
248	#endif
249	{
250	png_memset(struct_ptr, 0, size);
251	}
252
253	return (struct_ptr);
254	}
255
256
257	/* Free memory allocated by a png_create_struct() call */
258	void
259	png_destroy_struct(png_voidp struct_ptr)
260	{
261	if (struct_ptr != NULL)
262	{
263	#if defined(__TURBOC__) && !defined(__FLAT__)
264	farfree(struct_ptr);
265	#else
266	# if defined(_MSC_VER) && defined(MAXSEG_64K)
267	hfree(struct_ptr);
268	# else
269	free(struct_ptr);
270	# endif
271	#endif
272	}
273	}
274
275
276	/* Allocate memory. For reasonable files, size should never exceed
277	64K. However, zlib may allocate more then 64K if you don't tell
278	it not to. See zconf.h and png.h for more information. zlib does
279	need to allocate exactly 64K, so whatever you call here must
280	have the ability to do that. */
281
282	png_voidp
283	PNG_MALLOC(png_structp png_ptr, png_uint_32 size)
284	{
285	png_voidp ret;
286
287	if (png_ptr == NULL \|\| size == 0)
288	return ((png_voidp)NULL);
289
290	#ifdef PNG_MAX_MALLOC_64K
291	if (size > (png_uint_32)65536L)
292	png_error(png_ptr, "Cannot Allocate > 64K");
293	#endif
294
295	#if defined(__TURBOC__) && !defined(__FLAT__)
296	ret = farmalloc(size);
297	#else
298	# if defined(_MSC_VER) && defined(MAXSEG_64K)
299	ret = halloc(size, 1);
300	# else
301	ret = malloc((size_t)size);
302	# endif
303	#endif
304
305	if (ret == NULL)
306	{
307	png_error(png_ptr, "Out of Memory");
308	}
309
310	return (ret);
311	}
312
313	/* Free a pointer allocated by PNG_MALLOC(). In the default
314	configuration, png_ptr is not used, but is passed in case it
315	is needed. If ptr is NULL, return without taking any action. */
316	void
317	PNG_FREE(png_structp png_ptr, png_voidp ptr)
318	{
319	if (png_ptr == NULL \|\| ptr == NULL)
320	return;
321
322	#if defined(__TURBOC__) && !defined(__FLAT__)
323	farfree(ptr);
324	#else
325	# if defined(_MSC_VER) && defined(MAXSEG_64K)
326	hfree(ptr);
327	# else
328	free(ptr);
329	# endif
330	#endif
331	}
332
333	#endif /* Not Borland DOS special memory handler */
334
335	png_voidp
336	png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2,
337	png_uint_32 length)
338	{
339	png_size_t size;
340
341	size = (png_size_t)length;
342	if ((png_uint_32)size != length)
343	png_error(png_ptr,"Overflow in png_memcpy_check.");
344
345	return(png_memcpy (s1, s2, size));
346	}
347
348	png_voidp
349	png_memset_check (png_structp png_ptr, png_voidp s1, int value,
350	png_uint_32 length)
351	{
352	png_size_t size;
353
354	size = (png_size_t)length;
355	if ((png_uint_32)size != length)
356	png_error(png_ptr,"Overflow in png_memset_check.");
357
358	return (png_memset (s1, value, size));
359
360	}