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