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#if defined(PNG_iCCP_SUPPORTED)/* free any iCCP entry */#ifdef PNG_FREE_ME_SUPPORTEDif ((mask & PNG_FREE_ICCP) & info_ptr->free_me)#elseif (mask & PNG_FREE_ICCP)#endif{    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#if defined(PNG_sPLT_SUPPORTED)/* free a given sPLT entry, or (if num == -1) all sPLT entries */#ifdef PNG_FREE_ME_SUPPORTEDif ((mask & PNG_FREE_SPLT) & info_ptr->free_me)#elseif (mask & PNG_FREE_SPLT)#endif{   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;      }   }   else   {       if(info_ptr->splt_palettes_num)       {         int i;         for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)            png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);         png_free(png_ptr, info_ptr->splt_palettes);         info_ptr->splt_palettes = NULL;         info_ptr->splt_palettes_num = 0;       }       info_ptr->valid &= ~PNG_INFO_sPLT;   }}#endif#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)#ifdef PNG_FREE_ME_SUPPORTEDif ((mask & PNG_FREE_UNKN) & info_ptr->free_me)#elseif (mask & PNG_FREE_UNKN)#endif{   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;       }   }   else   {       int i;       if(info_ptr->unknown_chunks_num)       {         for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++)            png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);         png_free(png_ptr, info_ptr->unknown_chunks);         info_ptr->unknown_chunks = NULL;         info_ptr->unknown_chunks_num = 0;       }   }}#endif#if defined(PNG_hIST_SUPPORTED)/* free any hIST entry */#ifdef PNG_FREE_ME_SUPPORTEDif ((mask & PNG_FREE_HIST)  & info_ptr->free_me)#elseif ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST))#endif{    png_free(png_ptr, info_ptr->hist);    info_ptr->hist = NULL;    info_ptr->valid &= ~PNG_INFO_hIST;#ifndef PNG_FREE_ME_SUPPORTED    png_ptr->flags &= ~PNG_FLAG_FREE_HIST;#endif}#endif/* free any PLTE entry that was internally allocated */#ifdef PNG_FREE_ME_SUPPORTEDif ((mask & PNG_FREE_PLTE) & info_ptr->free_me)#elseif ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE))#endif{    png_zfree(png_ptr, info_ptr->palette);    info_ptr->palette = NULL;    info_ptr->valid &= ~PNG_INFO_PLTE;#ifndef PNG_FREE_ME_SUPPORTED    png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;#endif    info_ptr->num_palette = 0;}#if defined(PNG_INFO_IMAGE_SUPPORTED)/* free any image bits attached to the info structure */#ifdef PNG_FREE_ME_SUPPORTEDif ((mask & PNG_FREE_ROWS) & info_ptr->free_me)#elseif (mask & PNG_FREE_ROWS)#endif{    if(info_ptr->row_pointers)    {       int row;       for (row = 0; row < (int)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#ifdef PNG_FREE_ME_SUPPORTED   if(num == -1)     info_ptr->free_me &= ~mask;   else     info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);#endif}/* This is an internal routine to free any memory that the info struct is * pointing to before re-using it or freeing the struct itself.  Recall * that png_free() checks for NULL pointers for us. */void /* PRIVATE */png_info_destroy(png_structp png_ptr, png_infop info_ptr){   png_debug(1, "in png_info_destroy\n");   png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)   if (png_ptr->num_chunk_list)   {       png_free(png_ptr, png_ptr->chunk_list);       png_ptr->chunk_list=NULL;       png_ptr->num_chunk_list=0;   }#endif   png_info_init_3(&info_ptr, png_sizeof(png_info));}/* This function returns a pointer to the io_ptr associated with the user * functions.  The application should free any memory associated with this * pointer before png_write_destroy() or png_read_destroy() are called. */png_voidp PNGAPIpng_get_io_ptr(png_structp png_ptr){   return (png_ptr->io_ptr);}#if !defined(PNG_NO_STDIO)/* 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, you must use a function of your own because "FILE *" isn't * necessarily available. */void PNGAPIpng_init_io(png_structp png_ptr, png_FILE_p fp){   png_debug(1, "in png_init_io\n");   png_ptr->io_ptr = (png_voidp)fp;}#endif#if defined(PNG_TIME_RFC1123_SUPPORTED)/* Convert the supplied time into an RFC 1123 string suitable for use in * a "Creation Time" or other text-based time string. */png_charp PNGAPIpng_convert_to_rfc1123(png_structp png_ptr, png_timep ptime){   static PNG_CONST char short_months[12][4] =        {"Jan", "Feb", "Mar", "Apr", "May", "Jun",         "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};   if (png_ptr->time_buffer == NULL)   {      png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*         png_sizeof(char)));   }#if defined(_WIN32_WCE)   {      wchar_t time_buf[29];      wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"),          ptime->day % 32, short_months[(ptime->month - 1) % 12],        ptime->year, ptime->hour % 24, ptime->minute % 60,          ptime->second % 61);      WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29,          NULL, NULL);   }#else#ifdef USE_FAR_KEYWORD   {      char near_time_buf[29];      sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000",          ptime->day % 32, short_months[(ptime->month - 1) % 12],          ptime->year, ptime->hour % 24, ptime->minute % 60,          ptime->second % 61);      png_memcpy(png_ptr->time_buffer, near_time_buf,          29*png_sizeof(char));   }#else   sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000",       ptime->day % 32, short_months[(ptime->month - 1) % 12],       ptime->year, ptime->hour % 24, ptime->minute % 60,       ptime->second % 61);#endif#endif /* _WIN32_WCE */   return ((png_charp)png_ptr->time_buffer);}#endif /* PNG_TIME_RFC1123_SUPPORTED */#if 0/* Signature string for a PNG file. */png_bytep PNGAPIpng_sig_bytes(void){   return ((png_bytep)"\211\120\116\107\015\012\032\012");}#endifpng_charp PNGAPIpng_get_copyright(png_structp png_ptr){   if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */   return ((png_charp) "\n libpng version 1.2.8 - December 3, 2004\n\   Copyright (c) 1998-2004 Glenn Randers-Pehrson\n\   Copyright (c) 1996-1997 Andreas Dilger\n\   Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n");   return ((png_charp) "");}/* The following return the library version as a short string in the * 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_charp PNGAPIpng_get_libpng_ver(png_structp png_ptr){   /* Version of *.c files used when building libpng */   if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */      return ((png_charp) PNG_LIBPNG_VER_STRING);   return ((png_charp) "");}png_charp PNGAPIpng_get_header_ver(png_structp png_ptr){   /* Version of *.h files used when building libpng */   if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */      return ((png_charp) PNG_LIBPNG_VER_STRING);   return ((png_charp) "");}png_charp PNGAPIpng_get_header_version(png_structp png_ptr){   /* Returns longer string containing both version and date */   if (&png_ptr != NULL)  /* silence compiler warning about unused png_ptr */      return ((png_charp) PNG_HEADER_VERSION_STRING);   return ((png_charp) "");}#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTEDint PNGAPIpng_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name){   /* check chunk_name and return "keep" value if it's on the list, else 0 */   int i;   png_bytep p;   if((png_ptr == NULL && chunk_name == NULL) || png_ptr->num_chunk_list<=0)      return 0;   p=png_ptr->chunk_list+png_ptr->num_chunk_list*5-5;   for (i = png_ptr->num_chunk_list; i; i--, p-=5)      if (!png_memcmp(chunk_name, p, 4))        return ((int)*(p+4));   return 0;}#endif/* This function, added to libpng-1.0.6g, is untested. */int PNGAPIpng_reset_zstream(png_structp png_ptr){   return (inflateReset(&png_ptr->zstream));}/* This function was added to libpng-1.0.7 */png_uint_32 PNGAPIpng_access_version_number(void){   /* Version of *.c files used when building libpng */   return((png_uint_32) PNG_LIBPNG_VER);}#if !defined(PNG_1_0_X)#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)    /* GRR:  could add this:   && defined(PNG_MMX_CODE_SUPPORTED) *//* this INTERNAL function was added to libpng 1.2.0 */void /* PRIVATE */png_init_mmx_flags (png_structp png_ptr){    png_ptr->mmx_rowbytes_threshold = 0;    png_ptr->mmx_bitdepth_threshold = 0;#  if (defined(PNG_USE_PNGVCRD) || defined(PNG_USE_PNGGCCRD))    png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_COMPILED;    if (png_mmx_support() > 0) {        png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU#    ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW                              | PNG_ASM_FLAG_MMX_READ_COMBINE_ROW#    endif#    ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE                              | PNG_ASM_FLAG_MMX_READ_INTERLACE#    endif#    ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW                              ;#    else                              | PNG_ASM_FLAG_MMX_READ_FILTER_SUB                              | PNG_ASM_FLAG_MMX_READ_FILTER_UP                              | PNG_ASM_FLAG_MMX_READ_FILTER_AVG                              | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;        png_ptr->mmx_rowbytes_threshold = PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT;        png_ptr->mmx_bitdepth_threshold = PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT;#    endif    } else {        png_ptr->asm_flags &= ~( PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU                               | PNG_MMX_READ_FLAGS                               | PNG_MMX_WRITE_FLAGS );    }#  else /* !((PNGVCRD || PNGGCCRD) && PNG_ASSEMBLER_CODE_SUPPORTED)) */    /* clear all MMX flags; no support is compiled in */    png_ptr->asm_flags &= ~( PNG_MMX_FLAGS );#  endif /* ?(PNGVCRD || PNGGCCRD) */}#endif /* !(PNG_ASSEMBLER_CODE_SUPPORTED) *//* this function was added to libpng 1.2.0 */#if !defined(PNG_USE_PNGGCCRD) && \    !(defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD))int PNGAPIpng_mmx_support(void){    return -1;}#endif#endif /* PNG_1_0_X */#ifdef PNG_SIZE_T/* Added at libpng version 1.2.6 */   PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));png_size_t PNGAPIpng_convert_size(size_t size){  if (size > (png_size_t)-1)     PNG_ABORT();  /* We haven't got access to png_ptr, so no png_error() */  return ((png_size_t)size);}#endif /* PNG_SIZE_T */