Subversion Repositories Kolibri OS

 *

 * Last changed in libpng 1.5.1 [February 3, 2011]

 * Copyright (c) 1998-2011 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

 *

 * The functions here are used during reads to store data from the file

 * into the info struct, and during writes to store application data

 * into the info struct for writing into the file.  This abstracts the

 * info struct and allows us to change the structure in the future.

 */

void PNGAPI

png_set_bKGD(png_structp png_ptr, png_infop info_ptr,

    png_const_color_16p background)

{

   png_debug1(1, "in %s storage function", "bKGD");

      return;

   info_ptr->valid |= PNG_INFO_bKGD;

}

#endif

void PNGFAPI

png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,

    png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,

    png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,

    png_fixed_point blue_x, png_fixed_point blue_y)

{

   png_debug1(1, "in %s storage function", "cHRM fixed");

      return;

   if (png_check_cHRM_fixed(png_ptr,

       white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y))

#  endif

   {

      info_ptr->x_white = white_x;

      info_ptr->y_white = white_y;

      info_ptr->x_red   = red_x;

      info_ptr->y_red   = red_y;

      info_ptr->x_green = green_x;

      info_ptr->y_green = green_y;

      info_ptr->x_blue  = blue_x;

      info_ptr->y_blue  = blue_y;

      info_ptr->valid |= PNG_INFO_cHRM;

   }

}

void PNGAPI

png_set_cHRM(png_structp png_ptr, png_infop info_ptr,

    double white_x, double white_y, double red_x, double red_y,

    double green_x, double green_y, double blue_x, double blue_y)

{

   png_set_cHRM_fixed(png_ptr, info_ptr,

      png_fixed(png_ptr, white_x, "cHRM White X"),

      png_fixed(png_ptr, white_y, "cHRM White Y"),

      png_fixed(png_ptr, red_x, "cHRM Red X"),

      png_fixed(png_ptr, red_y, "cHRM Red Y"),

      png_fixed(png_ptr, green_x, "cHRM Green X"),

      png_fixed(png_ptr, green_y, "cHRM Green Y"),

      png_fixed(png_ptr, blue_x, "cHRM Blue X"),

      png_fixed(png_ptr, blue_y, "cHRM Blue Y"));

}

#  endif /* PNG_FLOATING_POINT_SUPPORTED */

void PNGFAPI

png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point

    file_gamma)

{

   png_debug1(1, "in %s storage function", "gAMA");

      return;

    * wrong, therefore storing them (and setting PNG_INFO_gAMA)

    * must be wrong too.

    */

   if (file_gamma > (png_fixed_point)PNG_UINT_31_MAX)

      png_warning(png_ptr, "Gamma too large, ignored");

      png_warning(png_ptr, "Negative or zero gamma ignored");

   {

      info_ptr->gamma = file_gamma;

      info_ptr->valid |= PNG_INFO_gAMA;

   }

}

void PNGAPI

png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)

{

   png_set_gAMA_fixed(png_ptr, info_ptr, png_fixed(png_ptr, file_gamma,

       "png_set_gAMA"));

}

#  endif

#endif

void PNGAPI

png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_const_uint_16p hist)

{

   int i;

      return;

       > PNG_MAX_PALETTE_LENGTH)

   {

      png_warning(png_ptr,

          "Invalid palette size, hIST allocation skipped");

   }

    * version 1.2.1

    */

   png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr,

       PNG_MAX_PALETTE_LENGTH * png_sizeof(png_uint_16));

   {

      png_warning(png_ptr, "Insufficient memory for hIST chunk data");

      return;

   }

      png_ptr->hist[i] = hist[i];

   info_ptr->valid |= PNG_INFO_hIST;

   info_ptr->free_me |= PNG_FREE_HIST;

}

#endif

png_set_IHDR(png_structp png_ptr, png_infop info_ptr,

    png_uint_32 width, png_uint_32 height, int bit_depth,

    int color_type, int interlace_type, int compression_type,

    int filter_type)

{

   png_debug1(1, "in %s storage function", "IHDR");

      return;

   info_ptr->height = height;

   info_ptr->bit_depth = (png_byte)bit_depth;

   info_ptr->color_type = (png_byte)color_type;

   info_ptr->compression_type = (png_byte)compression_type;

   info_ptr->filter_type = (png_byte)filter_type;

   info_ptr->interlace_type = (png_byte)interlace_type;

       info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,

       info_ptr->compression_type, info_ptr->filter_type);

      info_ptr->channels = 1;

      info_ptr->channels = 3;

      info_ptr->channels = 1;

      info_ptr->channels++;

   if (width >

       (PNG_UINT_32_MAX >> 3)      /* 8-byte RRGGBBAA pixels */

       - 48       /* bigrowbuf hack */

       - 1        /* filter byte */

       - 7*8      /* rounding of width to multiple of 8 pixels */

       - 8)       /* extra max_pixel_depth pad */

      info_ptr->rowbytes = 0;

   else

      info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, width);

}

void PNGAPI

png_set_oFFs(png_structp png_ptr, png_infop info_ptr,

    png_int_32 offset_x, png_int_32 offset_y, int unit_type)

{

   png_debug1(1, "in %s storage function", "oFFs");

      return;

   info_ptr->y_offset = offset_y;

   info_ptr->offset_unit_type = (png_byte)unit_type;

   info_ptr->valid |= PNG_INFO_oFFs;

}

#endif

void PNGAPI

png_set_pCAL(png_structp png_ptr, png_infop info_ptr,

    png_const_charp purpose, png_int_32 X0, png_int_32 X1, int type,

    int nparams, png_const_charp units, png_charpp params)

{

   png_size_t length;

   int i;

      return;

   png_debug1(3, "allocating purpose for info (%lu bytes)",

       (unsigned long)length);

   if (type < 0 || type > 3)

      png_error(png_ptr, "Invalid pCAL equation type");

   for (i=0; i

      if (!png_check_fp_string(params[i], png_strlen(params[i])))

         png_error(png_ptr, "Invalid format for pCAL parameter");

   {

      png_warning(png_ptr, "Insufficient memory for pCAL purpose");

      return;

   }

   info_ptr->pcal_X0 = X0;

   info_ptr->pcal_X1 = X1;

   info_ptr->pcal_type = (png_byte)type;

   info_ptr->pcal_nparams = (png_byte)nparams;

   png_debug1(3, "allocating units for info (%lu bytes)",

     (unsigned long)length);

   {

      png_warning(png_ptr, "Insufficient memory for pCAL units");

      return;

   }

       (png_size_t)((nparams + 1) * png_sizeof(png_charp)));

   {

      png_warning(png_ptr, "Insufficient memory for pCAL params");

      return;

   }

   {

      length = png_strlen(params[i]) + 1;

      png_debug2(3, "allocating parameter %d for info (%lu bytes)", i,

          (unsigned long)length);

      {

         png_warning(png_ptr, "Insufficient memory for pCAL parameter");

         return;

      }

   }

   info_ptr->free_me |= PNG_FREE_PCAL;

}

#endif

void PNGAPI

png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,

    int unit, png_const_charp swidth, png_const_charp sheight)

{

   png_size_t lengthw = 0, lengthh = 0;

      return;

    * unit unless this is an API call.)

    */

   if (unit != 1 && unit != 2)

      png_error(png_ptr, "Invalid sCAL unit");

       swidth[0] == 45 /*'-'*/ || !png_check_fp_string(swidth, lengthw))

      png_error(png_ptr, "Invalid sCAL width");

       sheight[0] == 45 /*'-'*/ || !png_check_fp_string(sheight, lengthh))

      png_error(png_ptr, "Invalid sCAL height");

   {

      png_warning(png_ptr, "Memory allocation failed while processing sCAL");

      return;

   }

   {

      png_free (png_ptr, info_ptr->scal_s_width);

      info_ptr->scal_s_width = NULL;

      return;

   }

   info_ptr->free_me |= PNG_FREE_SCAL;

}

void PNGAPI

png_set_sCAL(png_structp png_ptr, png_infop info_ptr, int unit, double width,

    double height)

{

   png_debug1(1, "in %s storage function", "sCAL");

   if (width <= 0)

      png_warning(png_ptr, "Invalid sCAL width ignored");

      png_warning(png_ptr, "Invalid sCAL height ignored");

   {

      /* Convert 'width' and 'height' to ASCII. */

      char swidth[PNG_sCAL_MAX_DIGITS+1];

      char sheight[PNG_sCAL_MAX_DIGITS+1];

         PNG_sCAL_PRECISION);

      png_ascii_from_fp(png_ptr, sheight, sizeof sheight, height,

         PNG_sCAL_PRECISION);

   }

}

#  endif

void PNGAPI

png_set_sCAL_fixed(png_structp png_ptr, png_infop info_ptr, int unit,

    png_fixed_point width, png_fixed_point height)

{

   png_debug1(1, "in %s storage function", "sCAL");

   if (width <= 0)

      png_warning(png_ptr, "Invalid sCAL width ignored");

      png_warning(png_ptr, "Invalid sCAL height ignored");

   {

      /* Convert 'width' and 'height' to ASCII. */

      char swidth[PNG_sCAL_MAX_DIGITS+1];

      char sheight[PNG_sCAL_MAX_DIGITS+1];

      png_ascii_from_fixed(png_ptr, sheight, sizeof sheight, height);

   }

}

#  endif

#endif

void PNGAPI

png_set_pHYs(png_structp png_ptr, png_infop info_ptr,

    png_uint_32 res_x, png_uint_32 res_y, int unit_type)

{

   png_debug1(1, "in %s storage function", "pHYs");

      return;

   info_ptr->y_pixels_per_unit = res_y;

   info_ptr->phys_unit_type = (png_byte)unit_type;

   info_ptr->valid |= PNG_INFO_pHYs;

}

#endif

png_set_PLTE(png_structp png_ptr, png_infop info_ptr,

    png_const_colorp palette, int num_palette)

{

      return;

   {

      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

         png_error(png_ptr, "Invalid palette length");

      {

         png_warning(png_ptr, "Invalid palette length");

         return;

      }

   }

    * we do it for backward compatibility with the way the png_handle_tRNS

    * function used to do the allocation.

    */

   png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0);

    * of num_palette entries, in case of an invalid PNG file that has

    * too-large sample values.

    */

   png_ptr->palette = (png_colorp)png_calloc(png_ptr,

       PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color));

   info_ptr->palette = png_ptr->palette;

   info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;

}

void PNGAPI

png_set_sBIT(png_structp png_ptr, png_infop info_ptr,

    png_const_color_8p sig_bit)

{

   png_debug1(1, "in %s storage function", "sBIT");

      return;

   info_ptr->valid |= PNG_INFO_sBIT;

}

#endif

void PNGAPI

png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int srgb_intent)

{

   png_debug1(1, "in %s storage function", "sRGB");

      return;

   info_ptr->valid |= PNG_INFO_sRGB;

}

png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,

    int srgb_intent)

{

   png_debug1(1, "in %s storage function", "sRGB_gAMA_and_cHRM");

      return;

   png_set_gAMA_fixed(png_ptr, info_ptr, 45455L);

#  endif

   png_set_cHRM_fixed(png_ptr, info_ptr,

      /* color      x       y */

      /* white */ 31270L, 32900L,

      /* red   */ 64000L, 33000L,

      /* green */ 30000L, 60000L,

      /* blue  */ 15000L,  6000L

   );

#  endif /* cHRM */

}

#endif /* sRGB */

void PNGAPI

png_set_iCCP(png_structp png_ptr, png_infop info_ptr,

    png_const_charp name, int compression_type,

    png_const_bytep profile, png_uint_32 proflen)

{

   png_charp new_iccp_name;

   png_bytep new_iccp_profile;

   png_uint_32 length;

      return;

   new_iccp_name = (png_charp)png_malloc_warn(png_ptr, length);

   {

        png_warning(png_ptr, "Insufficient memory to process iCCP chunk");

      return;

   }

   new_iccp_profile = (png_bytep)png_malloc_warn(png_ptr, proflen);

   {

      png_free (png_ptr, new_iccp_name);

      png_warning(png_ptr,

          "Insufficient memory to process iCCP profile");

      return;

   }

   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;

   info_ptr->free_me |= PNG_FREE_ICCP;

   info_ptr->valid |= PNG_INFO_iCCP;

}

#endif

void PNGAPI

png_set_text(png_structp png_ptr, png_infop info_ptr, png_const_textp text_ptr,

    int num_text)

{

   int ret;

   ret = png_set_text_2(png_ptr, info_ptr, text_ptr, num_text);

      png_error(png_ptr, "Insufficient memory to store text");

}

png_set_text_2(png_structp png_ptr, png_infop info_ptr,

    png_const_textp text_ptr, int num_text)

{

   int i;

       png_ptr->chunk_name[0] == '\0') ?

       "text" : (png_const_charp)png_ptr->chunk_name));

      return(0);

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

         info_ptr->max_text = info_ptr->num_text + num_text + 8;

         old_text = info_ptr->text;

         info_ptr->text = (png_textp)png_malloc_warn(png_ptr,

            (png_size_t)(info_ptr->max_text * png_sizeof(png_text)));

         {

            png_free(png_ptr, old_text);

            return(1);

         }

             png_sizeof(png_text)));

         png_free(png_ptr, old_text);

      }

      {

         info_ptr->max_text = num_text + 8;

         info_ptr->num_text = 0;

         info_ptr->text = (png_textp)png_malloc_warn(png_ptr,

             (png_size_t)(info_ptr->max_text * png_sizeof(png_text)));

         if (info_ptr->text == NULL)

            return(1);

         info_ptr->free_me |= PNG_FREE_TEXT;

      }

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

          continue;

          text_ptr[i].compression >= PNG_TEXT_COMPRESSION_LAST)

      {

         png_warning(png_ptr, "text compression mode is out of range");

         continue;

      }

      {

         lang_len = 0;

         lang_key_len = 0;

      }

#  ifdef PNG_iTXt_SUPPORTED

      {

         /* Set iTXt data */

            lang_len = png_strlen(text_ptr[i].lang);

            lang_len = 0;

            lang_key_len = png_strlen(text_ptr[i].lang_key);

            lang_key_len = 0;

      }

#  else /* PNG_iTXt_SUPPORTED */

      {

         png_warning(png_ptr, "iTXt chunk not supported");

         continue;

      }

#  endif

      {

         text_length = 0;

#  ifdef PNG_iTXt_SUPPORTED

         if (text_ptr[i].compression > 0)

            textp->compression = PNG_ITXT_COMPRESSION_NONE;

#  endif

            textp->compression = PNG_TEXT_COMPRESSION_NONE;

      }

      {

         text_length = png_strlen(text_ptr[i].text);

         textp->compression = text_ptr[i].compression;

      }

          (png_size_t)

          (key_len + text_length + lang_len + lang_key_len + 4));

         return(1);

          (unsigned long)(png_uint_32)

          (key_len + lang_len + lang_key_len + text_length + 4),

          textp->key);

      *(textp->key + key_len) = '\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;

      }

      {

         textp->lang=NULL;

         textp->lang_key=NULL;

         textp->text = textp->key + key_len + 1;

      }

         png_memcpy(textp->text, text_ptr[i].text,

             (png_size_t)(text_length));

      if (textp->compression > 0)

      {

         textp->text_length = 0;

         textp->itxt_length = text_length;

      }

#  endif

      {

         textp->text_length = text_length;

         textp->itxt_length = 0;

      }

      png_debug1(3, "transferred text chunk %d", info_ptr->num_text);

   }

   return(0);

}

#endif

void PNGAPI

png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_const_timep mod_time)

{

   png_debug1(1, "in %s storage function", "tIME");

       (png_ptr->mode & PNG_WROTE_tIME))

      return;

   info_ptr->valid |= PNG_INFO_tIME;

}

#endif

void PNGAPI

png_set_tRNS(png_structp png_ptr, png_infop info_ptr,

    png_const_bytep trans_alpha, int num_trans, png_const_color_16p trans_color)

{

   png_debug1(1, "in %s storage function", "tRNS");

      return;

   {

       /* It may not actually be necessary to set png_ptr->trans_alpha here;

        * we do it for backward compatibility with the way the png_handle_tRNS

        * function used to do the allocation.

        */

       png_ptr->trans_alpha = info_ptr->trans_alpha =

           (png_bytep)png_malloc(png_ptr, (png_size_t)PNG_MAX_PALETTE_LENGTH);

          png_memcpy(info_ptr->trans_alpha, trans_alpha, (png_size_t)num_trans);

   }

   {

      int sample_max = (1 << info_ptr->bit_depth);

          (int)trans_color->gray > sample_max) ||

          (info_ptr->color_type == PNG_COLOR_TYPE_RGB &&

          ((int)trans_color->red > sample_max ||

          (int)trans_color->green > sample_max ||

          (int)trans_color->blue > sample_max)))

         png_warning(png_ptr,

            "tRNS chunk has out-of-range samples for bit_depth");

         png_sizeof(png_color_16));

         num_trans = 1;

   }

   {

      info_ptr->valid |= PNG_INFO_tRNS;

      info_ptr->free_me |= PNG_FREE_TRNS;

   }

}

#endif

void PNGAPI

png_set_sPLT(png_structp png_ptr,

    png_infop info_ptr, png_const_sPLT_tp entries, int nentries)

/*

 *  entries        - array of png_sPLT_t structures

 *                   to be added to the list of palettes

 *                   in the info structure.

 *

 *  nentries       - number of palette structures to be

 *                   added.

 */

{

   png_sPLT_tp np;

   int i;

      return;

       (info_ptr->splt_palettes_num + nentries) *

       (png_size_t)png_sizeof(png_sPLT_t));

   {

      png_warning(png_ptr, "No memory for sPLT palettes");

      return;

   }

       info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t));

   info_ptr->splt_palettes=NULL;

   {

      png_sPLT_tp to = np + info_ptr->splt_palettes_num + i;

      png_const_sPLT_tp from = entries + i;

      png_uint_32 length;

      to->name = (png_charp)png_malloc_warn(png_ptr, (png_size_t)length);

      {

         png_warning(png_ptr,

             "Out of memory while processing sPLT chunk");

         continue;

      }

      to->entries = (png_sPLT_entryp)png_malloc_warn(png_ptr,

          (png_size_t)(from->nentries * png_sizeof(png_sPLT_entry)));

      {

         png_warning(png_ptr,

             "Out of memory while processing sPLT chunk");

         png_free(png_ptr, to->name);

         to->name = NULL;

         continue;

      }

          from->nentries * png_sizeof(png_sPLT_entry));

      to->depth = from->depth;

   }

   info_ptr->splt_palettes_num += nentries;

   info_ptr->valid |= PNG_INFO_sPLT;

   info_ptr->free_me |= PNG_FREE_SPLT;

}

#endif /* PNG_sPLT_SUPPORTED */

void PNGAPI

png_set_unknown_chunks(png_structp png_ptr,

   png_infop info_ptr, png_const_unknown_chunkp unknowns, int num_unknowns)

{

   png_unknown_chunkp np;

   int i;

      return;

       (png_size_t)(info_ptr->unknown_chunks_num + num_unknowns) *

       png_sizeof(png_unknown_chunk));

   {

      png_warning(png_ptr,

          "Out of memory while processing unknown chunk");

      return;

   }

       (png_size_t)info_ptr->unknown_chunks_num *

       png_sizeof(png_unknown_chunk));

   info_ptr->unknown_chunks = NULL;

   {

      png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i;

      png_const_unknown_chunkp from = unknowns + i;

      to->name[png_sizeof(to->name)-1] = '\0';

      to->size = from->size;

      to->location = (png_byte)(png_ptr->mode & 0xff);

         to->data=NULL;

      {

         to->data = (png_bytep)png_malloc_warn(png_ptr,

             (png_size_t)from->size);

         {

            png_warning(png_ptr,

                "Out of memory while processing unknown chunk");

            to->size = 0;

         }

            png_memcpy(to->data, from->data, from->size);

      }

   }

   info_ptr->unknown_chunks_num += num_unknowns;

   info_ptr->free_me |= PNG_FREE_UNKN;

}

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

       info_ptr->unknown_chunks_num)

      info_ptr->unknown_chunks[chunk].location = (png_byte)location;

}

#endif

png_uint_32 PNGAPI

png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features)

{

   png_debug(1, "in png_permit_mng_features");

      return (png_uint_32)0;

       (png_byte)(mng_features & PNG_ALL_MNG_FEATURES);

}

#endif

void PNGAPI

png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_const_bytep

    chunk_list, int num_chunks)

{

   png_bytep new_list, p;

   int i, old_num_chunks;

   if (png_ptr == NULL)

      return;

   {

      if (keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE)

         png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS;

         png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;

         png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS;

         png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;

   }

      return;

   new_list=(png_bytep)png_malloc(png_ptr,

       (png_size_t)(5*(num_chunks + old_num_chunks)));

   {

      png_memcpy(new_list, png_ptr->chunk_list,

          (png_size_t)(5*old_num_chunks));

      png_free(png_ptr, png_ptr->chunk_list);

      png_ptr->chunk_list=NULL;

   }

       (png_size_t)(5*num_chunks));

      *p=(png_byte)keep;

   png_ptr->chunk_list = new_list;

   png_ptr->free_me |= PNG_FREE_LIST;

}

#endif

void PNGAPI

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

      return;

   png_ptr->user_chunk_ptr = user_chunk_ptr;

}

#endif

void PNGAPI

png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers)

{

   png_debug1(1, "in %s storage function", "rows");

      return;

      png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);