Subversion Repositories Kolibri OS

 *

 * Last changed in libpng 1.6.3 [July 18, 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

 *

 * 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_const_structrp png_ptr, png_inforp 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_const_structrp png_ptr, png_inforp 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_xy xy;

      return;

   xy.redy = red_y;

   xy.greenx = green_x;

   xy.greeny = green_y;

   xy.bluex = blue_x;

   xy.bluey = blue_y;

   xy.whitex = white_x;

   xy.whitey = white_y;

      2/* override with app values*/))

      info_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM;

}

png_set_cHRM_XYZ_fixed(png_const_structrp png_ptr, png_inforp info_ptr,

    png_fixed_point int_red_X, png_fixed_point int_red_Y,

    png_fixed_point int_red_Z, png_fixed_point int_green_X,

    png_fixed_point int_green_Y, png_fixed_point int_green_Z,

    png_fixed_point int_blue_X, png_fixed_point int_blue_Y,

    png_fixed_point int_blue_Z)

{

   png_XYZ XYZ;

      return;

   XYZ.red_Y = int_red_Y;

   XYZ.red_Z = int_red_Z;

   XYZ.green_X = int_green_X;

   XYZ.green_Y = int_green_Y;

   XYZ.green_Z = int_green_Z;

   XYZ.blue_X = int_blue_X;

   XYZ.blue_Y = int_blue_Y;

   XYZ.blue_Z = int_blue_Z;

      info_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM;

}

void PNGAPI

png_set_cHRM(png_const_structrp png_ptr, png_inforp 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"));

}

png_set_cHRM_XYZ(png_const_structrp png_ptr, png_inforp info_ptr, double red_X,

    double red_Y, double red_Z, double green_X, double green_Y, double green_Z,

    double blue_X, double blue_Y, double blue_Z)

{

   png_set_cHRM_XYZ_fixed(png_ptr, info_ptr,

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

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

      png_fixed(png_ptr, red_Z, "cHRM Red Z"),

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

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

      png_fixed(png_ptr, green_Z, "cHRM Red Z"),

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

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

      png_fixed(png_ptr, blue_Z, "cHRM Red Z"));

}

#  endif /* PNG_FLOATING_POINT_SUPPORTED */

void PNGFAPI

png_set_gAMA_fixed(png_const_structrp png_ptr, png_inforp info_ptr,

    png_fixed_point file_gamma)

{

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

      return;

   png_colorspace_sync_info(png_ptr, info_ptr);

}

void PNGAPI

png_set_gAMA(png_const_structrp png_ptr, png_inforp 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_const_structrp png_ptr, png_inforp 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

    */

   info_ptr->hist = png_voidcast(png_uint_16p, png_malloc_warn(png_ptr,

       PNG_MAX_PALETTE_LENGTH * (sizeof (png_uint_16))));

   {

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

      return;

   }

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

}

#endif

png_set_IHDR(png_const_structrp png_ptr, png_inforp 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++;

}

void PNGAPI

png_set_oFFs(png_const_structrp png_ptr, png_inforp 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_const_structrp png_ptr, png_inforp 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;

      || (nparams > 0 && params == NULL))

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

      png_error(png_ptr, "Invalid pCAL parameter count");

   for (i=0; i

      if (params[i] == NULL ||

         !png_check_fp_string(params[i], strlen(params[i])))

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

      png_malloc_warn(png_ptr, length));

   {

      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_malloc_warn(png_ptr, length));

   {

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

      return;

   }

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

   {

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

      return;

   }

   {

      length = 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_const_structrp png_ptr, png_inforp 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_malloc_warn(png_ptr, lengthw));

   {

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

      return;

   }

      png_malloc_warn(png_ptr, lengthh));

   {

      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_const_structrp png_ptr, png_inforp 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_const_structrp png_ptr, png_inforp 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_const_structrp png_ptr, png_inforp 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_structrp png_ptr, png_inforp 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;

      }

   }

      (num_palette == 0

#        ifdef PNG_MNG_FEATURES_SUPPORTED

            && (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0

#        endif

      ))

   {

      png_chunk_report(png_ptr, "Invalid palette", PNG_CHUNK_ERROR);

      return;

   }

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

    * function used to do the allocation.

    *

    * 1.6.0: the above statement appears to be incorrect; something has to set

    * the palette inside png_struct on read.

    */

   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_voidcast(png_colorp, png_calloc(png_ptr,

       PNG_MAX_PALETTE_LENGTH * (sizeof (png_color))));

      memcpy(png_ptr->palette, palette, num_palette * (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_const_structrp png_ptr, png_inforp 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_const_structrp png_ptr, png_inforp info_ptr, int srgb_intent)

{

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

      return;

   png_colorspace_sync_info(png_ptr, info_ptr);

}

png_set_sRGB_gAMA_and_cHRM(png_const_structrp png_ptr, png_inforp info_ptr,

    int srgb_intent)

{

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

      return;

   {

      /* This causes the gAMA and cHRM to be written too */

      info_ptr->colorspace.flags |=

         PNG_COLORSPACE_FROM_gAMA|PNG_COLORSPACE_FROM_cHRM;

   }

}

#endif /* sRGB */

void PNGAPI

png_set_iCCP(png_const_structrp png_ptr, png_inforp 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_size_t length;

      return;

      png_app_error(png_ptr, "Invalid iCCP compression method");

    * override previously set app cHRM or gAMA here (because likely as not the

    * application knows better than libpng what the correct values are.)  Pass

    * the info_ptr color_type field to png_colorspace_set_ICC because in the

    * write case it has not yet been stored in png_ptr.

    */

   {

      int result = png_colorspace_set_ICC(png_ptr, &info_ptr->colorspace, name,

         proflen, profile, info_ptr->color_type);

      if (!result)

         return;

      info_ptr->colorspace.flags |=

         PNG_COLORSPACE_FROM_gAMA|PNG_COLORSPACE_FROM_cHRM;

   }

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

   {

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

      return;

   }

   new_iccp_profile = png_voidcast(png_bytep,

      png_malloc_warn(png_ptr, proflen));

   {

      png_free(png_ptr, new_iccp_name);

      png_benign_error(png_ptr,

          "Insufficient memory to process iCCP profile");

      return;

   }

   info_ptr->iccp_name = new_iccp_name;

   info_ptr->iccp_profile = new_iccp_profile;

   info_ptr->free_me |= PNG_FREE_ICCP;

   info_ptr->valid |= PNG_INFO_iCCP;

}

#endif

void PNGAPI

png_set_text(png_const_structrp png_ptr, png_inforp 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_const_structrp png_ptr, png_inforp info_ptr,

    png_const_textp text_ptr, int num_text)

{

   int i;

      (unsigned long)png_ptr->chunk_name);

      return(0);

    * to hold all of the incoming text_ptr objects.  This compare can't overflow

    * because max_text >= num_text (anyway, subtract of two positive integers

    * can't overflow in any case.)

    */

   if (num_text > info_ptr->max_text - info_ptr->num_text)

   {

      int old_num_text = info_ptr->num_text;

      int max_text;

      png_textp new_text = NULL;

      max_text = old_num_text;

      if (num_text <= INT_MAX - max_text)

      {

         max_text += num_text;

         if (max_text < INT_MAX-8)

            max_text = (max_text + 8) & ~0x7;

            max_text = INT_MAX;

          * the overflow checks.

          */

         new_text = png_voidcast(png_textp,png_realloc_array(png_ptr,

            info_ptr->text, old_num_text, max_text-old_num_text,

            sizeof *new_text));

      }

      {

         png_chunk_report(png_ptr, "too many text chunks",

            PNG_CHUNK_WRITE_ERROR);

         return 1;

      }

      info_ptr->free_me |= PNG_FREE_TEXT;

      info_ptr->max_text = max_text;

      /* num_text is adjusted below as the entries are copied in */

   }

   {

      size_t text_length, key_len;

      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_chunk_report(png_ptr, "text compression mode is out of range",

            PNG_CHUNK_WRITE_ERROR);

         continue;

      }

      {

         lang_len = 0;

         lang_key_len = 0;

      }

#  ifdef PNG_iTXt_SUPPORTED

      {

         /* Set iTXt data */

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

            lang_len = 0;

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

            lang_key_len = 0;

      }

#  else /* PNG_iTXt_SUPPORTED */

      {

         png_chunk_report(png_ptr, "iTXt chunk not supported",

            PNG_CHUNK_WRITE_ERROR);

         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 = strlen(text_ptr[i].text);

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

      }

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

      {

         png_chunk_report(png_ptr, "text chunk: out of memory",

               PNG_CHUNK_WRITE_ERROR);

         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;

         memcpy(textp->lang, text_ptr[i].lang, lang_len);

         *(textp->lang + lang_len) = '\0';

         textp->lang_key = textp->lang + lang_len + 1;

         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;

      }

         memcpy(textp->text, text_ptr[i].text, 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);

   }

}

#endif

void PNGAPI

png_set_tIME(png_const_structrp png_ptr, png_inforp info_ptr,

    png_const_timep mod_time)

{

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

       (png_ptr->mode & PNG_WROTE_tIME))

      return;

       mod_time->day   == 0   || mod_time->day   > 31  ||

       mod_time->hour  > 23   || mod_time->minute > 59 ||

       mod_time->second > 60)

   {

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

      return;

   }

   info_ptr->valid |= PNG_INFO_tIME;

}

#endif

void PNGAPI

png_set_tRNS(png_structrp png_ptr, png_inforp 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.

        *

        * 1.6.0: The above statement is incorrect; png_handle_tRNS effectively

        * relies on png_set_tRNS storing the information in png_struct

        * (otherwise it won't be there for the code in pngrtran.c).

        */

       png_ptr->trans_alpha = info_ptr->trans_alpha = png_voidcast(png_bytep,

         png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH));

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

   }

   {

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

          trans_color->gray > sample_max) ||

          (info_ptr->color_type == PNG_COLOR_TYPE_RGB &&

          (trans_color->red > sample_max ||

          trans_color->green > sample_max ||

          trans_color->blue > sample_max)))

         png_warning(png_ptr,

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

         num_trans = 1;

   }

   {

      info_ptr->valid |= PNG_INFO_tRNS;

      info_ptr->free_me |= PNG_FREE_TRNS;

   }

}

#endif

void PNGAPI

png_set_sPLT(png_const_structrp png_ptr,

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

      return;

    * overflows.  Notice that the parameters are (int) and (size_t)

    */

   np = png_voidcast(png_sPLT_tp,png_realloc_array(png_ptr,

      info_ptr->splt_palettes, info_ptr->splt_palettes_num, nentries,

      sizeof *np));

   {

      /* Out of memory or too many chunks */

      png_chunk_report(png_ptr, "too many sPLT chunks", PNG_CHUNK_WRITE_ERROR);

      return;

   }

   info_ptr->splt_palettes = np;

   info_ptr->free_me |= PNG_FREE_SPLT;

   {

      png_size_t length;

      if (entries->name == NULL || entries->entries == NULL)

      {

         /* png_handle_sPLT doesn't do this, so this is an app error */

         png_app_error(png_ptr, "png_set_sPLT: invalid sPLT");

         /* Just skip the invalid entry */

         continue;

      }

       * trying to add sPLT chunks.

       */

      length = strlen(entries->name) + 1;

      np->name = png_voidcast(png_charp, png_malloc_base(png_ptr, length));

         break;

       * goes wrong, this code must free it.  png_malloc_array produces no

       * warnings, use a png_chunk_report (below) if there is an error.

       */

      np->entries = png_voidcast(png_sPLT_entryp, png_malloc_array(png_ptr,

          entries->nentries, sizeof (png_sPLT_entry)));

      {

         png_free(png_ptr, np->name);

         break;

      }

      /* This multiply can't overflow because png_malloc_array has already

       * checked it when doing the allocation.

       */

      memcpy(np->entries, entries->entries,

         entries->nentries * sizeof (png_sPLT_entry));

       * count, so an invalid entry is not added.

       */

      info_ptr->valid |= PNG_INFO_sPLT;

      ++(info_ptr->splt_palettes_num);

      ++np;

   }

   while (++entries, --nentries);

      png_chunk_report(png_ptr, "sPLT out of memory", PNG_CHUNK_WRITE_ERROR);

}

#endif /* PNG_sPLT_SUPPORTED */

static png_byte

check_location(png_const_structrp png_ptr, int location)

{

   location &= (PNG_HAVE_IHDR|PNG_HAVE_PLTE|PNG_AFTER_IDAT);

    * change, previously the app had to use the

    * png_set_unknown_chunk_location API below for each chunk.

    */

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

   {

      /* Write struct, so unknown chunks come from the app */

      png_app_warning(png_ptr,

         "png_set_unknown_chunks now expects a valid location");

      /* Use the old behavior */

      location = (png_byte)(png_ptr->mode &

         (PNG_HAVE_IHDR|PNG_HAVE_PLTE|PNG_AFTER_IDAT));

   }

    * png_set_unknown_chunks on a read pointer it must get the location right.

    */

   if (location == 0)

      png_error(png_ptr, "invalid location in png_set_unknown_chunks");

    * significant bit in turn.

    */

   while (location != (location & -location))

      location &= ~(location & -location);

    * bits are significant.

    */

   return (png_byte)location;

}

png_set_unknown_chunks(png_const_structrp png_ptr,

   png_inforp info_ptr, png_const_unknown_chunkp unknowns, int num_unknowns)

{

   png_unknown_chunkp np;

      unknowns == NULL)

      return;

    * time.  This code is hardly ever compiled - it's here because

    * STORE_UNKNOWN_CHUNKS is set by both read and write code (compiling in this

    * code) but may be meaningless if the read or write handling of unknown

    * chunks is not compiled in.

    */

#  if !defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) && \

      defined(PNG_READ_SUPPORTED)

      if (png_ptr->mode & PNG_IS_READ_STRUCT)

      {

         png_app_error(png_ptr, "no unknown chunk support on read");

         return;

      }

#  endif

#  if !defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) && \

      defined(PNG_WRITE_SUPPORTED)