← Back to branch summary

~ubuntu-dev/wxwidgets2.6/upstream-debian

« back to all changes in this revision

Viewing changes to src/png/pngmem.c

  • Committer: Daniel T Chen
  • Date: 2006-06-26 10:15:11 UTC
  • Revision ID: crimsun@ubuntu.com-20060626101511-a4436cec4c6d9b35
Import Debian 2.6.3.2.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/png/pngmem.c
 
1
 
 
2
/* pngmem.c - stub functions for memory allocation
 
3
 *
 
4
 * libpng version 1.2.7 - September 12, 2004
 
5
 * For conditions of distribution and use, see copyright notice in png.h
 
6
 * Copyright (c) 1998-2004 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 = png_sizeof(png_info);
 
43
   else if (type == PNG_STRUCT_PNG)
 
44
     size = png_sizeof(png_struct);
 
45
   else
 
46
     return (png_get_copyright(NULL));
 
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
       ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
 
125
   else
 
126
       ret = (png_malloc_default(png_ptr, size));
 
127
   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 
128
       png_error(png_ptr, "Out of memory!");
 
129
   return (ret);
 
130
}
 
131
 
 
132
png_voidp PNGAPI
 
133
png_malloc_default(png_structp png_ptr, png_uint_32 size)
 
134
{
 
135
   png_voidp ret;
 
136
#endif /* PNG_USER_MEM_SUPPORTED */
 
137
 
 
138
#ifdef PNG_MAX_MALLOC_64K
 
139
   if (size > (png_uint_32)65536L)
 
140
   {
 
141
      png_warning(png_ptr, "Cannot Allocate > 64K");
 
142
      ret = NULL;
 
143
   }
 
144
   else
 
145
#endif
 
146
 
 
147
   if (size != (size_t)size)
 
148
     ret = NULL;
 
149
   else if (size == (png_uint_32)65536L)
 
150
   {
 
151
      if (png_ptr->offset_table == NULL)
 
152
      {
 
153
         /* try to see if we need to do any of this fancy stuff */
 
154
         ret = farmalloc(size);
 
155
         if (ret == NULL || ((png_size_t)ret & 0xffff))
 
156
         {
 
157
            int num_blocks;
 
158
            png_uint_32 total_size;
 
159
            png_bytep table;
 
160
            int i;
 
161
            png_byte huge * hptr;
 
162
 
 
163
            if (ret != NULL)
 
164
            {
 
165
               farfree(ret);
 
166
               ret = NULL;
 
167
            }
 
168
 
 
169
            if(png_ptr->zlib_window_bits > 14)
 
170
               num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
 
171
            else
 
172
               num_blocks = 1;
 
173
            if (png_ptr->zlib_mem_level >= 7)
 
174
               num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));
 
175
            else
 
176
               num_blocks++;
 
177
 
 
178
            total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;
 
179
 
 
180
            table = farmalloc(total_size);
 
181
 
 
182
            if (table == NULL)
 
183
            {
 
184
#ifndef PNG_USER_MEM_SUPPORTED
 
185
               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 
186
                  png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */
 
187
               else
 
188
                  png_warning(png_ptr, "Out Of Memory.");
 
189
#endif
 
190
               return (NULL);
 
191
            }
 
192
 
 
193
            if ((png_size_t)table & 0xfff0)
 
194
            {
 
195
#ifndef PNG_USER_MEM_SUPPORTED
 
196
               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 
197
                  png_error(png_ptr,
 
198
                    "Farmalloc didn't return normalized pointer");
 
199
               else
 
200
                  png_warning(png_ptr,
 
201
                    "Farmalloc didn't return normalized pointer");
 
202
#endif
 
203
               return (NULL);
 
204
            }
 
205
 
 
206
            png_ptr->offset_table = table;
 
207
            png_ptr->offset_table_ptr = farmalloc(num_blocks *
 
208
               png_sizeof (png_bytep));
 
209
 
 
210
            if (png_ptr->offset_table_ptr == NULL)
 
211
            {
 
212
#ifndef PNG_USER_MEM_SUPPORTED
 
213
               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 
214
                  png_error(png_ptr, "Out Of memory."); /* Note "O" and "M" */
 
215
               else
 
216
                  png_warning(png_ptr, "Out Of memory.");
 
217
#endif
 
218
               return (NULL);
 
219
            }
 
220
 
 
221
            hptr = (png_byte huge *)table;
 
222
            if ((png_size_t)hptr & 0xf)
 
223
            {
 
224
               hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
 
225
               hptr = hptr + 16L;  /* "hptr += 16L" fails on Turbo C++ 3.0 */
 
226
            }
 
227
            for (i = 0; i < num_blocks; i++)
 
228
            {
 
229
               png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
 
230
               hptr = hptr + (png_uint_32)65536L;  /* "+=" fails on TC++3.0 */
 
231
            }
 
232
 
 
233
            png_ptr->offset_table_number = num_blocks;
 
234
            png_ptr->offset_table_count = 0;
 
235
            png_ptr->offset_table_count_free = 0;
 
236
         }
 
237
      }
 
238
 
 
239
      if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
 
240
      {
 
241
#ifndef PNG_USER_MEM_SUPPORTED
 
242
         if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 
243
            png_error(png_ptr, "Out of Memory."); /* Note "o" and "M" */
 
244
         else
 
245
            png_warning(png_ptr, "Out of Memory.");
 
246
#endif
 
247
         return (NULL);
 
248
      }
 
249
 
 
250
      ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
 
251
   }
 
252
   else
 
253
      ret = farmalloc(size);
 
254
 
 
255
#ifndef PNG_USER_MEM_SUPPORTED
 
256
   if (ret == NULL)
 
257
   {
 
258
      if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 
259
         png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */
 
260
      else
 
261
         png_warning(png_ptr, "Out of memory."); /* Note "o" and "m" */
 
262
   }
 
263
#endif
 
264
 
 
265
   return (ret);
 
266
}
 
267
 
 
268
/* free a pointer allocated by png_malloc().  In the default
 
269
   configuration, png_ptr is not used, but is passed in case it
 
270
   is needed.  If ptr is NULL, return without taking any action. */
 
271
void PNGAPI
 
272
png_free(png_structp png_ptr, png_voidp ptr)
 
273
{
 
274
   if (png_ptr == NULL || ptr == NULL)
 
275
      return;
 
276
 
 
277
#ifdef PNG_USER_MEM_SUPPORTED
 
278
   if (png_ptr->free_fn != NULL)
 
279
   {
 
280
      (*(png_ptr->free_fn))(png_ptr, ptr);
 
281
      return;
 
282
   }
 
283
   else png_free_default(png_ptr, ptr);
 
284
}
 
285
 
 
286
void PNGAPI
 
287
png_free_default(png_structp png_ptr, png_voidp ptr)
 
288
{
 
289
#endif /* PNG_USER_MEM_SUPPORTED */
 
290
 
 
291
   if (png_ptr->offset_table != NULL)
 
292
   {
 
293
      int i;
 
294
 
 
295
      for (i = 0; i < png_ptr->offset_table_count; i++)
 
296
      {
 
297
         if (ptr == png_ptr->offset_table_ptr[i])
 
298
         {
 
299
            ptr = NULL;
 
300
            png_ptr->offset_table_count_free++;
 
301
            break;
 
302
         }
 
303
      }
 
304
      if (png_ptr->offset_table_count_free == png_ptr->offset_table_count)
 
305
      {
 
306
         farfree(png_ptr->offset_table);
 
307
         farfree(png_ptr->offset_table_ptr);
 
308
         png_ptr->offset_table = NULL;
 
309
         png_ptr->offset_table_ptr = NULL;
 
310
      }
 
311
   }
 
312
 
 
313
   if (ptr != NULL)
 
314
   {
 
315
      farfree(ptr);
 
316
   }
 
317
}
 
318
 
 
319
#else /* Not the Borland DOS special memory handler */
 
320
 
 
321
/* Allocate memory for a png_struct or a png_info.  The malloc and
 
322
   memset can be replaced by a single call to calloc() if this is thought
 
323
   to improve performance noticably. */
 
324
png_voidp /* PRIVATE */
 
325
png_create_struct(int type)
 
326
{
 
327
#ifdef PNG_USER_MEM_SUPPORTED
 
328
   return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));
 
329
}
 
330
 
 
331
/* Allocate memory for a png_struct or a png_info.  The malloc and
 
332
   memset can be replaced by a single call to calloc() if this is thought
 
333
   to improve performance noticably. */
 
334
png_voidp /* PRIVATE */
 
335
png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
 
336
{
 
337
#endif /* PNG_USER_MEM_SUPPORTED */
 
338
   png_size_t size;
 
339
   png_voidp struct_ptr;
 
340
 
 
341
   if (type == PNG_STRUCT_INFO)
 
342
      size = png_sizeof(png_info);
 
343
   else if (type == PNG_STRUCT_PNG)
 
344
      size = png_sizeof(png_struct);
 
345
   else
 
346
      return (NULL);
 
347
 
 
348
#ifdef PNG_USER_MEM_SUPPORTED
 
349
   if(malloc_fn != NULL)
 
350
   {
 
351
      png_struct dummy_struct;
 
352
      png_structp png_ptr = &dummy_struct;
 
353
      png_ptr->mem_ptr=mem_ptr;
 
354
      struct_ptr = (*(malloc_fn))(png_ptr, size);
 
355
      if (struct_ptr != NULL)
 
356
         png_memset(struct_ptr, 0, size);
 
357
      return (struct_ptr);
 
358
   }
 
359
#endif /* PNG_USER_MEM_SUPPORTED */
 
360
 
 
361
#if defined(__TURBOC__) && !defined(__FLAT__)
 
362
   struct_ptr = (png_voidp)farmalloc(size);
 
363
#else
 
364
# if defined(_MSC_VER) && defined(MAXSEG_64K)
 
365
   struct_ptr = (png_voidp)halloc(size,1);
 
366
# else
 
367
   struct_ptr = (png_voidp)malloc(size);
 
368
# endif
 
369
#endif
 
370
   if (struct_ptr != NULL)
 
371
      png_memset(struct_ptr, 0, size);
 
372
 
 
373
   return (struct_ptr);
 
374
}
 
375
 
 
376
 
 
377
/* Free memory allocated by a png_create_struct() call */
 
378
void /* PRIVATE */
 
379
png_destroy_struct(png_voidp struct_ptr)
 
380
{
 
381
#ifdef PNG_USER_MEM_SUPPORTED
 
382
   png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL);
 
383
}
 
384
 
 
385
/* Free memory allocated by a png_create_struct() call */
 
386
void /* PRIVATE */
 
387
png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
 
388
    png_voidp mem_ptr)
 
389
{
 
390
#endif /* PNG_USER_MEM_SUPPORTED */
 
391
   if (struct_ptr != NULL)
 
392
   {
 
393
#ifdef PNG_USER_MEM_SUPPORTED
 
394
      if(free_fn != NULL)
 
395
      {
 
396
         png_struct dummy_struct;
 
397
         png_structp png_ptr = &dummy_struct;
 
398
         png_ptr->mem_ptr=mem_ptr;
 
399
         (*(free_fn))(png_ptr, struct_ptr);
 
400
         return;
 
401
      }
 
402
#endif /* PNG_USER_MEM_SUPPORTED */
 
403
#if defined(__TURBOC__) && !defined(__FLAT__)
 
404
      farfree(struct_ptr);
 
405
#else
 
406
# if defined(_MSC_VER) && defined(MAXSEG_64K)
 
407
      hfree(struct_ptr);
 
408
# else
 
409
      free(struct_ptr);
 
410
# endif
 
411
#endif
 
412
   }
 
413
}
 
414
 
 
415
/* Allocate memory.  For reasonable files, size should never exceed
 
416
   64K.  However, zlib may allocate more then 64K if you don't tell
 
417
   it not to.  See zconf.h and png.h for more information.  zlib does
 
418
   need to allocate exactly 64K, so whatever you call here must
 
419
   have the ability to do that. */
 
420
 
 
421
png_voidp PNGAPI
 
422
png_malloc(png_structp png_ptr, png_uint_32 size)
 
423
{
 
424
   png_voidp ret;
 
425
 
 
426
#ifdef PNG_USER_MEM_SUPPORTED
 
427
   if (png_ptr == NULL || size == 0)
 
428
      return (NULL);
 
429
 
 
430
   if(png_ptr->malloc_fn != NULL)
 
431
       ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
 
432
   else
 
433
       ret = (png_malloc_default(png_ptr, size));
 
434
   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 
435
       png_error(png_ptr, "Out of Memory!");
 
436
   return (ret);
 
437
}
 
438
 
 
439
png_voidp PNGAPI
 
440
png_malloc_default(png_structp png_ptr, png_uint_32 size)
 
441
{
 
442
   png_voidp ret;
 
443
#endif /* PNG_USER_MEM_SUPPORTED */
 
444
 
 
445
   if (png_ptr == NULL || size == 0)
 
446
      return (NULL);
 
447
 
 
448
#ifdef PNG_MAX_MALLOC_64K
 
449
   if (size > (png_uint_32)65536L)
 
450
   {
 
451
#ifndef PNG_USER_MEM_SUPPORTED
 
452
      if(png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 
453
         png_error(png_ptr, "Cannot Allocate > 64K");
 
454
      else
 
455
#endif
 
456
         return NULL;
 
457
   }
 
458
#endif
 
459
 
 
460
 /* Check for overflow */
 
461
#if defined(__TURBOC__) && !defined(__FLAT__)
 
462
 if (size != (unsigned long)size)
 
463
   ret = NULL;
 
464
 else
 
465
   ret = farmalloc(size);
 
466
#else
 
467
# if defined(_MSC_VER) && defined(MAXSEG_64K)
 
468
 if (size != (unsigned long)size)
 
469
   ret = NULL;
 
470
 else
 
471
   ret = halloc(size, 1);
 
472
# else
 
473
 if (size != (size_t)size)
 
474
   ret = NULL;
 
475
 else
 
476
   ret = malloc((size_t)size);
 
477
# endif
 
478
#endif
 
479
 
 
480
#ifndef PNG_USER_MEM_SUPPORTED
 
481
   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
 
482
      png_error(png_ptr, "Out of Memory");
 
483
#endif
 
484
 
 
485
   return (ret);
 
486
}
 
487
 
 
488
/* Free a pointer allocated by png_malloc().  If ptr is NULL, return
 
489
   without taking any action. */
 
490
void PNGAPI
 
491
png_free(png_structp png_ptr, png_voidp ptr)
 
492
{
 
493
   if (png_ptr == NULL || ptr == NULL)
 
494
      return;
 
495
 
 
496
#ifdef PNG_USER_MEM_SUPPORTED
 
497
   if (png_ptr->free_fn != NULL)
 
498
   {
 
499
      (*(png_ptr->free_fn))(png_ptr, ptr);
 
500
      return;
 
501
   }
 
502
   else png_free_default(png_ptr, ptr);
 
503
}
 
504
void PNGAPI
 
505
png_free_default(png_structp png_ptr, png_voidp ptr)
 
506
{
 
507
   if (png_ptr == NULL || ptr == NULL)
 
508
      return;
 
509
 
 
510
#endif /* PNG_USER_MEM_SUPPORTED */
 
511
 
 
512
#if defined(__TURBOC__) && !defined(__FLAT__)
 
513
   farfree(ptr);
 
514
#else
 
515
# if defined(_MSC_VER) && defined(MAXSEG_64K)
 
516
   hfree(ptr);
 
517
# else
 
518
   free(ptr);
 
519
# endif
 
520
#endif
 
521
}
 
522
 
 
523
#endif /* Not Borland DOS special memory handler */
 
524
 
 
525
#if defined(PNG_1_0_X)
 
526
#  define png_malloc_warn png_malloc
 
527
#else
 
528
/* This function was added at libpng version 1.2.3.  The png_malloc_warn()
 
529
 * function will set up png_malloc() to issue a png_warning and return NULL
 
530
 * instead of issuing a png_error, if it fails to allocate the requested
 
531
 * memory.
 
532
 */
 
533
png_voidp PNGAPI
 
534
png_malloc_warn(png_structp png_ptr, png_uint_32 size)
 
535
{
 
536
   png_voidp ptr;
 
537
   png_uint_32 save_flags=png_ptr->flags;
 
538
 
 
539
   png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
 
540
   ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);
 
541
   png_ptr->flags=save_flags;
 
542
   return(ptr);
 
543
}
 
544
#endif
 
545
 
 
546
png_voidp PNGAPI
 
547
png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2,
 
548
   png_uint_32 length)
 
549
{
 
550
   png_size_t size;
 
551
 
 
552
   size = (png_size_t)length;
 
553
   if ((png_uint_32)size != length)
 
554
      png_error(png_ptr,"Overflow in png_memcpy_check.");
 
555
 
 
556
   return(png_memcpy (s1, s2, size));
 
557
}
 
558
 
 
559
png_voidp PNGAPI
 
560
png_memset_check (png_structp png_ptr, png_voidp s1, int value,
 
561
   png_uint_32 length)
 
562
{
 
563
   png_size_t size;
 
564
 
 
565
   size = (png_size_t)length;
 
566
   if ((png_uint_32)size != length)
 
567
      png_error(png_ptr,"Overflow in png_memset_check.");
 
568
 
 
569
   return (png_memset (s1, value, size));
 
570
 
 
571
}
 
572
 
 
573
#ifdef PNG_USER_MEM_SUPPORTED
 
574
/* This function is called when the application wants to use another method
 
575
 * of allocating and freeing memory.
 
576
 */
 
577
void PNGAPI
 
578
png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
 
579
  malloc_fn, png_free_ptr free_fn)
 
580
{
 
581
   png_ptr->mem_ptr = mem_ptr;
 
582
   png_ptr->malloc_fn = malloc_fn;
 
583
   png_ptr->free_fn = free_fn;
 
584
}
 
585
 
 
586
/* This function returns a pointer to the mem_ptr associated with the user
 
587
 * functions.  The application should free any memory associated with this
 
588
 * pointer before png_write_destroy and png_read_destroy are called.
 
589
 */
 
590
png_voidp PNGAPI
 
591
png_get_mem_ptr(png_structp png_ptr)
 
592
{
 
593
   return ((png_voidp)png_ptr->mem_ptr);
 
594
}
 
595
#endif /* PNG_USER_MEM_SUPPORTED */