/* png.c - location for general purpose libpng functions * * libpng version 1.0.9 - January 31, 2001 * Copyright (c) 1998-2001 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.) * */#define PNG_INTERNAL#define PNG_NO_EXTERN#include "png.h"/* Generate a compiler error if there is an old png.h in the search path. */typedef version_1_0_9 Your_png_h_is_not_version_1_0_9;/* Version information for C files.  This had better match the version * string defined in png.h.  */#ifdef PNG_USE_GLOBAL_ARRAYS/* png_libpng_ver was changed to a function in version 1.0.5c */const char png_libpng_ver[18] = "1.0.9";/* png_sig was changed to a function in version 1.0.5c *//* Place to hold the signature string for a PNG file. */const png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};/* Invoke global declarations for constant strings for known chunk types */PNG_IHDR;PNG_IDAT;PNG_IEND;PNG_PLTE;PNG_bKGD;PNG_cHRM;PNG_gAMA;PNG_hIST;PNG_iCCP;PNG_iTXt;PNG_oFFs;PNG_pCAL;PNG_sCAL;PNG_pHYs;PNG_sBIT;PNG_sPLT;PNG_sRGB;PNG_tEXt;PNG_tIME;PNG_tRNS;PNG_zTXt;/* arrays to facilitate easy interlacing - use pass (0 - 6) as index *//* start of interlace block */const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};/* offset to next interlace block */const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};/* start of interlace block in the y direction */const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};/* offset to next interlace block in the y direction */const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};/* width of interlace block (used in assembler routines only) */#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROWconst int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1};#endif/* Height of interlace block.  This is not currently used - if you need * it, uncomment it here and in png.hconst int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};*//* Mask to determine which pixels are valid in a pass */const int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};/* Mask to determine which pixels to overwrite while displaying */const int FARDATA png_pass_dsp_mask[]   = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};#endif/* Tells libpng that we have already handled the first "num_bytes" bytes * 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 PNGAPIpng_set_sig_bytes(png_structp png_ptr, int num_bytes){   png_debug(1, "in png_set_sig_bytes\n");   if (num_bytes > 8)      png_error(png_ptr, "Too many bytes for PNG signature.");   png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);}/* Checks whether the supplied bytes match the PNG signature.  We allow * 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 behaviour as strcmp, memcmp, etc). */int PNGAPIpng_sig_cmp(png_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};   if (num_to_check > 8)      num_to_check = 8;   else if (num_to_check < 1)      return (0);   if (start > 7)      return (0);   if (start + num_to_check > 8)      num_to_check = 8 - start;   return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));}/* (Obsolete) function to check signature bytes.  It does not allow one * to check a partial signature.  This function might be removed in the * future - use png_sig_cmp().  Returns true (nonzero) if the file is a PNG. */int PNGAPIpng_check_sig(png_bytep sig, int num){  return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num));}/* Function to allocate memory for zlib and clear it to 0. */voidpf PNGAPIpng_zalloc(voidpf png_ptr, uInt items, uInt size){   png_uint_32 num_bytes = (png_uint_32)items * size;   png_voidp ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);#ifndef PNG_NO_ZALLOC_ZERO   if (num_bytes > (png_uint_32)0x8000L)   {      png_memset(ptr, 0, (png_size_t)0x8000L);      png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,         (png_size_t)(num_bytes - (png_uint_32)0x8000L));   }   else   {      png_memset(ptr, 0, (png_size_t)num_bytes);   }#endif   return ((voidpf)ptr);}/* function to free memory for zlib */void PNGAPIpng_zfree(voidpf png_ptr, voidpf ptr){   png_free((png_structp)png_ptr, (png_voidp)ptr);}/* Reset the CRC variable to 32 bits of 1's.  Care must be taken * in case CRC is > 32 bits to leave the top bits 0. */void /* PRIVATE */png_reset_crc(png_structp png_ptr){   png_ptr->crc = crc32(0, Z_NULL, 0);}/* Calculate the CRC over a section of data.  We can only pass as * 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_structp png_ptr, png_bytep ptr, png_size_t length){   int need_crc = 1;   if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */   {      if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==          (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))         need_crc = 0;   }   else                                                    /* critical */   {      if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)         need_crc = 0;   }   if (need_crc)      png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);}/* Allocate the memory for an info_struct for the application.  We don't * really need the png_ptr, but it could potentially be useful in the * future.  This should be used in favour of malloc(sizeof(png_info)) * and png_info_init() so that applications that want to use a shared * libpng don't have to be recompiled if png_info changes size. */png_infop PNGAPIpng_create_info_struct(png_structp png_ptr){   png_infop info_ptr;   png_debug(1, "in png_create_info_struct\n");   if(png_ptr == NULL) return (NULL);#ifdef PNG_USER_MEM_SUPPORTED   if ((info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,      png_ptr->malloc_fn)) != NULL)#else   if ((info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO)) != NULL)#endif   {      png_info_init(info_ptr);   }   return (info_ptr);}/* This function frees the memory associated with a single info struct. * 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. */void PNGAPIpng_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr){   png_infop info_ptr = NULL;   png_debug(1, "in png_destroy_info_struct\n");   if (info_ptr_ptr != NULL)      info_ptr = *info_ptr_ptr;   if (info_ptr != NULL)   {      png_info_destroy(png_ptr, info_ptr);#ifdef PNG_USER_MEM_SUPPORTED      png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn);#else      png_destroy_struct((png_voidp)info_ptr);#endif      *info_ptr_ptr = (png_infop)NULL;   }}/* Initialize the info structure.  This is now an internal function (0.89) * and applications using it are urged to use png_create_info_struct() * instead. */void PNGAPIpng_info_init(png_infop info_ptr){   png_debug(1, "in png_info_init\n");   /* set everything to 0 */   png_memset(info_ptr, 0, sizeof (png_info));}#ifdef PNG_FREE_ME_SUPPORTEDvoid PNGAPIpng_data_freer(png_structp png_ptr, png_infop info_ptr,   int freer, png_uint_32 mask){   png_debug(1, "in png_data_freer\n");   if (png_ptr == NULL || info_ptr == NULL)      return;   if(freer == PNG_DESTROY_WILL_FREE_DATA)      info_ptr->free_me |= mask;   else if(freer == PNG_USER_WILL_FREE_DATA)      info_ptr->free_me &= ~mask;   else      png_warning(png_ptr,         "Unknown freer parameter in png_data_freer.");}#endifvoid PNGAPIpng_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, int num){   png_debug(1, "in png_free_data\n");   if (png_ptr == NULL || info_ptr == NULL)      return;#if defined(PNG_TEXT_SUPPORTED)/* free text item num or (if num == -1) all text items */#ifdef PNG_FREE_ME_SUPPORTEDif ((mask & PNG_FREE_TEXT) & info_ptr->free_me)#elseif (mask & PNG_FREE_TEXT)#endif{   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;     }   }   else   {       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#if defined(PNG_tRNS_SUPPORTED)/* free any tRNS entry */#ifdef PNG_FREE_ME_SUPPORTEDif ((mask & PNG_FREE_TRNS) & info_ptr->free_me)#elseif ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS))#endif{    png_free(png_ptr, info_ptr->trans);    info_ptr->valid &= ~PNG_INFO_tRNS;    info_ptr->trans = NULL;}#endif#if defined(PNG_sCAL_SUPPORTED)/* free any sCAL entry */#ifdef PNG_FREE_ME_SUPPORTEDif ((mask & PNG_FREE_SCAL) & info_ptr->free_me)#elseif (mask & PNG_FREE_SCAL)#endif{#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)    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;#endif    info_ptr->valid &= ~PNG_INFO_sCAL;}#endif#if defined(PNG_pCAL_SUPPORTED)/* free any pCAL entry */#ifdef PNG_FREE_ME_SUPPORTEDif ((mask & PNG_FREE_PCAL) & info_ptr->free_me)#elseif (mask & PNG_FREE_PCAL)