Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

  1.  
  2. /* pngmem.c - stub functions for memory allocation
  3.  *
  4.  * Last changed in libpng 1.5.1 [February 3, 2011]
  5.  * Copyright (c) 1998-2011 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. #include "pngpriv.h"
  21.  
  22. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  23.  
  24. /* Borland DOS special memory handler */
  25. #if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
  26. /* If you change this, be sure to change the one in png.h also */
  27.  
  28. /* Allocate memory for a png_struct.  The malloc and memset can be replaced
  29.    by a single call to calloc() if this is thought to improve performance. */
  30. PNG_FUNCTION(png_voidp /* PRIVATE */,
  31. png_create_struct,(int type),PNG_ALLOCATED)
  32. {
  33. #  ifdef PNG_USER_MEM_SUPPORTED
  34.    return (png_create_struct_2(type, NULL, NULL));
  35. }
  36.  
  37. /* Alternate version of png_create_struct, for use with user-defined malloc. */
  38. PNG_FUNCTION(png_voidp /* PRIVATE */,
  39. png_create_struct_2,(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr),
  40.    PNG_ALLOCATED)
  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.  
  49.    else if (type == PNG_STRUCT_PNG)
  50.       size = png_sizeof(png_struct);
  51.  
  52.    else
  53.       return (png_get_copyright(NULL));
  54.  
  55. #  ifdef PNG_USER_MEM_SUPPORTED
  56.    if (malloc_fn != NULL)
  57.    {
  58.       png_struct dummy_struct;
  59.       png_structp png_ptr = &dummy_struct;
  60.       png_ptr->mem_ptr=mem_ptr;
  61.       struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size);
  62.    }
  63.  
  64.    else
  65. #  endif /* PNG_USER_MEM_SUPPORTED */
  66.    struct_ptr = (png_voidp)farmalloc(size);
  67.    if (struct_ptr != NULL)
  68.       png_memset(struct_ptr, 0, size);
  69.  
  70.    return (struct_ptr);
  71. }
  72.  
  73. /* Free memory allocated by a png_create_struct() call */
  74. void /* PRIVATE */
  75. png_destroy_struct(png_voidp struct_ptr)
  76. {
  77. #  ifdef PNG_USER_MEM_SUPPORTED
  78.    png_destroy_struct_2(struct_ptr, NULL, NULL);
  79. }
  80.  
  81. /* Free memory allocated by a png_create_struct() call */
  82. void /* PRIVATE */
  83. png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
  84.     png_voidp mem_ptr)
  85. {
  86. #  endif
  87.    if (struct_ptr != NULL)
  88.    {
  89. #  ifdef PNG_USER_MEM_SUPPORTED
  90.       if (free_fn != NULL)
  91.       {
  92.          png_struct dummy_struct;
  93.          png_structp png_ptr = &dummy_struct;
  94.          png_ptr->mem_ptr=mem_ptr;
  95.          (*(free_fn))(png_ptr, struct_ptr);
  96.          return;
  97.       }
  98.  
  99. #  endif /* PNG_USER_MEM_SUPPORTED */
  100.       farfree (struct_ptr);
  101.    }
  102. }
  103.  
  104. /* Allocate memory.  For reasonable files, size should never exceed
  105.  * 64K.  However, zlib may allocate more then 64K if you don't tell
  106.  * it not to.  See zconf.h and png.h for more information. zlib does
  107.  * need to allocate exactly 64K, so whatever you call here must
  108.  * have the ability to do that.
  109.  *
  110.  * Borland seems to have a problem in DOS mode for exactly 64K.
  111.  * It gives you a segment with an offset of 8 (perhaps to store its
  112.  * memory stuff).  zlib doesn't like this at all, so we have to
  113.  * detect and deal with it.  This code should not be needed in
  114.  * Windows or OS/2 modes, and only in 16 bit mode.  This code has
  115.  * been updated by Alexander Lehmann for version 0.89 to waste less
  116.  * memory.
  117.  *
  118.  * Note that we can't use png_size_t for the "size" declaration,
  119.  * since on some systems a png_size_t is a 16-bit quantity, and as a
  120.  * result, we would be truncating potentially larger memory requests
  121.  * (which should cause a fatal error) and introducing major problems.
  122.  */
  123. PNG_FUNCTION(png_voidp,PNGAPI
  124. png_calloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
  125. {
  126.    png_voidp ret;
  127.  
  128.    ret = (png_malloc(png_ptr, size));
  129.  
  130.    if (ret != NULL)
  131.       png_memset(ret,0,(png_size_t)size);
  132.  
  133.    return (ret);
  134. }
  135.  
  136. PNG_FUNCTION(png_voidp,PNGAPI
  137. png_malloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
  138. {
  139.    png_voidp ret;
  140.  
  141.    if (png_ptr == NULL || size == 0)
  142.       return (NULL);
  143.  
  144. #  ifdef PNG_USER_MEM_SUPPORTED
  145.    if (png_ptr->malloc_fn != NULL)
  146.       ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
  147.  
  148.    else
  149.       ret = (png_malloc_default(png_ptr, size));
  150.  
  151.    if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
  152.        png_error(png_ptr, "Out of memory");
  153.  
  154.    return (ret);
  155. }
  156.  
  157. PNG_FUNCTION(png_voidp,PNGAPI
  158. png_malloc_default,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
  159. {
  160.    png_voidp ret;
  161. #  endif /* PNG_USER_MEM_SUPPORTED */
  162.  
  163.    if (png_ptr == NULL || size == 0)
  164.       return (NULL);
  165.  
  166. #  ifdef PNG_MAX_MALLOC_64K
  167.    if (size > (png_uint_32)65536L)
  168.    {
  169.       png_warning(png_ptr, "Cannot Allocate > 64K");
  170.       ret = NULL;
  171.    }
  172.  
  173.    else
  174. #  endif
  175.  
  176.    if (size != (size_t)size)
  177.       ret = NULL;
  178.  
  179.    else if (size == (png_uint_32)65536L)
  180.    {
  181.       if (png_ptr->offset_table == NULL)
  182.       {
  183.          /* Try to see if we need to do any of this fancy stuff */
  184.          ret = farmalloc(size);
  185.          if (ret == NULL || ((png_size_t)ret & 0xffff))
  186.          {
  187.             int num_blocks;
  188.             png_uint_32 total_size;
  189.             png_bytep table;
  190.             int i;
  191.             png_byte huge * hptr;
  192.  
  193.             if (ret != NULL)
  194.             {
  195.                farfree(ret);
  196.                ret = NULL;
  197.             }
  198.  
  199.             if (png_ptr->zlib_window_bits > 14)
  200.                num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
  201.  
  202.             else
  203.                num_blocks = 1;
  204.  
  205.             if (png_ptr->zlib_mem_level >= 7)
  206.                num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));
  207.  
  208.             else
  209.                num_blocks++;
  210.  
  211.             total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;
  212.  
  213.             table = farmalloc(total_size);
  214.  
  215.             if (table == NULL)
  216.             {
  217. #  ifndef PNG_USER_MEM_SUPPORTED
  218.                if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
  219.                   png_error(png_ptr, "Out Of Memory"); /* Note "O", "M" */
  220.  
  221.                else
  222.                   png_warning(png_ptr, "Out Of Memory");
  223. #  endif
  224.                return (NULL);
  225.             }
  226.  
  227.             if ((png_size_t)table & 0xfff0)
  228.             {
  229. #  ifndef PNG_USER_MEM_SUPPORTED
  230.                if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
  231.                   png_error(png_ptr,
  232.                     "Farmalloc didn't return normalized pointer");
  233.  
  234.                else
  235.                   png_warning(png_ptr,
  236.                     "Farmalloc didn't return normalized pointer");
  237. #  endif
  238.                return (NULL);
  239.             }
  240.  
  241.             png_ptr->offset_table = table;
  242.             png_ptr->offset_table_ptr = farmalloc(num_blocks *
  243.                png_sizeof(png_bytep));
  244.  
  245.             if (png_ptr->offset_table_ptr == NULL)
  246.             {
  247. #  ifndef PNG_USER_MEM_SUPPORTED
  248.                if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
  249.                   png_error(png_ptr, "Out Of memory"); /* Note "O", "m" */
  250.  
  251.                else
  252.                   png_warning(png_ptr, "Out Of memory");
  253. #  endif
  254.                return (NULL);
  255.             }
  256.  
  257.             hptr = (png_byte huge *)table;
  258.             if ((png_size_t)hptr & 0xf)
  259.             {
  260.                hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
  261.                hptr = hptr + 16L;  /* "hptr += 16L" fails on Turbo C++ 3.0 */
  262.             }
  263.  
  264.             for (i = 0; i < num_blocks; i++)
  265.             {
  266.                png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
  267.                hptr = hptr + (png_uint_32)65536L;  /* "+=" fails on TC++3.0 */
  268.             }
  269.  
  270.             png_ptr->offset_table_number = num_blocks;
  271.             png_ptr->offset_table_count = 0;
  272.             png_ptr->offset_table_count_free = 0;
  273.          }
  274.       }
  275.  
  276.       if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
  277.       {
  278. #  ifndef PNG_USER_MEM_SUPPORTED
  279.          if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
  280.             png_error(png_ptr, "Out of Memory"); /* Note "o" and "M" */
  281.  
  282.          else
  283.             png_warning(png_ptr, "Out of Memory");
  284. #  endif
  285.          return (NULL);
  286.       }
  287.  
  288.       ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
  289.    }
  290.  
  291.    else
  292.       ret = farmalloc(size);
  293.  
  294. #  ifndef PNG_USER_MEM_SUPPORTED
  295.    if (ret == NULL)
  296.    {
  297.       if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
  298.          png_error(png_ptr, "Out of memory"); /* Note "o" and "m" */
  299.  
  300.       else
  301.          png_warning(png_ptr, "Out of memory"); /* Note "o" and "m" */
  302.    }
  303. #  endif
  304.  
  305.    return (ret);
  306. }
  307.  
  308. /* Free a pointer allocated by png_malloc().  In the default
  309.  * configuration, png_ptr is not used, but is passed in case it
  310.  * is needed.  If ptr is NULL, return without taking any action.
  311.  */
  312. void PNGAPI
  313. png_free(png_structp png_ptr, png_voidp ptr)
  314. {
  315.    if (png_ptr == NULL || ptr == NULL)
  316.       return;
  317.  
  318. #  ifdef PNG_USER_MEM_SUPPORTED
  319.    if (png_ptr->free_fn != NULL)
  320.    {
  321.       (*(png_ptr->free_fn))(png_ptr, ptr);
  322.       return;
  323.    }
  324.  
  325.    else
  326.       png_free_default(png_ptr, ptr);
  327. }
  328.  
  329. void PNGAPI
  330. png_free_default(png_structp png_ptr, png_voidp ptr)
  331. {
  332. #  endif /* PNG_USER_MEM_SUPPORTED */
  333.  
  334.    if (png_ptr == NULL || ptr == NULL)
  335.       return;
  336.  
  337.    if (png_ptr->offset_table != NULL)
  338.    {
  339.       int i;
  340.  
  341.       for (i = 0; i < png_ptr->offset_table_count; i++)
  342.       {
  343.          if (ptr == png_ptr->offset_table_ptr[i])
  344.          {
  345.             ptr = NULL;
  346.             png_ptr->offset_table_count_free++;
  347.             break;
  348.          }
  349.       }
  350.       if (png_ptr->offset_table_count_free == png_ptr->offset_table_count)
  351.       {
  352.          farfree(png_ptr->offset_table);
  353.          farfree(png_ptr->offset_table_ptr);
  354.          png_ptr->offset_table = NULL;
  355.          png_ptr->offset_table_ptr = NULL;
  356.       }
  357.    }
  358.  
  359.    if (ptr != NULL)
  360.       farfree(ptr);
  361. }
  362.  
  363. #else /* Not the Borland DOS special memory handler */
  364.  
  365. /* Allocate memory for a png_struct or a png_info.  The malloc and
  366.    memset can be replaced by a single call to calloc() if this is thought
  367.    to improve performance noticably. */
  368. PNG_FUNCTION(png_voidp /* PRIVATE */,
  369. png_create_struct,(int type),PNG_ALLOCATED)
  370. {
  371. #  ifdef PNG_USER_MEM_SUPPORTED
  372.    return (png_create_struct_2(type, NULL, NULL));
  373. }
  374.  
  375. /* Allocate memory for a png_struct or a png_info.  The malloc and
  376.    memset can be replaced by a single call to calloc() if this is thought
  377.    to improve performance noticably. */
  378. PNG_FUNCTION(png_voidp /* PRIVATE */,
  379. png_create_struct_2,(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr),
  380.    PNG_ALLOCATED)
  381. {
  382. #  endif /* PNG_USER_MEM_SUPPORTED */
  383.    png_size_t size;
  384.    png_voidp struct_ptr;
  385.  
  386.    if (type == PNG_STRUCT_INFO)
  387.       size = png_sizeof(png_info);
  388.  
  389.    else if (type == PNG_STRUCT_PNG)
  390.       size = png_sizeof(png_struct);
  391.  
  392.    else
  393.       return (NULL);
  394.  
  395. #  ifdef PNG_USER_MEM_SUPPORTED
  396.    if (malloc_fn != NULL)
  397.    {
  398.       png_struct dummy_struct;
  399.       png_structp png_ptr = &dummy_struct;
  400.       png_ptr->mem_ptr=mem_ptr;
  401.       struct_ptr = (*(malloc_fn))(png_ptr, size);
  402.  
  403.       if (struct_ptr != NULL)
  404.          png_memset(struct_ptr, 0, size);
  405.  
  406.       return (struct_ptr);
  407.    }
  408. #  endif /* PNG_USER_MEM_SUPPORTED */
  409.  
  410. #  if defined(__TURBOC__) && !defined(__FLAT__)
  411.    struct_ptr = (png_voidp)farmalloc(size);
  412. #  else
  413. #    if defined(_MSC_VER) && defined(MAXSEG_64K)
  414.    struct_ptr = (png_voidp)halloc(size, 1);
  415. #    else
  416.    struct_ptr = (png_voidp)malloc(size);
  417. #    endif
  418. #  endif
  419.  
  420.    if (struct_ptr != NULL)
  421.       png_memset(struct_ptr, 0, size);
  422.  
  423.    return (struct_ptr);
  424. }
  425.  
  426.  
  427. /* Free memory allocated by a png_create_struct() call */
  428. void /* PRIVATE */
  429. png_destroy_struct(png_voidp struct_ptr)
  430. {
  431. #  ifdef PNG_USER_MEM_SUPPORTED
  432.    png_destroy_struct_2(struct_ptr, NULL, NULL);
  433. }
  434.  
  435. /* Free memory allocated by a png_create_struct() call */
  436. void /* PRIVATE */
  437. png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
  438.     png_voidp mem_ptr)
  439. {
  440. #  endif /* PNG_USER_MEM_SUPPORTED */
  441.    if (struct_ptr != NULL)
  442.    {
  443. #  ifdef PNG_USER_MEM_SUPPORTED
  444.       if (free_fn != NULL)
  445.       {
  446.          png_struct dummy_struct;
  447.          png_structp png_ptr = &dummy_struct;
  448.          png_ptr->mem_ptr=mem_ptr;
  449.          (*(free_fn))(png_ptr, struct_ptr);
  450.          return;
  451.       }
  452. #  endif /* PNG_USER_MEM_SUPPORTED */
  453. #  if defined(__TURBOC__) && !defined(__FLAT__)
  454.       farfree(struct_ptr);
  455.  
  456. #  else
  457. #    if defined(_MSC_VER) && defined(MAXSEG_64K)
  458.       hfree(struct_ptr);
  459.  
  460. #    else
  461.       free(struct_ptr);
  462.  
  463. #    endif
  464. #  endif
  465.    }
  466. }
  467.  
  468. /* Allocate memory.  For reasonable files, size should never exceed
  469.  * 64K.  However, zlib may allocate more then 64K if you don't tell
  470.  * it not to.  See zconf.h and png.h for more information.  zlib does
  471.  * need to allocate exactly 64K, so whatever you call here must
  472.  * have the ability to do that.
  473.  */
  474.  
  475. PNG_FUNCTION(png_voidp,PNGAPI
  476. png_calloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
  477. {
  478.    png_voidp ret;
  479.  
  480.    ret = (png_malloc(png_ptr, size));
  481.  
  482.    if (ret != NULL)
  483.       png_memset(ret,0,(png_size_t)size);
  484.  
  485.    return (ret);
  486. }
  487.  
  488. PNG_FUNCTION(png_voidp,PNGAPI
  489. png_malloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
  490. {
  491.    png_voidp ret;
  492.  
  493. #  ifdef PNG_USER_MEM_SUPPORTED
  494.    if (png_ptr == NULL || size == 0)
  495.       return (NULL);
  496.  
  497.    if (png_ptr->malloc_fn != NULL)
  498.       ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
  499.  
  500.    else
  501.       ret = (png_malloc_default(png_ptr, size));
  502.  
  503.    if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
  504.        png_error(png_ptr, "Out of Memory");
  505.  
  506.    return (ret);
  507. }
  508.  
  509. PNG_FUNCTION(png_voidp,PNGAPI
  510. png_malloc_default,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
  511. {
  512.    png_voidp ret;
  513. #  endif /* PNG_USER_MEM_SUPPORTED */
  514.  
  515.    if (png_ptr == NULL || size == 0)
  516.       return (NULL);
  517.  
  518. #  ifdef PNG_MAX_MALLOC_64K
  519.    if (size > (png_uint_32)65536L)
  520.    {
  521. #    ifndef PNG_USER_MEM_SUPPORTED
  522.       if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
  523.          png_error(png_ptr, "Cannot Allocate > 64K");
  524.  
  525.       else
  526. #    endif
  527.          return NULL;
  528.    }
  529. #  endif
  530.  
  531.    /* Check for overflow */
  532. #  if defined(__TURBOC__) && !defined(__FLAT__)
  533.  
  534.    if (size != (unsigned long)size)
  535.       ret = NULL;
  536.  
  537.    else
  538.       ret = farmalloc(size);
  539.  
  540. #  else
  541. #    if defined(_MSC_VER) && defined(MAXSEG_64K)
  542.    if (size != (unsigned long)size)
  543.       ret = NULL;
  544.  
  545.    else
  546.       ret = halloc(size, 1);
  547.  
  548. #    else
  549.    if (size != (size_t)size)
  550.       ret = NULL;
  551.  
  552.    else
  553.       ret = malloc((size_t)size);
  554. #    endif
  555. #  endif
  556.  
  557. #  ifndef PNG_USER_MEM_SUPPORTED
  558.    if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
  559.       png_error(png_ptr, "Out of Memory");
  560. #  endif
  561.  
  562.    return (ret);
  563. }
  564.  
  565. /* Free a pointer allocated by png_malloc().  If ptr is NULL, return
  566.  * without taking any action.
  567.  */
  568. void PNGAPI
  569. png_free(png_structp png_ptr, png_voidp ptr)
  570. {
  571.    if (png_ptr == NULL || ptr == NULL)
  572.       return;
  573.  
  574. #  ifdef PNG_USER_MEM_SUPPORTED
  575.    if (png_ptr->free_fn != NULL)
  576.    {
  577.       (*(png_ptr->free_fn))(png_ptr, ptr);
  578.       return;
  579.    }
  580.  
  581.    else
  582.       png_free_default(png_ptr, ptr);
  583. }
  584.  
  585. void PNGAPI
  586. png_free_default(png_structp png_ptr, png_voidp ptr)
  587. {
  588.    if (png_ptr == NULL || ptr == NULL)
  589.       return;
  590.  
  591. #  endif /* PNG_USER_MEM_SUPPORTED */
  592.  
  593. #  if defined(__TURBOC__) && !defined(__FLAT__)
  594.    farfree(ptr);
  595.  
  596. #  else
  597. #    if defined(_MSC_VER) && defined(MAXSEG_64K)
  598.    hfree(ptr);
  599.  
  600. #    else
  601.    free(ptr);
  602.  
  603. #    endif
  604. #  endif
  605. }
  606. #endif /* Not Borland DOS special memory handler */
  607.  
  608. /* This function was added at libpng version 1.2.3.  The png_malloc_warn()
  609.  * function will set up png_malloc() to issue a png_warning and return NULL
  610.  * instead of issuing a png_error, if it fails to allocate the requested
  611.  * memory.
  612.  */
  613. PNG_FUNCTION(png_voidp,PNGAPI
  614. png_malloc_warn,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
  615. {
  616.    png_voidp ptr;
  617.    png_uint_32 save_flags;
  618.    if (png_ptr == NULL)
  619.       return (NULL);
  620.  
  621.    save_flags = png_ptr->flags;
  622.    png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
  623.    ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);
  624.    png_ptr->flags=save_flags;
  625.    return(ptr);
  626. }
  627.  
  628.  
  629. #ifdef PNG_USER_MEM_SUPPORTED
  630. /* This function is called when the application wants to use another method
  631.  * of allocating and freeing memory.
  632.  */
  633. void PNGAPI
  634. png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
  635.   malloc_fn, png_free_ptr free_fn)
  636. {
  637.    if (png_ptr != NULL)
  638.    {
  639.       png_ptr->mem_ptr = mem_ptr;
  640.       png_ptr->malloc_fn = malloc_fn;
  641.       png_ptr->free_fn = free_fn;
  642.    }
  643. }
  644.  
  645. /* This function returns a pointer to the mem_ptr associated with the user
  646.  * functions.  The application should free any memory associated with this
  647.  * pointer before png_write_destroy and png_read_destroy are called.
  648.  */
  649. png_voidp PNGAPI
  650. png_get_mem_ptr(png_const_structp png_ptr)
  651. {
  652.    if (png_ptr == NULL)
  653.       return (NULL);
  654.  
  655.    return ((png_voidp)png_ptr->mem_ptr);
  656. }
  657. #endif /* PNG_USER_MEM_SUPPORTED */
  658. #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
  659.