Subversion Repositories Kolibri OS

 *

 * Last changed in libpng 1.6.2 [April 25, 2013]

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

 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

 *

 * This code is released under the libpng license.

 * For conditions of distribution and use, see the disclaimer

 * and license in png.h

 */

typedef png_libpng_version_1_6_5 Your_png_h_is_not_version_1_6_5;

 * of the PNG file signature.  If the PNG data is embedded into another

 * stream we can set num_bytes = 8 so that libpng will not attempt to read

 * or write any of the magic bytes before it starts on the IHDR.

 */

void PNGAPI

png_set_sig_bytes(png_structrp png_ptr, int num_bytes)

{

   png_debug(1, "in png_set_sig_bytes");

      return;

      png_error(png_ptr, "Too many bytes for PNG signature");

}

 * checking less than the full 8-byte signature so that those apps that

 * already read the first few bytes of a file to determine the file type

 * can simply check the remaining bytes for extra assurance.  Returns

 * an integer less than, equal to, or greater than zero if sig is found,

 * respectively, to be less than, to match, or be greater than the correct

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

 */

int PNGAPI

png_sig_cmp(png_const_bytep sig, png_size_t start, png_size_t num_to_check)

{

   png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};

      num_to_check = 8;

      return (-1);

      return (-1);

      num_to_check = 8 - start;

}

/* Function to allocate memory for zlib */

PNG_FUNCTION(voidpf /* PRIVATE */,

png_zalloc,(voidpf png_ptr, uInt items, uInt size),PNG_ALLOCATED)

{

   png_alloc_size_t num_bytes = size;

      return NULL;

   {

      png_warning (png_voidcast(png_structrp, png_ptr),

         "Potential overflow in png_zalloc()");

      return NULL;

   }

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

}

void /* PRIVATE */

png_zfree(voidpf png_ptr, voidpf ptr)

{

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

}

 * in case CRC is > 32 bits to leave the top bits 0.

 */

void /* PRIVATE */

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);

}

 * much data to this routine as the largest single buffer size.  We

 * also check that this data will actually be used before going to the

 * trouble of calculating it.

 */

void /* PRIVATE */

png_calculate_crc(png_structrp png_ptr, png_const_bytep ptr, png_size_t length)

{

   int need_crc = 1;

   {

      if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==

          (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))

         need_crc = 0;

   }

   {

      if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)

         need_crc = 0;

   }

    * 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 && length > 0)

   {

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

      {

         uInt safe_length = (uInt)length;

         if (safe_length == 0)

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

          * target system has characteristics that will probably violate other

          * assumptions within the libpng code.

          */

         ptr += safe_length;

         length -= safe_length;

      }

      while (length > 0);

      png_ptr->crc = (png_uint_32)crc;

   }

}

 * functions that create a png_struct.

 */

int

png_user_version_check(png_structrp png_ptr, png_const_charp user_png_ver)

{

   if (user_png_ver)

   {

      int i = 0;

      {

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

            png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;

      } while (png_libpng_ver[i++]);

   }

      png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;

   {

     /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so

      * we must recompile any applications that use any older library version.

      * For versions after libpng 1.0, we will be compatible, so we need

      * only check the first and third digits (note that when we reach version

      * 1.10 we will need to check the fourth symbol, namely user_png_ver[3]).

      */

      if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||

          (user_png_ver[0] == '1' && (user_png_ver[2] != png_libpng_ver[2] ||

          user_png_ver[3] != png_libpng_ver[3])) ||

          (user_png_ver[0] == '0' && user_png_ver[2] < '9'))

      {

#ifdef PNG_WARNINGS_SUPPORTED

         size_t pos = 0;

         char m[128];

             "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);

#endif

         png_ptr->flags = 0;

#endif

      }

   }

   return 1;

}

 * 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

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

    * to be called.

    */

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

#  ifdef PNG_USER_LIMITS_SUPPORTED

      create_struct.user_width_max = PNG_USER_WIDTH_MAX;

      create_struct.user_height_max = PNG_USER_HEIGHT_MAX;

         /* Added at libpng-1.2.43 and 1.4.0 */

         create_struct.user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX;

#     endif

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

    * 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);

#  endif

    * 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);

      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))

         {

            png_structrp png_ptr = png_voidcast(png_structrp,

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

            {

               /* 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;

                  /* Eliminate the local error handling: */

                  create_struct.jmp_buf_ptr = NULL;

                  create_struct.jmp_buf_size = 0;

                  create_struct.longjmp_fn = 0;

#              endif

               return png_ptr;

            }

         }

      }

    * simple failure to allocate the png_struct.

    */

   return NULL;

}

PNG_FUNCTION(png_infop,PNGAPI

png_create_info_struct,(png_const_structrp png_ptr),PNG_ALLOCATED)

{

   png_inforp info_ptr;

      return NULL;

    * 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));

}

 * Normally, one would use either png_destroy_read_struct() or

 * png_destroy_write_struct() to free an info struct, but this may be

 * 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).

 */

void PNGAPI

png_destroy_info_struct(png_const_structrp png_ptr, png_infopp info_ptr_ptr)

{

   png_inforp info_ptr = NULL;

      return;

      info_ptr = *info_ptr_ptr;

   {

      /* 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.

       */

      *info_ptr_ptr = NULL;

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

      png_free(png_ptr, info_ptr);

   }

}

 * and applications using it are urged to use png_create_info_struct()

 * 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;

      return;

   {

      *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)));

      *ptr_ptr = info_ptr;

   }

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

}

void PNGAPI

png_data_freer(png_const_structrp png_ptr, png_inforp info_ptr,

   int freer, png_uint_32 mask)

{

   png_debug(1, "in png_data_freer");

      return;

      info_ptr->free_me |= mask;

      info_ptr->free_me &= ~mask;

      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,

   int num)

{

   png_debug(1, "in png_free_data");

      return;

   /* Free text item num or (if num == -1) all text items */

   if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)

   {

      if (num != -1)

      {

         if (info_ptr->text && info_ptr->text[num].key)

         {

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

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

         }

      }

      {

         int i;

         for (i = 0; i < info_ptr->num_text; i++)

             png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);

         png_free(png_ptr, info_ptr->text);

         info_ptr->text = NULL;

         info_ptr->num_text=0;

      }

   }

#endif

   /* Free any tRNS entry */

   if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)

   {

      png_free(png_ptr, info_ptr->trans_alpha);

      info_ptr->trans_alpha = NULL;

      info_ptr->valid &= ~PNG_INFO_tRNS;

   }

#endif

   /* Free any sCAL entry */

   if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)

   {

      png_free(png_ptr, info_ptr->scal_s_width);

      png_free(png_ptr, info_ptr->scal_s_height);

      info_ptr->scal_s_width = NULL;

      info_ptr->scal_s_height = NULL;

      info_ptr->valid &= ~PNG_INFO_sCAL;

   }

#endif

   /* Free any pCAL entry */

   if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)

   {

      png_free(png_ptr, info_ptr->pcal_purpose);

      png_free(png_ptr, info_ptr->pcal_units);

      info_ptr->pcal_purpose = NULL;

      info_ptr->pcal_units = NULL;

      if (info_ptr->pcal_params != NULL)

         {

            unsigned int i;

            for (i = 0; i < info_ptr->pcal_nparams; i++)

            {

               png_free(png_ptr, info_ptr->pcal_params[i]);

               info_ptr->pcal_params[i] = NULL;

            }

            png_free(png_ptr, info_ptr->pcal_params);

            info_ptr->pcal_params = NULL;

         }

      info_ptr->valid &= ~PNG_INFO_pCAL;

   }

#endif

   /* Free any profile entry */

   if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)

   {

      png_free(png_ptr, info_ptr->iccp_name);

      png_free(png_ptr, info_ptr->iccp_profile);

      info_ptr->iccp_name = NULL;

      info_ptr->iccp_profile = NULL;

      info_ptr->valid &= ~PNG_INFO_iCCP;

   }

#endif

   /* Free a given sPLT entry, or (if num == -1) all sPLT entries */

   if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)

   {

      if (num != -1)

      {

         if (info_ptr->splt_palettes)

         {

            png_free(png_ptr, info_ptr->splt_palettes[num].name);

            png_free(png_ptr, info_ptr->splt_palettes[num].entries);

            info_ptr->splt_palettes[num].name = NULL;

            info_ptr->splt_palettes[num].entries = NULL;

         }

      }

      {

         if (info_ptr->splt_palettes_num)

         {

            int i;

            for (i = 0; i < info_ptr->splt_palettes_num; i++)

               png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, (int)i);

            info_ptr->splt_palettes = NULL;

            info_ptr->splt_palettes_num = 0;

         }

         info_ptr->valid &= ~PNG_INFO_sPLT;

      }

   }

#endif

   if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)

   {

      if (num != -1)

      {

          if (info_ptr->unknown_chunks)

          {

             png_free(png_ptr, info_ptr->unknown_chunks[num].data);

             info_ptr->unknown_chunks[num].data = NULL;

          }

      }

      {

         int i;

         {

            for (i = 0; i < info_ptr->unknown_chunks_num; i++)

               png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, (int)i);

            info_ptr->unknown_chunks = NULL;

            info_ptr->unknown_chunks_num = 0;

         }

      }

   }

#endif

   /* Free any hIST entry */

   if ((mask & PNG_FREE_HIST)  & info_ptr->free_me)

   {

      png_free(png_ptr, info_ptr->hist);

      info_ptr->hist = NULL;

      info_ptr->valid &= ~PNG_INFO_hIST;

   }

#endif

   if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)

   {

      png_free(png_ptr, info_ptr->palette);

      info_ptr->palette = NULL;

      info_ptr->valid &= ~PNG_INFO_PLTE;

      info_ptr->num_palette = 0;

   }

   /* Free any image bits attached to the info structure */

   if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)

   {

      if (info_ptr->row_pointers)

      {

         png_uint_32 row;

         for (row = 0; row < info_ptr->height; row++)

         {

            png_free(png_ptr, info_ptr->row_pointers[row]);

            info_ptr->row_pointers[row] = NULL;

         }

         png_free(png_ptr, info_ptr->row_pointers);

         info_ptr->row_pointers = NULL;

      }

      info_ptr->valid &= ~PNG_INFO_IDAT;

   }

#endif

      mask &= ~PNG_FREE_MUL;

}

#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */

 * functions.  The application should free any memory associated with this

 * pointer before png_write_destroy() or png_read_destroy() are called.

 */

png_voidp PNGAPI

png_get_io_ptr(png_const_structrp png_ptr)

{

   if (png_ptr == NULL)

      return (NULL);

}

#  ifdef PNG_STDIO_SUPPORTED

/* Initialize the default input/output functions for the PNG file.  If you

 * use your own read or write routines, you can call either png_set_read_fn()

 * or png_set_write_fn() instead of png_init_io().  If you have defined

 * PNG_NO_STDIO or otherwise disabled PNG_STDIO_SUPPORTED, you must use a

 * function of your own because "FILE *" isn't necessarily available.

 */

void PNGAPI

png_init_io(png_structrp png_ptr, png_FILE_p fp)

{

   png_debug(1, "in png_init_io");

      return;

}

#  endif

/* The png_save_int_32 function assumes integers are stored in two's

 * complement format.  If this isn't the case, then this routine needs to

 * be modified to write data in two's complement format.  Note that,

 * the following works correctly even if png_int_32 has more than 32 bits

 * (compare the more complex code required on read for sign extension.)

 */

void PNGAPI

png_save_int_32(png_bytep buf, png_int_32 i)

{

   buf[0] = (png_byte)((i >> 24) & 0xff);

   buf[1] = (png_byte)((i >> 16) & 0xff);

   buf[2] = (png_byte)((i >> 8) & 0xff);

   buf[3] = (png_byte)(i & 0xff);

}

#endif

/* Convert the supplied time into an RFC 1123 string suitable for use in

 * a "Creation Time" or other text-based time string.

 */

int PNGAPI

png_convert_to_rfc1123_buffer(char out[29], png_const_timep ptime)

{

   static PNG_CONST char short_months[12][4] =

        {"Jan", "Feb", "Mar", "Apr", "May", "Jun",

         "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};

      return 0;

       ptime->month == 0    ||  ptime->month > 12  ||

       ptime->day   == 0    ||  ptime->day   > 31  ||

       ptime->hour  > 23    ||  ptime->minute > 59 ||

       ptime->second > 60)

      return 0;

      size_t pos = 0;

      char number_buf[5]; /* enough for a four-digit year */

#     define APPEND_NUMBER(format, value)\

         APPEND_STRING(PNG_FORMAT_NUMBER(number_buf, format, (value)))

#     define APPEND(ch) if (pos < 28) out[pos++] = (ch)

      APPEND(' ');

      APPEND_STRING(short_months[(ptime->month - 1)]);

      APPEND(' ');

      APPEND_NUMBER(PNG_NUMBER_FORMAT_u, ptime->year);

      APPEND(' ');

      APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->hour);

      APPEND(':');

      APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->minute);

      APPEND(':');

      APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->second);

      APPEND_STRING(" +0000"); /* This reliably terminates the buffer */

#     undef APPEND_NUMBER

#     undef APPEND_STRING

   }

}

/* To do: remove the following from libpng-1.7 */

/* Original API that uses a private buffer in png_struct.

 * Deprecated because it causes png_struct to carry a spurious temporary

 * buffer (png_struct::time_buffer), better to have the caller pass this in.

 */

png_const_charp PNGAPI

png_convert_to_rfc1123(png_structrp png_ptr, png_const_timep ptime)

{

   if (png_ptr != NULL)

   {

      /* The only failure above if png_ptr != NULL is from an invalid ptime */

      if (!png_convert_to_rfc1123_buffer(png_ptr->time_buffer, ptime))

         png_warning(png_ptr, "Ignoring invalid time value");

         return png_ptr->time_buffer;

   }

}

#     endif

#  endif /* PNG_TIME_RFC1123_SUPPORTED */

png_get_copyright(png_const_structrp png_ptr)

{

   PNG_UNUSED(png_ptr)  /* Silence compiler warning about unused png_ptr */

#ifdef PNG_STRING_COPYRIGHT

   return PNG_STRING_COPYRIGHT

#else

#  ifdef __STDC__

   return PNG_STRING_NEWLINE \

     "libpng version 1.6.5 - September 14, 2013" PNG_STRING_NEWLINE \

     "Copyright (c) 1998-2013 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \

     "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \

     "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \

     PNG_STRING_NEWLINE;

#  else

      return "libpng version 1.6.5 - September 14, 2013\

      Copyright (c) 1998-2013 Glenn Randers-Pehrson\

      Copyright (c) 1996-1997 Andreas Dilger\

      Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.";

#  endif

#endif

}

 * format 1.0.0 through 99.99.99zz.  To get the version of *.h files

 * used with your application, print out PNG_LIBPNG_VER_STRING, which

 * is defined in png.h.

 * Note: now there is no difference between png_get_libpng_ver() and

 * png_get_header_ver().  Due to the version_nn_nn_nn typedef guard,

 * it is guaranteed that png.c uses the correct version of png.h.

 */

png_const_charp PNGAPI

png_get_libpng_ver(png_const_structrp png_ptr)

{

   /* Version of *.c files used when building libpng */

   return png_get_header_ver(png_ptr);

}

png_get_header_ver(png_const_structrp png_ptr)

{

   /* Version of *.h files used when building libpng */

   PNG_UNUSED(png_ptr)  /* Silence compiler warning about unused png_ptr */

   return PNG_LIBPNG_VER_STRING;

}

png_get_header_version(png_const_structrp png_ptr)

{

   /* Returns longer string containing both version and date */

   PNG_UNUSED(png_ptr)  /* Silence compiler warning about unused png_ptr */

#ifdef __STDC__

   return PNG_HEADER_VERSION_STRING

#  ifndef PNG_READ_SUPPORTED

   "     (NO READ SUPPORT)"

#  endif

   PNG_STRING_NEWLINE;

#else

   return PNG_HEADER_VERSION_STRING;

#endif

}

int PNGAPI

png_handle_as_unknown(png_const_structrp png_ptr, png_const_bytep chunk_name)

{

   /* Check chunk_name and return "keep" value if it's on the list, else 0 */

   png_const_bytep p, p_end;

      return PNG_HANDLE_CHUNK_AS_DEFAULT;

   p = p_end + png_ptr->num_chunk_list*5; /* beyond end */

    * code was always searched from the end of the list, this is no longer

    * necessary because the 'set' routine handles duplicate entries correcty.

    */

   do /* num_chunk_list > 0, so at least one */

   {

      p -= 5;

         return p[4];

   }

   while (p > p_end);

    * be handled according to the value of png_ptr->unknown_default; this can be

    * confusing because, as a result, there are two levels of defaulting for

    * unknown chunks.

    */

   return PNG_HANDLE_CHUNK_AS_DEFAULT;

}

int /* PRIVATE */

png_chunk_unknown_handling(png_const_structrp png_ptr, png_uint_32 chunk_name)

{

   png_byte chunk_string[5];

   return png_handle_as_unknown(png_ptr, chunk_string);

}

#endif /* HANDLE_AS_UNKNOWN */

#endif /* SET_UNKNOWN_CHUNKS */

/* This function, added to libpng-1.0.6g, is untested. */

int PNGAPI

png_reset_zstream(png_structrp png_ptr)

{

   if (png_ptr == NULL)

      return Z_STREAM_ERROR;

   return (inflateReset(&png_ptr->zstream));

}

#endif /* PNG_READ_SUPPORTED */

png_uint_32 PNGAPI

png_access_version_number(void)

{

   /* Version of *.c files used when building libpng */

   return((png_uint_32)PNG_LIBPNG_VER);

}

/* Ensure that png_ptr->zstream.msg holds some appropriate error message string.

 * If it doesn't 'ret' is used to set it to something appropriate, even in cases

 * like Z_OK or Z_STREAM_END where the error code is apparently a success code.

 */

void /* PRIVATE */

png_zstream_error(png_structrp png_ptr, int ret)

{

   /* Translate 'ret' into an appropriate error string, priority is given to the

    * one in zstream if set.  This always returns a string, even in cases like

    * Z_OK or Z_STREAM_END where the error code is a success code.

    */

   if (png_ptr->zstream.msg == NULL) switch (ret)

   {

      default:

      case Z_OK:

         png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return code");

         break;

         /* Normal exit */

         png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected end of LZ stream");

         break;

         /* This means the deflate stream did not have a dictionary; this

          * indicates a bogus PNG.

          */

         png_ptr->zstream.msg = PNGZ_MSG_CAST("missing LZ dictionary");

         break;

         /* gz APIs only: should not happen */

         png_ptr->zstream.msg = PNGZ_MSG_CAST("zlib IO error");

         break;

         /* internal libpng error */

         png_ptr->zstream.msg = PNGZ_MSG_CAST("bad parameters to zlib");

         break;

         png_ptr->zstream.msg = PNGZ_MSG_CAST("damaged LZ stream");

         break;

         png_ptr->zstream.msg = PNGZ_MSG_CAST("insufficient memory");

         break;

         /* End of input or output; not a problem if the caller is doing

          * incremental read or write.

          */

         png_ptr->zstream.msg = PNGZ_MSG_CAST("truncated");

         break;

         png_ptr->zstream.msg = PNGZ_MSG_CAST("unsupported zlib version");

         break;

         /* Compile errors here mean that zlib now uses the value co-opted in

          * pngpriv.h for PNG_UNEXPECTED_ZLIB_RETURN; update the switch above

          * and change pngpriv.h.  Note that this message is "... return",

          * whereas the default/Z_OK one is "... return code".

          */

         png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return");

         break;

   }

}

 * at libpng 1.5.5!

 */

#ifdef PNG_GAMMA_SUPPORTED /* always set if COLORSPACE */

static int

png_colorspace_check_gamma(png_const_structrp png_ptr,

   png_colorspacerp colorspace, png_fixed_point gAMA, int from)

   /* This is called to check a new gamma value against an existing one.  The

    * routine returns false if the new gamma value should not be written.

    *

    * 'from' says where the new gamma value comes from:

    *

    *    0: the new gamma value is the libpng estimate for an ICC profile

    *    1: the new gamma value comes from a gAMA chunk

    *    2: the new gamma value comes from an sRGB chunk

    */

{

   png_fixed_point gtest;

      (!png_muldiv(>est, colorspace->gamma, PNG_FP_1, gAMA) ||

      png_gamma_significant(gtest)))

   {

      /* Either this is an sRGB image, in which case the calculated gamma

       * approximation should match, or this is an image with a profile and the

       * value libpng calculates for the gamma of the profile does not match the

       * value recorded in the file.  The former, sRGB, case is an error, the

       * latter is just a warning.

       */

      if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0 || from == 2)

      {

         png_chunk_report(png_ptr, "gamma value does not match sRGB",

            PNG_CHUNK_ERROR);

         /* Do not overwrite an sRGB value */

         return from == 2;

      }

      {

         png_chunk_report(png_ptr, "gamma value does not match libpng estimate",

            PNG_CHUNK_WARNING);

         return from == 1;

      }

   }

}

png_colorspace_set_gamma(png_const_structrp png_ptr,

   png_colorspacerp colorspace, png_fixed_point gAMA)

{

   /* Changed in libpng-1.5.4 to limit the values to ensure overflow can't

    * occur.  Since the fixed point representation is assymetrical it is

    * possible for 1/gamma to overflow the limit of 21474 and this means the

    * gamma value must be at least 5/100000 and hence at most 20000.0.  For

    * safety the limits here are a little narrower.  The values are 0.00016 to

    * 6250.0, which are truly ridiculous gamma values (and will produce

    * displays that are all black or all white.)

    *

    * In 1.6.0 this test replaces the ones in pngrutil.c, in the gAMA chunk

    * handling code, which only required the value to be >0.

    */

   png_const_charp errmsg;

      errmsg = "gamma value out of range";

      /* Allow the application to set the gamma value more than once */

      else if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&

         (colorspace->flags & PNG_COLORSPACE_FROM_gAMA) != 0)

         errmsg = "duplicate";

#  endif

   else if (colorspace->flags & PNG_COLORSPACE_INVALID)

      return;

   {

      if (png_colorspace_check_gamma(png_ptr, colorspace, gAMA, 1/*from gAMA*/))

      {

         /* Store this gamma value. */

         colorspace->gamma = gAMA;

         colorspace->flags |=

            (PNG_COLORSPACE_HAVE_GAMMA | PNG_COLORSPACE_FROM_gAMA);

      }

       * not updated however the colorspace is not invalidated.  This

       * corresponds to the case where the existing gamma comes from an sRGB

       * chunk or profile.  An error message has already been output.

       */

      return;

   }

   colorspace->flags |= PNG_COLORSPACE_INVALID;

   png_chunk_report(png_ptr, errmsg, PNG_CHUNK_WRITE_ERROR);

}

png_colorspace_sync_info(png_const_structrp png_ptr, png_inforp info_ptr)

{

   if (info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID)

   {

      /* Everything is invalid */

      info_ptr->valid &= ~(PNG_INFO_gAMA|PNG_INFO_cHRM|PNG_INFO_sRGB|

         PNG_INFO_iCCP);

         /* Clean up the iCCP profile now if it won't be used. */

         png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, -1/*not used*/);

#     else

         PNG_UNUSED(png_ptr)

#     endif

   }

   {

#     ifdef PNG_COLORSPACE_SUPPORTED

         /* Leave the INFO_iCCP flag set if the pngset.c code has already set

          * it; this allows a PNG to contain a profile which matches sRGB and

          * yet still have that profile retrievable by the application.

          */

         if (info_ptr->colorspace.flags & PNG_COLORSPACE_MATCHES_sRGB)

            info_ptr->valid |= PNG_INFO_sRGB;

            info_ptr->valid &= ~PNG_INFO_sRGB;

            info_ptr->valid |= PNG_INFO_cHRM;

            info_ptr->valid &= ~PNG_INFO_cHRM;

#     endif

         info_ptr->valid |= PNG_INFO_gAMA;