pngmem.c 16.5 KB
Newer Older
dimitri's avatar
dimitri committed
1 2 3

/* pngmem.c - stub functions for memory allocation
 *
dimitri's avatar
dimitri committed
4
 * Last changed in libpng 1.2.13 November 13, 2006
dimitri's avatar
dimitri committed
5
 * For conditions of distribution and use, see copyright notice in png.h
dimitri's avatar
dimitri committed
6
 * Copyright (c) 1998-2006 Glenn Randers-Pehrson
dimitri's avatar
dimitri committed
7 8 9 10 11 12 13 14 15 16 17 18 19
 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
 *
 * 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.
 */

#define PNG_INTERNAL
#include "png.h"

dimitri's avatar
dimitri committed
20 21
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)

dimitri's avatar
dimitri committed
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
/* 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_voidp /* PRIVATE */
png_create_struct(int type)
{
#ifdef PNG_USER_MEM_SUPPORTED
   return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));
}

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

   if (type == PNG_STRUCT_INFO)
dimitri's avatar
dimitri committed
44
     size = png_sizeof(png_info);
dimitri's avatar
dimitri committed
45
   else if (type == PNG_STRUCT_PNG)
dimitri's avatar
dimitri committed
46
     size = png_sizeof(png_struct);
dimitri's avatar
dimitri committed
47
   else
dimitri's avatar
dimitri committed
48
     return (png_get_copyright(NULL));
dimitri's avatar
dimitri committed
49 50 51 52 53 54 55 56 57 58 59

#ifdef PNG_USER_MEM_SUPPORTED
   if(malloc_fn != NULL)
   {
      png_struct dummy_struct;
      png_structp png_ptr = &dummy_struct;
      png_ptr->mem_ptr=mem_ptr;
      struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size);
   }
   else
#endif /* PNG_USER_MEM_SUPPORTED */
dimitri's avatar
dimitri committed
60
      struct_ptr = (png_voidp)farmalloc(size);
dimitri's avatar
dimitri committed
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
   if (struct_ptr != NULL)
      png_memset(struct_ptr, 0, size);
   return (struct_ptr);
}

/* 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, png_free_ptr_NULL, png_voidp_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)
   {
#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;
      }
#endif /* PNG_USER_MEM_SUPPORTED */
      farfree (struct_ptr);
   }
}

/* Allocate memory.  For reasonable files, size should never exceed
 * 64K.  However, zlib may allocate more then 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.
 *
 * 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.
 */
dimitri's avatar
dimitri committed
115

dimitri's avatar
dimitri committed
116 117 118 119
png_voidp PNGAPI
png_malloc(png_structp png_ptr, png_uint_32 size)
{
   png_voidp ret;
dimitri's avatar
dimitri committed
120

dimitri's avatar
dimitri committed
121 122 123 124 125 126 127
   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, (png_size_t)size));
   else
dimitri's avatar
dimitri committed
128 129 130 131
       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);
dimitri's avatar
dimitri committed
132 133 134 135 136 137 138 139
}

png_voidp PNGAPI
png_malloc_default(png_structp png_ptr, png_uint_32 size)
{
   png_voidp ret;
#endif /* PNG_USER_MEM_SUPPORTED */

dimitri's avatar
dimitri committed
140 141 142
   if (png_ptr == NULL || size == 0)
      return (NULL);

dimitri's avatar
dimitri committed
143 144
#ifdef PNG_MAX_MALLOC_64K
   if (size > (png_uint_32)65536L)
dimitri's avatar
dimitri committed
145 146 147 148 149
   {
      png_warning(png_ptr, "Cannot Allocate > 64K");
      ret = NULL;
   }
   else
dimitri's avatar
dimitri committed
150 151
#endif

dimitri's avatar
dimitri committed
152 153 154
   if (size != (size_t)size)
     ret = NULL;
   else if (size == (png_uint_32)65536L)
dimitri's avatar
dimitri committed
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
   {
      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;
            png_byte huge * hptr;

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

            if(png_ptr->zlib_window_bits > 14)
               num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
            else
               num_blocks = 1;
            if (png_ptr->zlib_mem_level >= 7)
               num_blocks += (int)(1 << (png_ptr->zlib_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)
            {
dimitri's avatar
dimitri committed
189 190 191 192 193 194 195
#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);
dimitri's avatar
dimitri committed
196 197 198 199
            }

            if ((png_size_t)table & 0xfff0)
            {
dimitri's avatar
dimitri committed
200 201 202 203 204 205 206 207 208
#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);
dimitri's avatar
dimitri committed
209 210 211 212
            }

            png_ptr->offset_table = table;
            png_ptr->offset_table_ptr = farmalloc(num_blocks *
dimitri's avatar
dimitri committed
213
               png_sizeof (png_bytep));
dimitri's avatar
dimitri committed
214 215 216

            if (png_ptr->offset_table_ptr == NULL)
            {
dimitri's avatar
dimitri committed
217 218 219 220 221 222 223
#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);
dimitri's avatar
dimitri committed
224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
            }

            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)
dimitri's avatar
dimitri committed
245 246 247 248 249 250 251 252 253
      {
#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);
      }
dimitri's avatar
dimitri committed
254 255 256 257 258 259

      ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
   }
   else
      ret = farmalloc(size);

dimitri's avatar
dimitri committed
260
#ifndef PNG_USER_MEM_SUPPORTED
dimitri's avatar
dimitri committed
261 262
   if (ret == NULL)
   {
dimitri's avatar
dimitri committed
263 264 265 266
      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" */
dimitri's avatar
dimitri committed
267
   }
dimitri's avatar
dimitri committed
268
#endif
dimitri's avatar
dimitri committed
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

   return (ret);
}

/* 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. */
void PNGAPI
png_free(png_structp png_ptr, png_voidp ptr)
{
   if (png_ptr == NULL || ptr == NULL)
      return;

#ifdef PNG_USER_MEM_SUPPORTED
   if (png_ptr->free_fn != NULL)
   {
      (*(png_ptr->free_fn))(png_ptr, ptr);
      return;
   }
   else png_free_default(png_ptr, ptr);
}

void PNGAPI
png_free_default(png_structp png_ptr, png_voidp ptr)
{
#endif /* PNG_USER_MEM_SUPPORTED */

dimitri's avatar
dimitri committed
296 297
   if(png_ptr == NULL) return;

dimitri's avatar
dimitri committed
298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329
   if (png_ptr->offset_table != NULL)
   {
      int i;

      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
dimitri's avatar
dimitri committed
330
   to improve performance noticably. */
dimitri's avatar
dimitri committed
331 332 333 334 335 336 337 338 339
png_voidp /* PRIVATE */
png_create_struct(int type)
{
#ifdef PNG_USER_MEM_SUPPORTED
   return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));
}

/* 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
dimitri's avatar
dimitri committed
340
   to improve performance noticably. */
dimitri's avatar
dimitri committed
341 342 343 344 345 346 347 348
png_voidp /* PRIVATE */
png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
{
#endif /* PNG_USER_MEM_SUPPORTED */
   png_size_t size;
   png_voidp struct_ptr;

   if (type == PNG_STRUCT_INFO)
dimitri's avatar
dimitri committed
349
      size = png_sizeof(png_info);
dimitri's avatar
dimitri committed
350
   else if (type == PNG_STRUCT_PNG)
dimitri's avatar
dimitri committed
351
      size = png_sizeof(png_struct);
dimitri's avatar
dimitri committed
352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368
   else
      return (NULL);

#ifdef PNG_USER_MEM_SUPPORTED
   if(malloc_fn != NULL)
   {
      png_struct dummy_struct;
      png_structp png_ptr = &dummy_struct;
      png_ptr->mem_ptr=mem_ptr;
      struct_ptr = (*(malloc_fn))(png_ptr, size);
      if (struct_ptr != NULL)
         png_memset(struct_ptr, 0, size);
      return (struct_ptr);
   }
#endif /* PNG_USER_MEM_SUPPORTED */

#if defined(__TURBOC__) && !defined(__FLAT__)
dimitri's avatar
dimitri committed
369
   struct_ptr = (png_voidp)farmalloc(size);
dimitri's avatar
dimitri committed
370 371
#else
# if defined(_MSC_VER) && defined(MAXSEG_64K)
dimitri's avatar
dimitri committed
372
   struct_ptr = (png_voidp)halloc(size,1);
dimitri's avatar
dimitri committed
373
# else
dimitri's avatar
dimitri committed
374
   struct_ptr = (png_voidp)malloc(size);
dimitri's avatar
dimitri committed
375 376
# endif
#endif
dimitri's avatar
dimitri committed
377
   if (struct_ptr != NULL)
dimitri's avatar
dimitri committed
378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431
      png_memset(struct_ptr, 0, size);

   return (struct_ptr);
}


/* 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, png_free_ptr_NULL, png_voidp_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;
      }
#endif /* PNG_USER_MEM_SUPPORTED */
#if defined(__TURBOC__) && !defined(__FLAT__)
      farfree(struct_ptr);
#else
# if defined(_MSC_VER) && defined(MAXSEG_64K)
      hfree(struct_ptr);
# else
      free(struct_ptr);
# endif
#endif
   }
}

/* Allocate memory.  For reasonable files, size should never exceed
   64K.  However, zlib may allocate more then 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. */

png_voidp PNGAPI
png_malloc(png_structp png_ptr, png_uint_32 size)
{
   png_voidp ret;
dimitri's avatar
dimitri committed
432 433

#ifdef PNG_USER_MEM_SUPPORTED
dimitri's avatar
dimitri committed
434 435 436 437
   if (png_ptr == NULL || size == 0)
      return (NULL);

   if(png_ptr->malloc_fn != NULL)
dimitri's avatar
dimitri committed
438
       ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
dimitri's avatar
dimitri committed
439
   else
dimitri's avatar
dimitri committed
440 441 442 443
       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);
dimitri's avatar
dimitri committed
444
}
dimitri's avatar
dimitri committed
445 446

png_voidp PNGAPI
dimitri's avatar
dimitri committed
447 448 449 450 451
png_malloc_default(png_structp png_ptr, png_uint_32 size)
{
   png_voidp ret;
#endif /* PNG_USER_MEM_SUPPORTED */

dimitri's avatar
dimitri committed
452 453 454
   if (png_ptr == NULL || size == 0)
      return (NULL);

dimitri's avatar
dimitri committed
455 456
#ifdef PNG_MAX_MALLOC_64K
   if (size > (png_uint_32)65536L)
dimitri's avatar
dimitri committed
457 458 459 460 461 462 463 464
   {
#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;
   }
dimitri's avatar
dimitri committed
465 466
#endif

dimitri's avatar
dimitri committed
467
 /* Check for overflow */
dimitri's avatar
dimitri committed
468
#if defined(__TURBOC__) && !defined(__FLAT__)
dimitri's avatar
dimitri committed
469 470 471
 if (size != (unsigned long)size)
   ret = NULL;
 else
dimitri's avatar
dimitri committed
472 473 474
   ret = farmalloc(size);
#else
# if defined(_MSC_VER) && defined(MAXSEG_64K)
dimitri's avatar
dimitri committed
475 476 477
 if (size != (unsigned long)size)
   ret = NULL;
 else
dimitri's avatar
dimitri committed
478 479
   ret = halloc(size, 1);
# else
dimitri's avatar
dimitri committed
480 481 482
 if (size != (size_t)size)
   ret = NULL;
 else
dimitri's avatar
dimitri committed
483 484 485 486
   ret = malloc((size_t)size);
# endif
#endif

dimitri's avatar
dimitri committed
487 488
#ifndef PNG_USER_MEM_SUPPORTED
   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
dimitri's avatar
dimitri committed
489
      png_error(png_ptr, "Out of Memory");
dimitri's avatar
dimitri committed
490
#endif
dimitri's avatar
dimitri committed
491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510

   return (ret);
}

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

#ifdef PNG_USER_MEM_SUPPORTED
   if (png_ptr->free_fn != NULL)
   {
      (*(png_ptr->free_fn))(png_ptr, ptr);
      return;
   }
   else png_free_default(png_ptr, ptr);
}
dimitri's avatar
dimitri committed
511
void PNGAPI
dimitri's avatar
dimitri committed
512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531
png_free_default(png_structp png_ptr, png_voidp ptr)
{
   if (png_ptr == NULL || ptr == NULL)
      return;

#endif /* PNG_USER_MEM_SUPPORTED */

#if defined(__TURBOC__) && !defined(__FLAT__)
   farfree(ptr);
#else
# if defined(_MSC_VER) && defined(MAXSEG_64K)
   hfree(ptr);
# else
   free(ptr);
# endif
#endif
}

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

dimitri's avatar
dimitri committed
532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
#if defined(PNG_1_0_X)
#  define png_malloc_warn png_malloc
#else
/* 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_voidp PNGAPI
png_malloc_warn(png_structp png_ptr, png_uint_32 size)
{
   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);
}
#endif

png_voidp PNGAPI
dimitri's avatar
dimitri committed
556 557 558 559 560 561 562 563 564 565 566 567
png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2,
   png_uint_32 length)
{
   png_size_t size;

   size = (png_size_t)length;
   if ((png_uint_32)size != length)
      png_error(png_ptr,"Overflow in png_memcpy_check.");

   return(png_memcpy (s1, s2, size));
}

dimitri's avatar
dimitri committed
568
png_voidp PNGAPI
dimitri's avatar
dimitri committed
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
png_memset_check (png_structp png_ptr, png_voidp s1, int value,
   png_uint_32 length)
{
   png_size_t size;

   size = (png_size_t)length;
   if ((png_uint_32)size != length)
      png_error(png_ptr,"Overflow in png_memset_check.");

   return (png_memset (s1, value, size));

}

#ifdef PNG_USER_MEM_SUPPORTED
/* This function is called when the application wants to use another method
 * of allocating and freeing memory.
 */
void PNGAPI
png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
  malloc_fn, png_free_ptr free_fn)
{
dimitri's avatar
dimitri committed
590
   if(png_ptr != NULL) {
dimitri's avatar
dimitri committed
591 592 593
   png_ptr->mem_ptr = mem_ptr;
   png_ptr->malloc_fn = malloc_fn;
   png_ptr->free_fn = free_fn;
dimitri's avatar
dimitri committed
594
   }
dimitri's avatar
dimitri committed
595 596 597 598 599 600 601 602 603
}

/* 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
png_get_mem_ptr(png_structp png_ptr)
{
dimitri's avatar
dimitri committed
604
   if(png_ptr == NULL) return (NULL);
dimitri's avatar
dimitri committed
605 606 607
   return ((png_voidp)png_ptr->mem_ptr);
}
#endif /* PNG_USER_MEM_SUPPORTED */
dimitri's avatar
dimitri committed
608
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */