WebSVN - shark - Blame - Rev 96 - /shark/trunk/ports/png/pngmem.c

Rev	Author	Line No.	Line
96	giacomo	1
		2	/* pngmem.c - stub functions for memory allocation
		3	*
		4	* libpng 1.2.5 - October 3, 2002
		5	* For conditions of distribution and use, see copyright notice in png.h
		6	* Copyright (c) 1998-2002 Glenn Randers-Pehrson
		7	* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
		8	* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
		9	*
		10	* This file provides a location for all memory allocation. Users who
		11	* need special memory handling are expected to supply replacement
		12	* functions for png_malloc() and png_free(), and to use
		13	* png_create_read_struct_2() and png_create_write_struct_2() to
		14	* identify the replacement functions.
		15	*/
		16
		17	#define PNG_INTERNAL
		18	#include "png.h"
		19
		20	/* Borland DOS special memory handler */
		21	#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
		22	/* if you change this, be sure to change the one in png.h also */
		23
		24	/* Allocate memory for a png_struct. The malloc and memset can be replaced
		25	by a single call to calloc() if this is thought to improve performance. */
		26	png_voidp /* PRIVATE */
		27	png_create_struct(int type)
		28	{
		29	#ifdef PNG_USER_MEM_SUPPORTED
		30	return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));
		31	}
		32
		33	/* Alternate version of png_create_struct, for use with user-defined malloc. */
		34	png_voidp /* PRIVATE */
		35	png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
		36	{
		37	#endif /* PNG_USER_MEM_SUPPORTED */
		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_get_copyright());
		47
		48	#ifdef PNG_USER_MEM_SUPPORTED
		49	if(malloc_fn != NULL)
		50	{
		51	png_struct dummy_struct;
		52	png_structp png_ptr = &dummy_struct;
		53	png_ptr->mem_ptr=mem_ptr;
		54	struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size);
		55	}
		56	else
		57	#endif /* PNG_USER_MEM_SUPPORTED */
		58	struct_ptr = (png_voidp)farmalloc(size));
		59	if (struct_ptr != NULL)
		60	png_memset(struct_ptr, 0, size);
		61	return (struct_ptr);
		62	}
		63
		64	/* Free memory allocated by a png_create_struct() call */
		65	void /* PRIVATE */
		66	png_destroy_struct(png_voidp struct_ptr)
		67	{
		68	#ifdef PNG_USER_MEM_SUPPORTED
		69	png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL);
		70	}
		71
		72	/* Free memory allocated by a png_create_struct() call */
		73	void /* PRIVATE */
		74	png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
		75	png_voidp mem_ptr)
		76	{
		77	#endif
		78	if (struct_ptr != NULL)
		79	{
		80	#ifdef PNG_USER_MEM_SUPPORTED
		81	if(free_fn != NULL)
		82	{
		83	png_struct dummy_struct;
		84	png_structp png_ptr = &dummy_struct;
		85	png_ptr->mem_ptr=mem_ptr;
		86	(*(free_fn))(png_ptr, struct_ptr);
		87	return;
		88	}
		89	#endif /* PNG_USER_MEM_SUPPORTED */
		90	farfree (struct_ptr);
		91	}
		92	}
		93
		94	/* Allocate memory. For reasonable files, size should never exceed
		95	* 64K. However, zlib may allocate more then 64K if you don't tell
		96	* it not to. See zconf.h and png.h for more information. zlib does
		97	* need to allocate exactly 64K, so whatever you call here must
		98	* have the ability to do that.
		99	*
		100	* Borland seems to have a problem in DOS mode for exactly 64K.
		101	* It gives you a segment with an offset of 8 (perhaps to store its
		102	* memory stuff). zlib doesn't like this at all, so we have to
		103	* detect and deal with it. This code should not be needed in
		104	* Windows or OS/2 modes, and only in 16 bit mode. This code has
		105	* been updated by Alexander Lehmann for version 0.89 to waste less
		106	* memory.
		107	*
		108	* Note that we can't use png_size_t for the "size" declaration,
		109	* since on some systems a png_size_t is a 16-bit quantity, and as a
		110	* result, we would be truncating potentially larger memory requests
		111	* (which should cause a fatal error) and introducing major problems.
		112	*/
		113
		114	png_voidp PNGAPI
		115	png_malloc(png_structp png_ptr, png_uint_32 size)
		116	{
		117	png_voidp ret;
		118
		119	if (png_ptr == NULL \|\| size == 0)
		120	return (NULL);
		121
		122	#ifdef PNG_USER_MEM_SUPPORTED
		123	if(png_ptr->malloc_fn != NULL)
		124	{
		125	ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
		126	if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
		127	png_error(png_ptr, "Out of memory!");
		128	return (ret);
		129	}
		130	else
		131	return png_malloc_default(png_ptr, size);
		132	}
		133
		134	png_voidp PNGAPI
		135	png_malloc_default(png_structp png_ptr, png_uint_32 size)
		136	{
		137	png_voidp ret;
		138	#endif /* PNG_USER_MEM_SUPPORTED */
		139
		140	#ifdef PNG_MAX_MALLOC_64K
		141	if (size > (png_uint_32)65536L)
		142	png_error(png_ptr, "Cannot Allocate > 64K");
		143	#endif
		144
		145	if (size == (png_uint_32)65536L)
		146	{
		147	if (png_ptr->offset_table == NULL)
		148	{
		149	/* try to see if we need to do any of this fancy stuff */
		150	ret = farmalloc(size);
		151	if (ret == NULL \|\| ((png_size_t)ret & 0xffff))
		152	{
		153	int num_blocks;
		154	png_uint_32 total_size;
		155	png_bytep table;
		156	int i;
		157	png_byte huge * hptr;
		158
		159	if (ret != NULL)
		160	{
		161	farfree(ret);
		162	ret = NULL;
		163	}
		164
		165	if(png_ptr->zlib_window_bits > 14)
		166	num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
		167	else
		168	num_blocks = 1;
		169	if (png_ptr->zlib_mem_level >= 7)
		170	num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));
		171	else
		172	num_blocks++;
		173
		174	total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;
		175
		176	table = farmalloc(total_size);
		177
		178	if (table == NULL)
		179	{
		180	if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
		181	png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */
		182	else
		183	png_warning(png_ptr, "Out Of Memory.");
		184	return (NULL);
		185	}
		186
		187	if ((png_size_t)table & 0xfff0)
		188	{
		189	if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
		190	png_error(png_ptr,
		191	"Farmalloc didn't return normalized pointer");
		192	else
		193	png_warning(png_ptr,
		194	"Farmalloc didn't return normalized pointer");
		195	return (NULL);
		196	}
		197
		198	png_ptr->offset_table = table;
		199	png_ptr->offset_table_ptr = farmalloc(num_blocks *
		200	sizeof (png_bytep));
		201
		202	if (png_ptr->offset_table_ptr == NULL)
		203	{
		204	if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
		205	png_error(png_ptr, "Out Of memory."); /* Note "O" and "M" */
		206	else
		207	png_warning(png_ptr, "Out Of memory.");
		208	return (NULL);
		209	}
		210
		211	hptr = (png_byte huge *)table;
		212	if ((png_size_t)hptr & 0xf)
		213	{
		214	hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
		215	hptr = hptr + 16L; /* "hptr += 16L" fails on Turbo C++ 3.0 */
		216	}
		217	for (i = 0; i < num_blocks; i++)
		218	{
		219	png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
		220	hptr = hptr + (png_uint_32)65536L; /* "+=" fails on TC++3.0 */
		221	}
		222
		223	png_ptr->offset_table_number = num_blocks;
		224	png_ptr->offset_table_count = 0;
		225	png_ptr->offset_table_count_free = 0;
		226	}
		227	}
		228
		229	if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
		230	{
		231	if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
		232	png_error(png_ptr, "Out of Memory."); /* Note "o" and "M" */
		233	else
		234	png_warning(png_ptr, "Out of Memory.");
		235	return (NULL);
		236	}
		237
		238	ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
		239	}
		240	else
		241	ret = farmalloc(size);
		242
		243	if (ret == NULL)
		244	{
		245	if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
		246	png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */
		247	else
		248	png_warning(png_ptr, "Out of memory."); /* Note "o" and "m" */
		249	}
		250
		251	return (ret);
		252	}
		253
		254	/* free a pointer allocated by png_malloc(). In the default
		255	configuration, png_ptr is not used, but is passed in case it
		256	is needed. If ptr is NULL, return without taking any action. */
		257	void PNGAPI
		258	png_free(png_structp png_ptr, png_voidp ptr)
		259	{
		260	if (png_ptr == NULL \|\| ptr == NULL)
		261	return;
		262
		263	#ifdef PNG_USER_MEM_SUPPORTED
		264	if (png_ptr->free_fn != NULL)
		265	{
		266	(*(png_ptr->free_fn))(png_ptr, ptr);
		267	return;
		268	}
		269	else png_free_default(png_ptr, ptr);
		270	}
		271
		272	void PNGAPI
		273	png_free_default(png_structp png_ptr, png_voidp ptr)
		274	{
		275	#endif /* PNG_USER_MEM_SUPPORTED */
		276
		277	if (png_ptr->offset_table != NULL)
		278	{
		279	int i;
		280
		281	for (i = 0; i < png_ptr->offset_table_count; i++)
		282	{
		283	if (ptr == png_ptr->offset_table_ptr[i])
		284	{
		285	ptr = NULL;
		286	png_ptr->offset_table_count_free++;
		287	break;
		288	}
		289	}
		290	if (png_ptr->offset_table_count_free == png_ptr->offset_table_count)
		291	{
		292	farfree(png_ptr->offset_table);
		293	farfree(png_ptr->offset_table_ptr);
		294	png_ptr->offset_table = NULL;
		295	png_ptr->offset_table_ptr = NULL;
		296	}
		297	}
		298
		299	if (ptr != NULL)
		300	{
		301	farfree(ptr);
		302	}
		303	}
		304
		305	#else /* Not the Borland DOS special memory handler */
		306
		307	/* Allocate memory for a png_struct or a png_info. The malloc and
		308	memset can be replaced by a single call to calloc() if this is thought
		309	to improve performance noticably. */
		310	png_voidp /* PRIVATE */
		311	png_create_struct(int type)
		312	{
		313	#ifdef PNG_USER_MEM_SUPPORTED
		314	return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));
		315	}
		316
		317	/* Allocate memory for a png_struct or a png_info. The malloc and
		318	memset can be replaced by a single call to calloc() if this is thought
		319	to improve performance noticably. */
		320	png_voidp /* PRIVATE */
		321	png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
		322	{
		323	#endif /* PNG_USER_MEM_SUPPORTED */
		324	png_size_t size;
		325	png_voidp struct_ptr;
		326
		327	if (type == PNG_STRUCT_INFO)
		328	size = sizeof(png_info);
		329	else if (type == PNG_STRUCT_PNG)
		330	size = sizeof(png_struct);
		331	else
		332	return (NULL);
		333
		334	#ifdef PNG_USER_MEM_SUPPORTED
		335	if(malloc_fn != NULL)
		336	{
		337	png_struct dummy_struct;
		338	png_structp png_ptr = &dummy_struct;
		339	png_ptr->mem_ptr=mem_ptr;
		340	struct_ptr = (*(malloc_fn))(png_ptr, size);
		341	if (struct_ptr != NULL)
		342	png_memset(struct_ptr, 0, size);
		343	return (struct_ptr);
		344	}
		345	#endif /* PNG_USER_MEM_SUPPORTED */
		346
		347	#if defined(__TURBOC__) && !defined(__FLAT__)
		348	if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL)
		349	#else
		350	# if defined(_MSC_VER) && defined(MAXSEG_64K)
		351	if ((struct_ptr = (png_voidp)halloc(size,1)) != NULL)
		352	# else
		353	if ((struct_ptr = (png_voidp)malloc(size)) != NULL)
		354	# endif
		355	#endif
		356	{
		357	png_memset(struct_ptr, 0, size);
		358	}
		359
		360	return (struct_ptr);
		361	}
		362
		363
		364	/* Free memory allocated by a png_create_struct() call */
		365	void /* PRIVATE */
		366	png_destroy_struct(png_voidp struct_ptr)
		367	{
		368	#ifdef PNG_USER_MEM_SUPPORTED
		369	png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL);
		370	}
		371
		372	/* Free memory allocated by a png_create_struct() call */
		373	void /* PRIVATE */
		374	png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
		375	png_voidp mem_ptr)
		376	{
		377	#endif /* PNG_USER_MEM_SUPPORTED */
		378	if (struct_ptr != NULL)
		379	{
		380	#ifdef PNG_USER_MEM_SUPPORTED
		381	if(free_fn != NULL)
		382	{
		383	png_struct dummy_struct;
		384	png_structp png_ptr = &dummy_struct;
		385	png_ptr->mem_ptr=mem_ptr;
		386	(*(free_fn))(png_ptr, struct_ptr);
		387	return;
		388	}
		389	#endif /* PNG_USER_MEM_SUPPORTED */
		390	#if defined(__TURBOC__) && !defined(__FLAT__)
		391	farfree(struct_ptr);
		392	#else
		393	# if defined(_MSC_VER) && defined(MAXSEG_64K)
		394	hfree(struct_ptr);
		395	# else
		396	free(struct_ptr);
		397	# endif
		398	#endif
		399	}
		400	}
		401
		402	/* Allocate memory. For reasonable files, size should never exceed
		403	64K. However, zlib may allocate more then 64K if you don't tell
		404	it not to. See zconf.h and png.h for more information. zlib does
		405	need to allocate exactly 64K, so whatever you call here must
		406	have the ability to do that. */
		407
		408	png_voidp PNGAPI
		409	png_malloc(png_structp png_ptr, png_uint_32 size)
		410	{
		411	png_voidp ret;
		412
		413	if (png_ptr == NULL \|\| size == 0)
		414	return (NULL);
		415
		416	#ifdef PNG_USER_MEM_SUPPORTED
		417	if(png_ptr->malloc_fn != NULL)
		418	{
		419	ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
		420	if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
		421	png_error(png_ptr, "Out of Memory!");
		422	return (ret);
		423	}
		424	else
		425	return (png_malloc_default(png_ptr, size));
		426	}
		427
		428	png_voidp PNGAPI
		429	png_malloc_default(png_structp png_ptr, png_uint_32 size)
		430	{
		431	png_voidp ret;
		432	#endif /* PNG_USER_MEM_SUPPORTED */
		433
		434	#ifdef PNG_MAX_MALLOC_64K
		435	if (size > (png_uint_32)65536L)
		436	{
		437	if(png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
		438	png_error(png_ptr, "Cannot Allocate > 64K");
		439	else
		440	return NULL;
		441	}
		442	#endif
		443
		444	#if defined(__TURBOC__) && !defined(__FLAT__)
		445	ret = farmalloc(size);
		446	#else
		447	# if defined(_MSC_VER) && defined(MAXSEG_64K)
		448	ret = halloc(size, 1);
		449	# else
		450	ret = malloc((size_t)size);
		451	# endif
		452	#endif
		453
		454	if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
		455	png_error(png_ptr, "Out of Memory");
		456
		457	return (ret);
		458	}
		459
		460	/* Free a pointer allocated by png_malloc(). If ptr is NULL, return
		461	without taking any action. */
		462	void PNGAPI
		463	png_free(png_structp png_ptr, png_voidp ptr)
		464	{
		465	if (png_ptr == NULL \|\| ptr == NULL)
		466	return;
		467
		468	#ifdef PNG_USER_MEM_SUPPORTED
		469	if (png_ptr->free_fn != NULL)
		470	{
		471	(*(png_ptr->free_fn))(png_ptr, ptr);
		472	return;
		473	}
		474	else png_free_default(png_ptr, ptr);
		475	}
		476	void PNGAPI
		477	png_free_default(png_structp png_ptr, png_voidp ptr)
		478	{
		479	if (png_ptr == NULL \|\| ptr == NULL)
		480	return;
		481
		482	#endif /* PNG_USER_MEM_SUPPORTED */
		483
		484	#if defined(__TURBOC__) && !defined(__FLAT__)
		485	farfree(ptr);
		486	#else
		487	# if defined(_MSC_VER) && defined(MAXSEG_64K)
		488	hfree(ptr);
		489	# else
		490	free(ptr);
		491	# endif
		492	#endif
		493	}
		494
		495	#endif /* Not Borland DOS special memory handler */
		496
		497	#if defined(PNG_1_0_X)
		498	# define png_malloc_warn png_malloc
		499	#else
		500	/* This function was added at libpng version 1.2.3. The png_malloc_warn()
		501	* function will issue a png_warning and return NULL instead of issuing a
		502	* png_error, if it fails to allocate the requested memory.
		503	*/
		504	png_voidp PNGAPI
		505	png_malloc_warn(png_structp png_ptr, png_uint_32 size)
		506	{
		507	png_voidp ptr;
		508	png_uint_32 save_flags=png_ptr->flags;
		509
		510	png_ptr->flags\|=PNG_FLAG_MALLOC_NULL_MEM_OK;
		511	ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);
		512	png_ptr->flags=save_flags;
		513	return(ptr);
		514	}
		515	#endif
		516
		517	png_voidp PNGAPI
		518	png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2,
		519	png_uint_32 length)
		520	{
		521	png_size_t size;
		522
		523	size = (png_size_t)length;
		524	if ((png_uint_32)size != length)
		525	png_error(png_ptr,"Overflow in png_memcpy_check.");
		526
		527	return(png_memcpy (s1, s2, size));
		528	}
		529
		530	png_voidp PNGAPI
		531	png_memset_check (png_structp png_ptr, png_voidp s1, int value,
		532	png_uint_32 length)
		533	{
		534	png_size_t size;
		535
		536	size = (png_size_t)length;
		537	if ((png_uint_32)size != length)
		538	png_error(png_ptr,"Overflow in png_memset_check.");
		539
		540	return (png_memset (s1, value, size));
		541
		542	}
		543
		544	#ifdef PNG_USER_MEM_SUPPORTED
		545	/* This function is called when the application wants to use another method
		546	* of allocating and freeing memory.
		547	*/
		548	void PNGAPI
		549	png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
		550	malloc_fn, png_free_ptr free_fn)
		551	{
		552	png_ptr->mem_ptr = mem_ptr;
		553	png_ptr->malloc_fn = malloc_fn;
		554	png_ptr->free_fn = free_fn;
		555	}
		556
		557	/* This function returns a pointer to the mem_ptr associated with the user
		558	* functions. The application should free any memory associated with this
		559	* pointer before png_write_destroy and png_read_destroy are called.
		560	*/
		561	png_voidp PNGAPI
		562	png_get_mem_ptr(png_structp png_ptr)
		563	{
		564	return ((png_voidp)png_ptr->mem_ptr);
		565	}
		566	#endif /* PNG_USER_MEM_SUPPORTED */

Subversion Repositories shark

(root)/shark/trunk/ports/png/pngmem.c @ 1028 - Rev 96