pngmem.c 17.3 KB
Newer Older
wester committed
1 2 3

/* pngmem.c - stub functions for memory allocation
 *
wester committed
4 5
 * Last changed in libpng 1.5.13 [September 27, 2012]
 * Copyright (c) 1998-2002,2004,2006-2012 Glenn Randers-Pehrson
wester committed
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
 *
 * This code is released under the libpng license.
 * For conditions of distribution and use, see the disclaimer
 * and license in png.h
 *
 * This file provides a location for all memory allocation.  Users who
 * need special memory handling are expected to supply replacement
 * functions for png_malloc() and png_free(), and to use
 * png_create_read_struct_2() and png_create_write_struct_2() to
 * identify the replacement functions.
 */

#include "pngpriv.h"

#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
wester committed
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

/* Borland DOS special memory handler */
#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
/* If you change this, be sure to change the one in png.h also */

/* Allocate memory for a png_struct.  The malloc and memset can be replaced
   by a single call to calloc() if this is thought to improve performance. */
PNG_FUNCTION(png_voidp /* PRIVATE */,
png_create_struct,(int type),PNG_ALLOCATED)
{
#  ifdef PNG_USER_MEM_SUPPORTED
   return (png_create_struct_2(type, NULL, NULL));
}

/* Alternate version of png_create_struct, for use with user-defined malloc. */
PNG_FUNCTION(png_voidp /* PRIVATE */,
png_create_struct_2,(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr),
   PNG_ALLOCATED)
{
#  endif /* PNG_USER_MEM_SUPPORTED */
   png_size_t size;
   png_voidp struct_ptr;

   if (type == PNG_STRUCT_INFO)
      size = png_sizeof(png_info);

   else if (type == PNG_STRUCT_PNG)
      size = png_sizeof(png_struct);

   else
      return (png_get_copyright(NULL));

#  ifdef PNG_USER_MEM_SUPPORTED
   if (malloc_fn != NULL)
   {
      png_struct dummy_struct;
      png_memset(&dummy_struct, 0, sizeof dummy_struct);
      dummy_struct.mem_ptr=mem_ptr;
      struct_ptr = (*(malloc_fn))(&dummy_struct, (png_alloc_size_t)size);
   }

   else
#  endif /* PNG_USER_MEM_SUPPORTED */
   struct_ptr = (png_voidp)farmalloc(size);
   if (struct_ptr != NULL)
      png_memset(struct_ptr, 0, size);

   return (struct_ptr);
}

/* Free memory allocated by a png_create_struct() call */
wester committed
74
void /* PRIVATE */
wester committed
75
png_destroy_struct(png_voidp struct_ptr)
wester committed
76
{
wester committed
77 78 79 80 81 82 83 84 85 86 87
#  ifdef PNG_USER_MEM_SUPPORTED
   png_destroy_struct_2(struct_ptr, NULL, NULL);
}

/* Free memory allocated by a png_create_struct() call */
void /* PRIVATE */
png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
    png_voidp mem_ptr)
{
#  endif
   if (struct_ptr != NULL)
wester committed
88
   {
wester committed
89 90 91 92 93 94 95 96 97 98 99 100
#  ifdef PNG_USER_MEM_SUPPORTED
      if (free_fn != NULL)
      {
         png_struct dummy_struct;
         png_memset(&dummy_struct, 0, sizeof dummy_struct);
         dummy_struct.mem_ptr=mem_ptr;
         (*(free_fn))(&dummy_struct, struct_ptr);
         return;
      }

#  endif /* PNG_USER_MEM_SUPPORTED */
      farfree (struct_ptr);
wester committed
101 102 103 104 105
   }
}

/* Allocate memory.  For reasonable files, size should never exceed
 * 64K.  However, zlib may allocate more than 64K if you don't tell
wester committed
106
 * it not to.  See zconf.h and png.h for more information. zlib does
wester committed
107 108
 * need to allocate exactly 64K, so whatever you call here must
 * have the ability to do that.
wester committed
109 110 111 112 113 114 115 116 117 118 119 120 121
 *
 * Borland seems to have a problem in DOS mode for exactly 64K.
 * It gives you a segment with an offset of 8 (perhaps to store its
 * memory stuff).  zlib doesn't like this at all, so we have to
 * detect and deal with it.  This code should not be needed in
 * Windows or OS/2 modes, and only in 16 bit mode.  This code has
 * been updated by Alexander Lehmann for version 0.89 to waste less
 * memory.
 *
 * Note that we can't use png_size_t for the "size" declaration,
 * since on some systems a png_size_t is a 16-bit quantity, and as a
 * result, we would be truncating potentially larger memory requests
 * (which should cause a fatal error) and introducing major problems.
wester committed
122 123
 */
PNG_FUNCTION(png_voidp,PNGAPI
wester committed
124
png_calloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
wester committed
125 126 127
{
   png_voidp ret;

wester committed
128
   ret = (png_malloc(png_ptr, size));
wester committed
129 130

   if (ret != NULL)
wester committed
131
      png_memset(ret,0,(png_size_t)size);
wester committed
132

wester committed
133
   return (ret);
wester committed
134 135
}

wester committed
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
PNG_FUNCTION(png_voidp,PNGAPI
png_malloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
{
   png_voidp ret;

   if (png_ptr == NULL || size == 0)
      return (NULL);

#  ifdef PNG_USER_MEM_SUPPORTED
   if (png_ptr->malloc_fn != NULL)
      ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, size));

   else
      ret = (png_malloc_default(png_ptr, size));

   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
       png_error(png_ptr, "Out of memory");

   return (ret);
}

PNG_FUNCTION(png_voidp,PNGAPI
png_malloc_default,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
wester committed
159
{
wester committed
160 161 162 163 164 165 166 167
   png_voidp ret;
#  endif /* PNG_USER_MEM_SUPPORTED */

   if (png_ptr == NULL || size == 0)
      return (NULL);

#  ifdef PNG_MAX_MALLOC_64K
   if (size > (png_uint_32)65536L)
wester committed
168
   {
wester committed
169 170 171
      png_warning(png_ptr, "Cannot Allocate > 64K");
      ret = NULL;
   }
wester committed
172

wester committed
173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
   else
#  endif

   if (size != (size_t)size)
      ret = NULL;

   else if (size == (png_uint_32)65536L)
   {
      if (png_ptr->offset_table == NULL)
      {
         /* Try to see if we need to do any of this fancy stuff */
         ret = farmalloc(size);
         if (ret == NULL || ((png_size_t)ret & 0xffff))
         {
            int num_blocks;
            png_uint_32 total_size;
            png_bytep table;
            int i, mem_level, window_bits;
            png_byte huge * hptr;
            int window_bits

            if (ret != NULL)
            {
               farfree(ret);
               ret = NULL;
            }

            window_bits =
                png_ptr->zlib_window_bits >= png_ptr->zlib_text_window_bits ?
                png_ptr->zlib_window_bits : png_ptr->zlib_text_window_bits;

            if (window_bits > 14)
               num_blocks = (int)(1 << (window_bits - 14));

            else
               num_blocks = 1;

            mem_level =
                png_ptr->zlib_mem_level >= png_ptr->zlib_text_mem_level ?
                png_ptr->zlib_mem_level : png_ptr->zlib_text_mem_level;

            if (mem_level >= 7)
               num_blocks += (int)(1 << (mem_level - 7));

            else
               num_blocks++;

            total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;

            table = farmalloc(total_size);

            if (table == NULL)
            {
#  ifndef PNG_USER_MEM_SUPPORTED
               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
                  png_error(png_ptr, "Out Of Memory"); /* Note "O", "M" */

               else
                  png_warning(png_ptr, "Out Of Memory");
#  endif
               return (NULL);
            }

            if ((png_size_t)table & 0xfff0)
            {
#  ifndef PNG_USER_MEM_SUPPORTED
               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
                  png_error(png_ptr,
                    "Farmalloc didn't return normalized pointer");

               else
                  png_warning(png_ptr,
                    "Farmalloc didn't return normalized pointer");
#  endif
               return (NULL);
            }

            png_ptr->offset_table = table;
            png_ptr->offset_table_ptr = farmalloc(num_blocks *
               png_sizeof(png_bytep));

            if (png_ptr->offset_table_ptr == NULL)
            {
#  ifndef PNG_USER_MEM_SUPPORTED
               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
                  png_error(png_ptr, "Out Of memory"); /* Note "O", "m" */

               else
                  png_warning(png_ptr, "Out Of memory");
#  endif
               return (NULL);
            }

            hptr = (png_byte huge *)table;
            if ((png_size_t)hptr & 0xf)
            {
               hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
               hptr = hptr + 16L;  /* "hptr += 16L" fails on Turbo C++ 3.0 */
            }

            for (i = 0; i < num_blocks; i++)
            {
               png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
               hptr = hptr + (png_uint_32)65536L;  /* "+=" fails on TC++3.0 */
            }

            png_ptr->offset_table_number = num_blocks;
            png_ptr->offset_table_count = 0;
            png_ptr->offset_table_count_free = 0;
         }
      }

      if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
      {
#  ifndef PNG_USER_MEM_SUPPORTED
         if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
            png_error(png_ptr, "Out of Memory"); /* Note "O" and "M" */

         else
            png_warning(png_ptr, "Out of Memory");
#  endif
         return (NULL);
      }

      ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
wester committed
298 299 300
   }

   else
wester committed
301 302 303 304 305 306 307 308 309 310 311 312 313 314
      ret = farmalloc(size);

#  ifndef PNG_USER_MEM_SUPPORTED
   if (ret == NULL)
   {
      if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
         png_error(png_ptr, "Out of memory"); /* Note "o" and "m" */

      else
         png_warning(png_ptr, "Out of memory"); /* Note "o" and "m" */
   }
#  endif

   return (ret);
wester committed
315 316
}

wester committed
317 318 319
/* Free a pointer allocated by png_malloc().  In the default
 * configuration, png_ptr is not used, but is passed in case it
 * is needed.  If ptr is NULL, return without taking any action.
wester committed
320
 */
wester committed
321 322
void PNGAPI
png_free(png_structp png_ptr, png_voidp ptr)
wester committed
323
{
wester committed
324 325
   if (png_ptr == NULL || ptr == NULL)
      return;
wester committed
326

wester committed
327 328 329 330 331 332
#  ifdef PNG_USER_MEM_SUPPORTED
   if (png_ptr->free_fn != NULL)
   {
      (*(png_ptr->free_fn))(png_ptr, ptr);
      return;
   }
wester committed
333

wester committed
334 335
   else
      png_free_default(png_ptr, ptr);
wester committed
336 337
}

wester committed
338 339
void PNGAPI
png_free_default(png_structp png_ptr, png_voidp ptr)
wester committed
340
{
wester committed
341 342 343 344 345 346 347 348
#  endif /* PNG_USER_MEM_SUPPORTED */

   if (png_ptr == NULL || ptr == NULL)
      return;

   if (png_ptr->offset_table != NULL)
   {
      int i;
wester committed
349

wester committed
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381
      for (i = 0; i < png_ptr->offset_table_count; i++)
      {
         if (ptr == png_ptr->offset_table_ptr[i])
         {
            ptr = NULL;
            png_ptr->offset_table_count_free++;
            break;
         }
      }
      if (png_ptr->offset_table_count_free == png_ptr->offset_table_count)
      {
         farfree(png_ptr->offset_table);
         farfree(png_ptr->offset_table_ptr);
         png_ptr->offset_table = NULL;
         png_ptr->offset_table_ptr = NULL;
      }
   }

   if (ptr != NULL)
      farfree(ptr);
}

#else /* Not the Borland DOS special memory handler */

/* Allocate memory for a png_struct or a png_info.  The malloc and
   memset can be replaced by a single call to calloc() if this is thought
   to improve performance noticably. */
PNG_FUNCTION(png_voidp /* PRIVATE */,
png_create_struct,(int type),PNG_ALLOCATED)
{
#  ifdef PNG_USER_MEM_SUPPORTED
   return (png_create_struct_2(type, NULL, NULL));
wester committed
382 383
}

wester committed
384 385 386
/* Allocate memory for a png_struct or a png_info.  The malloc and
   memset can be replaced by a single call to calloc() if this is thought
   to improve performance noticably. */
wester committed
387
PNG_FUNCTION(png_voidp /* PRIVATE */,
wester committed
388 389
png_create_struct_2,(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr),
   PNG_ALLOCATED)
wester committed
390
{
wester committed
391 392 393 394 395 396 397 398 399 400 401 402 403 404 405
#  endif /* PNG_USER_MEM_SUPPORTED */
   png_size_t size;
   png_voidp struct_ptr;

   if (type == PNG_STRUCT_INFO)
      size = png_sizeof(png_info);

   else if (type == PNG_STRUCT_PNG)
      size = png_sizeof(png_struct);

   else
      return (NULL);

#  ifdef PNG_USER_MEM_SUPPORTED
   if (malloc_fn != NULL)
wester committed
406
   {
wester committed
407 408 409 410
      png_struct dummy_struct;
      png_structp png_ptr = &dummy_struct;
      png_ptr->mem_ptr=mem_ptr;
      struct_ptr = (*(malloc_fn))(png_ptr, size);
wester committed
411

wester committed
412 413
      if (struct_ptr != NULL)
         png_memset(struct_ptr, 0, size);
wester committed
414

wester committed
415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433
      return (struct_ptr);
   }
#  endif /* PNG_USER_MEM_SUPPORTED */

#  if defined(__TURBOC__) && !defined(__FLAT__)
   struct_ptr = (png_voidp)farmalloc(size);
#  else
#    if defined(_MSC_VER) && defined(MAXSEG_64K)
   struct_ptr = (png_voidp)halloc(size, 1);
#    else
   struct_ptr = (png_voidp)malloc(size);
#    endif
#  endif

   if (struct_ptr != NULL)
      png_memset(struct_ptr, 0, size);

   return (struct_ptr);
}
wester committed
434

wester committed
435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459

/* Free memory allocated by a png_create_struct() call */
void /* PRIVATE */
png_destroy_struct(png_voidp struct_ptr)
{
#  ifdef PNG_USER_MEM_SUPPORTED
   png_destroy_struct_2(struct_ptr, NULL, NULL);
}

/* Free memory allocated by a png_create_struct() call */
void /* PRIVATE */
png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
    png_voidp mem_ptr)
{
#  endif /* PNG_USER_MEM_SUPPORTED */
   if (struct_ptr != NULL)
   {
#  ifdef PNG_USER_MEM_SUPPORTED
      if (free_fn != NULL)
      {
         png_struct dummy_struct;
         png_structp png_ptr = &dummy_struct;
         png_ptr->mem_ptr=mem_ptr;
         (*(free_fn))(png_ptr, struct_ptr);
         return;
wester committed
460
      }
wester committed
461 462 463 464 465 466 467
#  endif /* PNG_USER_MEM_SUPPORTED */
#  if defined(__TURBOC__) && !defined(__FLAT__)
      farfree(struct_ptr);

#  else
#    if defined(_MSC_VER) && defined(MAXSEG_64K)
      hfree(struct_ptr);
wester committed
468

wester committed
469 470 471 472 473 474
#    else
      free(struct_ptr);

#    endif
#  endif
   }
wester committed
475 476
}

wester committed
477 478 479 480 481
/* Allocate memory.  For reasonable files, size should never exceed
 * 64K.  However, zlib may allocate more than 64K if you don't tell
 * it not to.  See zconf.h and png.h for more information.  zlib does
 * need to allocate exactly 64K, so whatever you call here must
 * have the ability to do that.
wester committed
482
 */
wester committed
483

wester committed
484
PNG_FUNCTION(png_voidp,PNGAPI
wester committed
485
png_calloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
wester committed
486 487 488
{
   png_voidp ret;

wester committed
489
   ret = (png_malloc(png_ptr, size));
wester committed
490

wester committed
491 492
   if (ret != NULL)
      png_memset(ret,0,(png_size_t)size);
wester committed
493

wester committed
494
   return (ret);
wester committed
495 496 497
}

PNG_FUNCTION(png_voidp,PNGAPI
wester committed
498
png_malloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
wester committed
499 500 501
{
   png_voidp ret;

wester committed
502 503 504
#  ifdef PNG_USER_MEM_SUPPORTED
   if (png_ptr == NULL || size == 0)
      return (NULL);
wester committed
505

wester committed
506 507
   if (png_ptr->malloc_fn != NULL)
      ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
wester committed
508

wester committed
509 510 511 512 513
   else
      ret = (png_malloc_default(png_ptr, size));

   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
       png_error(png_ptr, "Out of Memory");
wester committed
514

wester committed
515
   return (ret);
wester committed
516 517 518
}

PNG_FUNCTION(png_voidp,PNGAPI
wester committed
519
png_malloc_default,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
wester committed
520
{
wester committed
521 522
   png_voidp ret;
#  endif /* PNG_USER_MEM_SUPPORTED */
wester committed
523

wester committed
524 525
   if (png_ptr == NULL || size == 0)
      return (NULL);
wester committed
526

wester committed
527 528 529 530 531 532 533 534 535 536
#  ifdef PNG_MAX_MALLOC_64K
   if (size > (png_uint_32)65536L)
   {
#    ifndef PNG_USER_MEM_SUPPORTED
      if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
         png_error(png_ptr, "Cannot Allocate > 64K");

      else
#    endif
         return NULL;
wester committed
537
   }
wester committed
538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559
#  endif

   /* Check for overflow */
#  if defined(__TURBOC__) && !defined(__FLAT__)

   if (size != (unsigned long)size)
      ret = NULL;

   else
      ret = farmalloc(size);

#  else
#    if defined(_MSC_VER) && defined(MAXSEG_64K)
   if (size != (unsigned long)size)
      ret = NULL;

   else
      ret = halloc(size, 1);

#    else
   if (size != (size_t)size)
      ret = NULL;
wester committed
560

wester committed
561 562 563 564 565 566 567 568 569 570 571
   else
      ret = malloc((size_t)size);
#    endif
#  endif

#  ifndef PNG_USER_MEM_SUPPORTED
   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
      png_error(png_ptr, "Out of Memory");
#  endif

   return (ret);
wester committed
572 573 574 575 576 577
}

/* Free a pointer allocated by png_malloc().  If ptr is NULL, return
 * without taking any action.
 */
void PNGAPI
wester committed
578
png_free(png_structp png_ptr, png_voidp ptr)
wester committed
579 580 581 582
{
   if (png_ptr == NULL || ptr == NULL)
      return;

wester committed
583
#  ifdef PNG_USER_MEM_SUPPORTED
wester committed
584
   if (png_ptr->free_fn != NULL)
wester committed
585 586 587 588
   {
      (*(png_ptr->free_fn))(png_ptr, ptr);
      return;
   }
wester committed
589 590 591 592 593

   else
      png_free_default(png_ptr, ptr);
}

wester committed
594 595
void PNGAPI
png_free_default(png_structp png_ptr, png_voidp ptr)
wester committed
596 597 598 599
{
   if (png_ptr == NULL || ptr == NULL)
      return;

wester committed
600 601 602 603 604 605 606 607 608 609
#  endif /* PNG_USER_MEM_SUPPORTED */

#  if defined(__TURBOC__) && !defined(__FLAT__)
   farfree(ptr);

#  else
#    if defined(_MSC_VER) && defined(MAXSEG_64K)
   hfree(ptr);

#    else
wester committed
610
   free(ptr);
wester committed
611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634

#    endif
#  endif
}
#endif /* Not Borland DOS special memory handler */

/* This function was added at libpng version 1.2.3.  The png_malloc_warn()
 * function will set up png_malloc() to issue a png_warning and return NULL
 * instead of issuing a png_error, if it fails to allocate the requested
 * memory.
 */
PNG_FUNCTION(png_voidp,PNGAPI
png_malloc_warn,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
{
   png_voidp ptr;
   png_uint_32 save_flags;
   if (png_ptr == NULL)
      return (NULL);

   save_flags = png_ptr->flags;
   png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
   ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);
   png_ptr->flags=save_flags;
   return(ptr);
wester committed
635 636
}

wester committed
637

wester committed
638 639 640 641 642
#ifdef PNG_USER_MEM_SUPPORTED
/* This function is called when the application wants to use another method
 * of allocating and freeing memory.
 */
void PNGAPI
wester committed
643
png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
wester committed
644 645 646 647 648 649 650 651 652 653 654 655 656 657 658
  malloc_fn, png_free_ptr free_fn)
{
   if (png_ptr != NULL)
   {
      png_ptr->mem_ptr = mem_ptr;
      png_ptr->malloc_fn = malloc_fn;
      png_ptr->free_fn = free_fn;
   }
}

/* This function returns a pointer to the mem_ptr associated with the user
 * functions.  The application should free any memory associated with this
 * pointer before png_write_destroy and png_read_destroy are called.
 */
png_voidp PNGAPI
wester committed
659
png_get_mem_ptr(png_const_structp png_ptr)
wester committed
660 661
{
   if (png_ptr == NULL)
wester committed
662
      return (NULL);
wester committed
663

wester committed
664
   return ((png_voidp)png_ptr->mem_ptr);
wester committed
665
}
wester committed
666 667
#endif /* PNG_USER_MEM_SUPPORTED */
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */