Wrappers for *ToText
[wxWidgets.git] / src / png / pngmem.c
1
2 /* pngmem.c - stub functions for memory allocation
3 *
4 * libpng 1.2.5rc3 - September 18, 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 */