#endif#endif}#endif#if defined(PNG_iCCP_SUPPORTED)void PNGAPIpng_set_iCCP(png_structp png_ptr, png_infop info_ptr,             png_charp name, int compression_type,             png_charp profile, png_uint_32 proflen){   png_charp new_iccp_name;   png_charp new_iccp_profile;   png_debug1(1, "in %s storage function\n", "iCCP");   if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)      return;   new_iccp_name = (png_charp)png_malloc(png_ptr, png_strlen(name)+1);   strcpy(new_iccp_name, name);   new_iccp_profile = (png_charp)png_malloc(png_ptr, proflen);   png_memcpy(new_iccp_profile, profile, (png_size_t)proflen);   png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0);   info_ptr->iccp_proflen = proflen;   info_ptr->iccp_name = new_iccp_name;   info_ptr->iccp_profile = new_iccp_profile;   /* Compression is always zero but is here so the API and info structure    * does not have to change if we introduce multiple compression types */   info_ptr->iccp_compression = (png_byte)compression_type;#ifdef PNG_FREE_ME_SUPPORTED   info_ptr->free_me |= PNG_FREE_ICCP;#endif   info_ptr->valid |= PNG_INFO_iCCP;}#endif#if defined(PNG_TEXT_SUPPORTED)void PNGAPIpng_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,   int num_text){   int i;   png_debug1(1, "in %s storage function\n", (png_ptr->chunk_name[0] == '\0' ?      "text" : (png_const_charp)png_ptr->chunk_name));   if (png_ptr == NULL || info_ptr == NULL || num_text == 0)      return;   /* Make sure we have enough space in the "text" array in info_struct    * to hold all of the incoming text_ptr objects.    */   if (info_ptr->num_text + num_text > info_ptr->max_text)   {      if (info_ptr->text != NULL)      {         png_textp old_text;         int old_max;         old_max = info_ptr->max_text;         info_ptr->max_text = info_ptr->num_text + num_text + 8;         old_text = info_ptr->text;         info_ptr->text = (png_textp)png_malloc(png_ptr,            (png_uint_32)(info_ptr->max_text * sizeof (png_text)));         png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max *            sizeof(png_text)));         png_free(png_ptr, old_text);      }      else      {         info_ptr->max_text = num_text + 8;         info_ptr->num_text = 0;         info_ptr->text = (png_textp)png_malloc(png_ptr,            (png_uint_32)(info_ptr->max_text * sizeof (png_text)));#ifdef PNG_FREE_ME_SUPPORTED         info_ptr->free_me |= PNG_FREE_TEXT;#endif      }      png_debug1(3, "allocated %d entries for info_ptr->text\n",         info_ptr->max_text);   }   for (i = 0; i < num_text; i++)   {      png_size_t text_length,key_len;      png_size_t lang_len,lang_key_len;      png_textp textp = &(info_ptr->text[info_ptr->num_text]);      if (text_ptr[i].key == (png_charp)NULL)          continue;      key_len = png_strlen(text_ptr[i].key);      if(text_ptr[i].compression <= 0)      {        lang_len = 0;        lang_key_len = 0;      }      else#ifdef PNG_iTXt_SUPPORTED      {        /* set iTXt data */        if (text_ptr[i].key != (png_charp)NULL)          lang_len = png_strlen(text_ptr[i].lang);        else          lang_len = 0;        if (text_ptr[i].lang_key != (png_charp)NULL)          lang_key_len = png_strlen(text_ptr[i].lang_key);        else          lang_key_len = 0;      }#else      {        png_warning(png_ptr, "iTXt chunk not supported.");        continue;      }#endif      if (text_ptr[i].text == (png_charp)NULL || text_ptr[i].text[0] == '\0')      {         text_length = 0;#ifdef PNG_iTXt_SUPPORTED         if(text_ptr[i].compression > 0)            textp->compression = PNG_ITXT_COMPRESSION_NONE;         else#endif            textp->compression = PNG_TEXT_COMPRESSION_NONE;      }      else      {         text_length = png_strlen(text_ptr[i].text);         textp->compression = text_ptr[i].compression;      }      textp->key = (png_charp)png_malloc(png_ptr,         (png_uint_32)(key_len + text_length + lang_len + lang_key_len + 4));      png_debug2(2, "Allocated %d bytes at %x in png_set_text\n",         key_len + lang_len + lang_key_len + text_length + 4, (int)textp->key);      png_memcpy(textp->key, text_ptr[i].key,         (png_size_t)(key_len));      *(textp->key+key_len) = '\0';#ifdef PNG_iTXt_SUPPORTED      if (text_ptr[i].compression > 0)      {         textp->lang=textp->key + key_len + 1;         png_memcpy(textp->lang, text_ptr[i].lang, lang_len);         *(textp->lang+lang_len) = '\0';         textp->lang_key=textp->lang + lang_len + 1;         png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len);         *(textp->lang_key+lang_key_len) = '\0';         textp->text=textp->lang_key + lang_key_len + 1;      }      else#endif      {#ifdef PNG_iTXt_SUPPORTED         textp->lang=(png_charp)NULL;         textp->lang_key=(png_charp)NULL;#endif         textp->text=textp->key + key_len + 1;      }      if(text_length)         png_memcpy(textp->text, text_ptr[i].text,            (png_size_t)(text_length));      *(textp->text+text_length) = '\0';#ifdef PNG_iTXt_SUPPORTED      if(textp->compression > 0)      {         textp->text_length = 0;         textp->itxt_length = text_length;      }      else#endif      {         textp->text_length = text_length;#ifdef PNG_iTXt_SUPPORTED         textp->itxt_length = 0;#endif      }      info_ptr->text[info_ptr->num_text]= *textp;      info_ptr->num_text++;      png_debug1(3, "transferred text chunk %d\n", info_ptr->num_text);   }}#endif#if defined(PNG_tIME_SUPPORTED)void PNGAPIpng_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time){   png_debug1(1, "in %s storage function\n", "tIME");   if (png_ptr == NULL || info_ptr == NULL ||       (png_ptr->mode & PNG_WROTE_tIME))      return;   png_memcpy(&(info_ptr->mod_time), mod_time, sizeof (png_time));   info_ptr->valid |= PNG_INFO_tIME;}#endif#if defined(PNG_tRNS_SUPPORTED)void PNGAPIpng_set_tRNS(png_structp png_ptr, png_infop info_ptr,   png_bytep trans, int num_trans, png_color_16p trans_values){   png_debug1(1, "in %s storage function\n", "tRNS");   if (png_ptr == NULL || info_ptr == NULL)      return;   if (trans != NULL)   {       /*	* It may not actually be necessary to set png_ptr->trans here;	* we do it for backward compatibility with the way the png_handle_tRNS	* function used to do the allocation.	*/#ifdef PNG_FREE_ME_SUPPORTED       png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);#endif       png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr, num_trans);       memcpy(info_ptr->trans, trans, num_trans);#ifdef PNG_FREE_ME_SUPPORTED       info_ptr->free_me |= PNG_FREE_TRNS;#else       png_ptr->flags |= PNG_FLAG_FREE_TRNS;#endif   }   if (trans_values != NULL)   {      png_memcpy(&(info_ptr->trans_values), trans_values,         sizeof(png_color_16));      if (num_trans == 0)        num_trans = 1;   }   info_ptr->num_trans = (png_uint_16)num_trans;   info_ptr->valid |= PNG_INFO_tRNS;}#endif#if defined(PNG_sPLT_SUPPORTED)void PNGAPIpng_set_sPLT(png_structp png_ptr,             png_infop info_ptr, png_sPLT_tp entries, int nentries){    png_sPLT_tp np;    int i;    np = (png_sPLT_tp)png_malloc(png_ptr,        (info_ptr->splt_palettes_num + nentries) * sizeof(png_sPLT_t));    png_memcpy(np, info_ptr->splt_palettes,           info_ptr->splt_palettes_num * sizeof(png_sPLT_t));    png_free(png_ptr, info_ptr->splt_palettes);    info_ptr->splt_palettes=NULL;    for (i = 0; i < nentries; i++)    {        png_sPLT_tp to = np + info_ptr->splt_palettes_num + i;        png_sPLT_tp from = entries + i;        to->name = (png_charp)png_malloc(png_ptr,                                        png_strlen(from->name) + 1);        png_strcpy(to->name, from->name);        to->entries = (png_sPLT_entryp)png_malloc(png_ptr,                                 from->nentries * sizeof(png_sPLT_t));        png_memcpy(to->entries, from->entries,               from->nentries * sizeof(png_sPLT_t));        to->nentries = from->nentries;        to->depth = from->depth;    }    info_ptr->splt_palettes = np;    info_ptr->splt_palettes_num += nentries;    info_ptr->valid |= PNG_INFO_sPLT;#ifdef PNG_FREE_ME_SUPPORTED    info_ptr->free_me |= PNG_FREE_SPLT;#endif}#endif /* PNG_sPLT_SUPPORTED */#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)void PNGAPIpng_set_unknown_chunks(png_structp png_ptr,   png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns){    png_unknown_chunkp np;    int i;    if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0)        return;    np = (png_unknown_chunkp)png_malloc(png_ptr,        (info_ptr->unknown_chunks_num + num_unknowns) *        sizeof(png_unknown_chunk));    png_memcpy(np, info_ptr->unknown_chunks,           info_ptr->unknown_chunks_num * sizeof(png_unknown_chunk));    png_free(png_ptr, info_ptr->unknown_chunks);    info_ptr->unknown_chunks=NULL;    for (i = 0; i < num_unknowns; i++)    {        png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i;        png_unknown_chunkp from = unknowns + i;        png_strcpy((png_charp)to->name, (png_charp)from->name);        to->data = (png_bytep)png_malloc(png_ptr, from->size);        png_memcpy(to->data, from->data, from->size);        to->size = from->size;        /* note our location in the read or write sequence */        to->location = (png_byte)(png_ptr->mode & 0xff);    }    info_ptr->unknown_chunks = np;    info_ptr->unknown_chunks_num += num_unknowns;#ifdef PNG_FREE_ME_SUPPORTED    info_ptr->free_me |= PNG_FREE_UNKN;#endif}void PNGAPIpng_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr,   int chunk, int location){   if(png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk <         (int)info_ptr->unknown_chunks_num)      info_ptr->unknown_chunks[chunk].location = (png_byte)location;}#endif#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \    defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)void PNGAPIpng_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted){   /* This function is deprecated in favor of png_permit_mng_features()      and will be removed from libpng-2.0.0 */   png_debug(1, "in png_permit_empty_plte, DEPRECATED.\n");   if (png_ptr == NULL)      return;   png_ptr->mng_features_permitted = (png_byte)     ((png_ptr->mng_features_permitted & (~(PNG_FLAG_MNG_EMPTY_PLTE))) |     ((empty_plte_permitted & PNG_FLAG_MNG_EMPTY_PLTE)));}#endif#if defined(PNG_MNG_FEATURES_SUPPORTED)png_uint_32 PNGAPIpng_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features){   png_debug(1, "in png_permit_mng_features\n");   if (png_ptr == NULL)      return (png_uint_32)0;   png_ptr->mng_features_permitted =     (png_byte)(mng_features & PNG_ALL_MNG_FEATURES);   return (png_uint_32)png_ptr->mng_features_permitted;}#endif#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)void PNGAPIpng_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep   chunk_list, int num_chunks){    png_bytep new_list, p;    int i, old_num_chunks;    if (num_chunks == 0)    {      if(keep == HANDLE_CHUNK_ALWAYS || keep == HANDLE_CHUNK_IF_SAFE)        png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS;      else        png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;      if(keep == HANDLE_CHUNK_ALWAYS)        png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS;      else        png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;      return;    }    if (chunk_list == NULL)      return;    old_num_chunks=png_ptr->num_chunk_list;    new_list=(png_bytep)png_malloc(png_ptr,5*(num_chunks+old_num_chunks));    if(png_ptr->chunk_list != (png_bytep)NULL)    {       png_memcpy(new_list, png_ptr->chunk_list, 5*old_num_chunks);       png_free(png_ptr, png_ptr->chunk_list);       png_ptr->chunk_list=NULL;    }    png_memcpy(new_list+5*old_num_chunks, chunk_list, 5*num_chunks);    for (p=new_list+5*old_num_chunks+4, i=0; i<num_chunks; i++, p+=5)       *p=(png_byte)keep;    png_ptr->num_chunk_list=old_num_chunks+num_chunks;    png_ptr->chunk_list=new_list;#ifdef PNG_FREE_ME_SUPPORTED    png_ptr->free_me |= PNG_FREE_LIST;#endif}#endif#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)void PNGAPIpng_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr,   png_user_chunk_ptr read_user_chunk_fn){   png_debug(1, "in png_set_read_user_chunk_fn\n");   png_ptr->read_user_chunk_fn = read_user_chunk_fn;   png_ptr->user_chunk_ptr = user_chunk_ptr;}#endif#if defined(PNG_INFO_IMAGE_SUPPORTED)void PNGAPIpng_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers){   png_debug1(1, "in %s storage function\n", "rows");   if (png_ptr == NULL || info_ptr == NULL)      return;   if(info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers))      png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);   info_ptr->row_pointers = row_pointers;   if(row_pointers)      info_ptr->valid |= PNG_INFO_IDAT;}#endifvoid PNGAPIpng_set_compression_buffer_size(png_structp png_ptr, png_uint_32 size){    if(png_ptr->zbuf)       png_free(png_ptr, png_ptr->zbuf);    png_ptr->zbuf_size = (png_size_t)size;    png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size);    if(!png_ptr->zbuf)       png_error(png_ptr,"Unable to malloc zbuf");    png_ptr->zstream.next_out = png_ptr->zbuf;    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;}void PNGAPIpng_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask){   if (png_ptr && info_ptr)      info_ptr->valid &= ~(mask);}