src/png/pngmem.c

   1
   2 /* pngmem.c - stub functions for memory allocation
   3  *
   4  * libpng version 1.2.6 - August 15, 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 */