← Back to branch summary

~baltix/+junk/irrlicht-test

« back to all changes in this revision

Viewing changes to source/Irrlicht/libpng/pngmem.c

  • Committer: Mantas Kriaučiūnas
  • Date: 2011-07-18 13:06:25 UTC
  • Revision ID: mantas@akl.lt-20110718130625-c5pvifp61e7kj1ol
Included whole irrlicht SVN libraries to work around launchpad recipe issue with quilt, see https://answers.launchpad.net/launchpad/+question/165193

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/Irrlicht/libpng/pngmem.c
 
1
 
 
2
/* pngmem.c - stub functions for memory allocation
 
3
 *
 
4
 * Last changed in libpng 1.4.2 [May 6, 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_NO_PEDANTIC_WARNINGS
 
21
#include "png.h"
 
22
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
 
23
#include "pngpriv.h"
 
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. */
 
31
png_voidp /* PRIVATE */
 
32
png_create_struct(int type)
 
33
{
 
34
#ifdef PNG_USER_MEM_SUPPORTED
 
35
   return (png_create_struct_2(type, NULL, NULL));
 
36
}
 
37
 
 
38
/* Alternate version of png_create_struct, for use with user-defined malloc. */
 
39
png_voidp /* PRIVATE */
 
40
png_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 */
 
70
void /* PRIVATE */
 
71
png_destroy_struct(png_voidp struct_ptr)
 
72
{
 
73
#ifdef PNG_USER_MEM_SUPPORTED
 
74
   png_destroy_struct_2(struct_ptr, NULL, NULL);
 
75
}
 
76
 
 
77
/* Free memory allocated by a png_create_struct() call */
 
78
void /* PRIVATE */
 
79
png_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
 */
 
118
png_voidp PNGAPI
 
119
png_calloc(png_structp png_ptr, png_alloc_size_t 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
 
 
129
png_voidp PNGAPI
 
130
png_malloc(png_structp png_ptr, png_alloc_size_t 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
 
 
147
png_voidp PNGAPI
 
148
png_malloc_default(png_structp png_ptr, png_alloc_size_t 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
 */
 
290
void PNGAPI
 
291
png_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
 
 
306
void PNGAPI
 
307
png_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. */
 
347
png_voidp /* PRIVATE */
 
348
png_create_struct(int type)
 
349
{
 
350
#ifdef PNG_USER_MEM_SUPPORTED
 
351
   return (png_create_struct_2(type, NULL, 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. */
 
357
png_voidp /* PRIVATE */
 
358
png_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 */
 
401
void /* PRIVATE */
 
402
png_destroy_struct(png_voidp struct_ptr)
 
403
{
 
404
#ifdef PNG_USER_MEM_SUPPORTED
 
405
   png_destroy_struct_2(struct_ptr, NULL, NULL);
 
406
}
 
407
 
 
408
/* Free memory allocated by a png_create_struct() call */
 
409
void /* PRIVATE */
 
410
png_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
 
 
445
png_voidp PNGAPI
 
446
png_calloc(png_structp png_ptr, png_alloc_size_t 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
 
 
456
png_voidp PNGAPI
 
457
png_malloc(png_structp png_ptr, png_alloc_size_t 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
 
 
474
png_voidp PNGAPI
 
475
png_malloc_default(png_structp png_ptr, png_alloc_size_t 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
 */
 
526
void PNGAPI
 
527
png_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
}
 
541
void PNGAPI
 
542
png_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
/* This function was added at libpng version 1.2.3.  The png_malloc_warn()
 
563
 * function will set up png_malloc() to issue a png_warning and return NULL
 
564
 * instead of issuing a png_error, if it fails to allocate the requested
 
565
 * memory.
 
566
 */
 
567
png_voidp PNGAPI
 
568
png_malloc_warn(png_structp png_ptr, png_alloc_size_t size)
 
569
{
 
570
   png_voidp ptr;
 
571
   png_uint_32 save_flags;
 
572
   if (png_ptr == NULL)
 
573
      return (NULL);
 
574
 
 
575
   save_flags = png_ptr->flags;
 
576
   png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
 
577
   ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);
 
578
   png_ptr->flags=save_flags;
 
579
   return(ptr);
 
580
}
 
581
 
 
582
 
 
583
#ifdef PNG_USER_MEM_SUPPORTED
 
584
/* This function is called when the application wants to use another method
 
585
 * of allocating and freeing memory.
 
586
 */
 
587
void PNGAPI
 
588
png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
 
589
  malloc_fn, png_free_ptr free_fn)
 
590
{
 
591
   if (png_ptr != NULL)
 
592
   {
 
593
      png_ptr->mem_ptr = mem_ptr;
 
594
      png_ptr->malloc_fn = malloc_fn;
 
595
      png_ptr->free_fn = free_fn;
 
596
   }
 
597
}
 
598
 
 
599
/* This function returns a pointer to the mem_ptr associated with the user
 
600
 * functions.  The application should free any memory associated with this
 
601
 * pointer before png_write_destroy and png_read_destroy are called.
 
602
 */
 
603
png_voidp PNGAPI
 
604
png_get_mem_ptr(png_structp png_ptr)
 
605
{
 
606
   if (png_ptr == NULL)
 
607
      return (NULL);
 
608
   return ((png_voidp)png_ptr->mem_ptr);
 
609
}
 
610
#endif /* PNG_USER_MEM_SUPPORTED */
 
611
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */