src/png/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 */