/src/compiler/android/jni/ftk/pngmem.c

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