* Last changed in libpng 1.6.16 [December 22, 2014]

 * Copyright (c) 1998-2014 Glenn Randers-Pehrson

typedef png_libpng_version_1_6_16 Your_png_h_is_not_version_1_6_16;

png_set_sig_bytes(png_structrp png_ptr, int num_bytes)

 * PNG signature (this is the same behavior as strcmp, memcmp, etc).

   return ((int)(memcmp(&sig[start], &png_signature[start], num_to_check)));

#endif /* READ */

   png_alloc_size_t num_bytes = size;

      return NULL;

   if (items >= (~(png_alloc_size_t)0)/size)

      png_warning (png_voidcast(png_structrp, png_ptr),

         "Potential overflow in png_zalloc()");

      return NULL;

   num_bytes *= items;

   return png_malloc_warn(png_voidcast(png_structrp, png_ptr), num_bytes);

   png_free(png_voidcast(png_const_structrp,png_ptr), ptr);

png_reset_crc(png_structrp png_ptr)

   /* The cast is safe because the crc is a 32 bit value. */

   png_ptr->crc = (png_uint_32)crc32(0, Z_NULL, 0);

png_calculate_crc(png_structrp png_ptr, png_const_bytep ptr, png_size_t length)

   if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name) != 0)

   else /* critical */

      if ((png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) != 0)

   /* 'uLong' is defined in zlib.h as unsigned long; this means that on some

    * systems it is a 64 bit value.  crc32, however, returns 32 bits so the

    * following cast is safe.  'uInt' may be no more than 16 bits, so it is

    * necessary to perform a loop here.

    */

   if (need_crc != 0 && length > 0)

   {

      uLong crc = png_ptr->crc; /* Should never issue a warning */

      do

      {

         uInt safe_length = (uInt)length;

         if (safe_length == 0)

            safe_length = (uInt)-1; /* evil, but safe */

         crc = crc32(crc, ptr, safe_length);

         /* The following should never issue compiler warnings; if they do the

          * target system has characteristics that will probably violate other

          * assumptions within the libpng code.

          */

         ptr += safe_length;

         length -= safe_length;

      }

      while (length > 0);

      /* And the following is always safe because the crc is only 32 bits. */

      png_ptr->crc = (png_uint_32)crc;

   }

 * functions that create a png_struct.

png_user_version_check(png_structrp png_ptr, png_const_charp user_png_ver)

     /* Libpng versions 1.0.0 and later are binary compatible if the version

      * string matches through the second '.'; we must recompile any

      * applications that use any older library version.

      */

   if (user_png_ver != NULL)

      int i = -1;

      int found_dots = 0;

         i++;

         if (user_png_ver[i] != PNG_LIBPNG_VER_STRING[i])

         if (user_png_ver[i] == '.')

            found_dots++;

      } while (found_dots < 2 && user_png_ver[i] != 0 &&

            PNG_LIBPNG_VER_STRING[i] != 0);

   if ((png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) != 0)

      size_t pos = 0;

      char m[128];

      pos = png_safecat(m, (sizeof m), pos,

          "Application built with libpng-");

      pos = png_safecat(m, (sizeof m), pos, user_png_ver);

      pos = png_safecat(m, (sizeof m), pos, " but running with ");

      pos = png_safecat(m, (sizeof m), pos, PNG_LIBPNG_VER_STRING);

      PNG_UNUSED(pos)

      png_warning(png_ptr, m);

      png_ptr->flags = 0;

      return 0;

/* Generic function to create a png_struct for either read or write - this

 * contains the common initialization.

PNG_FUNCTION(png_structp /* PRIVATE */,

png_create_png_struct,(png_const_charp user_png_ver, png_voidp error_ptr,

    png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

    png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)

{

   png_struct create_struct;

#  ifdef PNG_SETJMP_SUPPORTED

      jmp_buf create_jmp_buf;

#  endif

   /* This temporary stack-allocated structure is used to provide a place to

    * build enough context to allow the user provided memory allocator (if any)

    * to be called.

    */

   memset(&create_struct, 0, (sizeof create_struct));

   /* Added at libpng-1.2.6 */

#  ifdef PNG_USER_LIMITS_SUPPORTED

      create_struct.user_width_max = PNG_USER_WIDTH_MAX;

      create_struct.user_height_max = PNG_USER_HEIGHT_MAX;

#     ifdef PNG_USER_CHUNK_CACHE_MAX

         /* Added at libpng-1.2.43 and 1.4.0 */

         create_struct.user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX;

#     endif

#     ifdef PNG_USER_CHUNK_MALLOC_MAX

         /* Added at libpng-1.2.43 and 1.4.1, required only for read but exists

          * in png_struct regardless.

          */

         create_struct.user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX;

#     endif

#  endif

   /* The following two API calls simply set fields in png_struct, so it is safe

    * to do them now even though error handling is not yet set up.

    */

#  ifdef PNG_USER_MEM_SUPPORTED

      png_set_mem_fn(&create_struct, mem_ptr, malloc_fn, free_fn);

#  else

      PNG_UNUSED(mem_ptr)

      PNG_UNUSED(malloc_fn)

      PNG_UNUSED(free_fn)

#  endif

   /* (*error_fn) can return control to the caller after the error_ptr is set,

    * this will result in a memory leak unless the error_fn does something

    * extremely sophisticated.  The design lacks merit but is implicit in the

    * API.

    */

   png_set_error_fn(&create_struct, error_ptr, error_fn, warn_fn);

#  ifdef PNG_SETJMP_SUPPORTED

      if (!setjmp(create_jmp_buf))

      {

         /* Temporarily fake out the longjmp information until we have

          * successfully completed this function.  This only works if we have

          * setjmp() support compiled in, but it is safe - this stuff should

          * never happen.

          */

         create_struct.jmp_buf_ptr = &create_jmp_buf;

         create_struct.jmp_buf_size = 0; /*stack allocation*/

         create_struct.longjmp_fn = longjmp;

#  else

      {

#  endif

         /* Call the general version checker (shared with read and write code):

          */

         if (png_user_version_check(&create_struct, user_png_ver) != 0)

         {

            png_structrp png_ptr = png_voidcast(png_structrp,

               png_malloc_warn(&create_struct, (sizeof *png_ptr)));

            if (png_ptr != NULL)

            {

               /* png_ptr->zstream holds a back-pointer to the png_struct, so

                * this can only be done now:

                */

               create_struct.zstream.zalloc = png_zalloc;

               create_struct.zstream.zfree = png_zfree;

               create_struct.zstream.opaque = png_ptr;

#              ifdef PNG_SETJMP_SUPPORTED

                  /* Eliminate the local error handling: */

                  create_struct.jmp_buf_ptr = NULL;

                  create_struct.jmp_buf_size = 0;

                  create_struct.longjmp_fn = 0;

#              endif

               *png_ptr = create_struct;

               /* This is the successful return point */

               return png_ptr;

            }

         }

      }

   /* A longjmp because of a bug in the application storage allocator or a

    * simple failure to allocate the png_struct.

    */

   return NULL;

}

/* Allocate the memory for an info_struct for the application. */

png_create_info_struct,(png_const_structrp png_ptr),PNG_ALLOCATED)

   png_inforp info_ptr;

      return NULL;

   /* Use the internal API that does not (or at least should not) error out, so

    * that this call always returns ok.  The application typically sets up the

    * error handling *after* creating the info_struct because this is the way it

    * has always been done in 'example.c'.

    */

   info_ptr = png_voidcast(png_inforp, png_malloc_base(png_ptr,

      (sizeof *info_ptr)));

      memset(info_ptr, 0, (sizeof *info_ptr));

   return info_ptr;

 * useful for some applications.  From libpng 1.6.0 this function is also used

 * internally to implement the png_info release part of the 'struct' destroy

 * APIs.  This ensures that all possible approaches free the same data (all of

 * it).

png_destroy_info_struct(png_const_structrp png_ptr, png_infopp info_ptr_ptr)

   png_inforp info_ptr = NULL;

      /* Do this first in case of an error below; if the app implements its own

       * memory management this can lead to png_free calling png_error, which

       * will abort this routine and return control to the app error handler.

       * An infinite loop may result if it then tries to free the same info

       * ptr.

       */

      png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);

      memset(info_ptr, 0, (sizeof *info_ptr));

      png_free(png_ptr, info_ptr);

 * instead.  Use deprecated in 1.6.0, internal use removed (used internally it

 * is just a memset).

 *

 * NOTE: it is almost inconceivable that this API is used because it bypasses

 * the user-memory mechanism and the user error handling/warning mechanisms in

 * those cases where it does anything other than a memset.

PNG_FUNCTION(void,PNGAPI

png_info_init_3,(png_infopp ptr_ptr, png_size_t png_info_struct_size),

   PNG_DEPRECATED)

   png_inforp info_ptr = *ptr_ptr;

   if ((sizeof (png_info)) > png_info_struct_size)

      *ptr_ptr = NULL;

      /* The following line is why this API should not be used: */

      free(info_ptr);

      info_ptr = png_voidcast(png_inforp, png_malloc_base(NULL,

         (sizeof *info_ptr)));

   memset(info_ptr, 0, (sizeof *info_ptr));

/* The following API is not called internally */

png_data_freer(png_const_structrp png_ptr, png_inforp info_ptr,

      png_error(png_ptr, "Unknown freer parameter in png_data_freer");

png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask,

   if (info_ptr->text != 0 &&

       ((mask & PNG_FREE_TEXT) & info_ptr->free_me) != 0)

         png_free(png_ptr, info_ptr->text[num].key);

         info_ptr->text[num].key = NULL;

            png_free(png_ptr, info_ptr->text[i].key);