1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/libs/libpng/pngset.c	Thu Sep 08 06:28:38 2011 +0300
     1.3 @@ -0,0 +1,1293 @@
     1.4 +
     1.5 +/* pngset.c - storage of image information into info struct
     1.6 + *
     1.7 + * Last changed in libpng 1.2.30 [August 15, 2008]
     1.8 + * For conditions of distribution and use, see copyright notice in png.h
     1.9 + * Copyright (c) 1998-2008 Glenn Randers-Pehrson
    1.10 + * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
    1.11 + * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
    1.12 + *
    1.13 + * The functions here are used during reads to store data from the file
    1.14 + * into the info struct, and during writes to store application data
    1.15 + * into the info struct for writing into the file.  This abstracts the
    1.16 + * info struct and allows us to change the structure in the future.
    1.17 + */
    1.18 +
    1.19 +#define PNG_INTERNAL
    1.20 +#include "png.h"
    1.21 +#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
    1.22 +
    1.23 +#if defined(PNG_bKGD_SUPPORTED)
    1.24 +void PNGAPI
    1.25 +png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background)
    1.26 +{
    1.27 +   png_debug1(1, "in %s storage function\n", "bKGD");
    1.28 +   if (png_ptr == NULL || info_ptr == NULL)
    1.29 +      return;
    1.30 +
    1.31 +   png_memcpy(&(info_ptr->background), background, png_sizeof(png_color_16));
    1.32 +   info_ptr->valid |= PNG_INFO_bKGD;
    1.33 +}
    1.34 +#endif
    1.35 +
    1.36 +#if defined(PNG_cHRM_SUPPORTED)
    1.37 +#ifdef PNG_FLOATING_POINT_SUPPORTED
    1.38 +void PNGAPI
    1.39 +png_set_cHRM(png_structp png_ptr, png_infop info_ptr,
    1.40 +   double white_x, double white_y, double red_x, double red_y,
    1.41 +   double green_x, double green_y, double blue_x, double blue_y)
    1.42 +{
    1.43 +   png_debug1(1, "in %s storage function\n", "cHRM");
    1.44 +   if (png_ptr == NULL || info_ptr == NULL)
    1.45 +      return;
    1.46 +   if (!(white_x || white_y || red_x || red_y || green_x || green_y ||
    1.47 +       blue_x || blue_y))
    1.48 +   {
    1.49 +      png_warning(png_ptr,
    1.50 +        "Ignoring attempt to set all-zero chromaticity values");
    1.51 +      return;
    1.52 +   }
    1.53 +   if (white_x < 0.0 || white_y < 0.0 ||
    1.54 +         red_x < 0.0 ||   red_y < 0.0 ||
    1.55 +       green_x < 0.0 || green_y < 0.0 ||
    1.56 +        blue_x < 0.0 ||  blue_y < 0.0)
    1.57 +   {
    1.58 +      png_warning(png_ptr,
    1.59 +        "Ignoring attempt to set negative chromaticity value");
    1.60 +      return;
    1.61 +   }
    1.62 +   if (white_x > 21474.83 || white_y > 21474.83 ||
    1.63 +         red_x > 21474.83 ||   red_y > 21474.83 ||
    1.64 +       green_x > 21474.83 || green_y > 21474.83 ||
    1.65 +        blue_x > 21474.83 ||  blue_y > 21474.83)
    1.66 +   {
    1.67 +      png_warning(png_ptr,
    1.68 +        "Ignoring attempt to set chromaticity value exceeding 21474.83");
    1.69 +      return;
    1.70 +   }
    1.71 +
    1.72 +   info_ptr->x_white = (float)white_x;
    1.73 +   info_ptr->y_white = (float)white_y;
    1.74 +   info_ptr->x_red   = (float)red_x;
    1.75 +   info_ptr->y_red   = (float)red_y;
    1.76 +   info_ptr->x_green = (float)green_x;
    1.77 +   info_ptr->y_green = (float)green_y;
    1.78 +   info_ptr->x_blue  = (float)blue_x;
    1.79 +   info_ptr->y_blue  = (float)blue_y;
    1.80 +#ifdef PNG_FIXED_POINT_SUPPORTED
    1.81 +   info_ptr->int_x_white = (png_fixed_point)(white_x*100000.+0.5);
    1.82 +   info_ptr->int_y_white = (png_fixed_point)(white_y*100000.+0.5);
    1.83 +   info_ptr->int_x_red   = (png_fixed_point)(  red_x*100000.+0.5);
    1.84 +   info_ptr->int_y_red   = (png_fixed_point)(  red_y*100000.+0.5);
    1.85 +   info_ptr->int_x_green = (png_fixed_point)(green_x*100000.+0.5);
    1.86 +   info_ptr->int_y_green = (png_fixed_point)(green_y*100000.+0.5);
    1.87 +   info_ptr->int_x_blue  = (png_fixed_point)( blue_x*100000.+0.5);
    1.88 +   info_ptr->int_y_blue  = (png_fixed_point)( blue_y*100000.+0.5);
    1.89 +#endif
    1.90 +   info_ptr->valid |= PNG_INFO_cHRM;
    1.91 +}
    1.92 +#endif
    1.93 +#ifdef PNG_FIXED_POINT_SUPPORTED
    1.94 +void PNGAPI
    1.95 +png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
    1.96 +   png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,
    1.97 +   png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,
    1.98 +   png_fixed_point blue_x, png_fixed_point blue_y)
    1.99 +{
   1.100 +   png_debug1(1, "in %s storage function\n", "cHRM");
   1.101 +   if (png_ptr == NULL || info_ptr == NULL)
   1.102 +      return;
   1.103 +
   1.104 +   if (!(white_x || white_y || red_x || red_y || green_x || green_y ||
   1.105 +       blue_x || blue_y))
   1.106 +   {
   1.107 +      png_warning(png_ptr,
   1.108 +        "Ignoring attempt to set all-zero chromaticity values");
   1.109 +      return;
   1.110 +   }
   1.111 +   if (white_x < 0 || white_y < 0 ||
   1.112 +         red_x < 0 ||   red_y < 0 ||
   1.113 +       green_x < 0 || green_y < 0 ||
   1.114 +        blue_x < 0 ||  blue_y < 0)
   1.115 +   {
   1.116 +      png_warning(png_ptr,
   1.117 +        "Ignoring attempt to set negative chromaticity value");
   1.118 +      return;
   1.119 +   }
   1.120 +   if (white_x > (png_fixed_point) PNG_UINT_31_MAX ||
   1.121 +       white_y > (png_fixed_point) PNG_UINT_31_MAX ||
   1.122 +         red_x > (png_fixed_point) PNG_UINT_31_MAX ||
   1.123 +         red_y > (png_fixed_point) PNG_UINT_31_MAX ||
   1.124 +       green_x > (png_fixed_point) PNG_UINT_31_MAX ||
   1.125 +       green_y > (png_fixed_point) PNG_UINT_31_MAX ||
   1.126 +        blue_x > (png_fixed_point) PNG_UINT_31_MAX ||
   1.127 +        blue_y > (png_fixed_point) PNG_UINT_31_MAX )
   1.128 +   {
   1.129 +      png_warning(png_ptr,
   1.130 +        "Ignoring attempt to set chromaticity value exceeding 21474.83");
   1.131 +      return;
   1.132 +   }
   1.133 +   info_ptr->int_x_white = white_x;
   1.134 +   info_ptr->int_y_white = white_y;
   1.135 +   info_ptr->int_x_red   = red_x;
   1.136 +   info_ptr->int_y_red   = red_y;
   1.137 +   info_ptr->int_x_green = green_x;
   1.138 +   info_ptr->int_y_green = green_y;
   1.139 +   info_ptr->int_x_blue  = blue_x;
   1.140 +   info_ptr->int_y_blue  = blue_y;
   1.141 +#ifdef PNG_FLOATING_POINT_SUPPORTED
   1.142 +   info_ptr->x_white = (float)(white_x/100000.);
   1.143 +   info_ptr->y_white = (float)(white_y/100000.);
   1.144 +   info_ptr->x_red   = (float)(  red_x/100000.);
   1.145 +   info_ptr->y_red   = (float)(  red_y/100000.);
   1.146 +   info_ptr->x_green = (float)(green_x/100000.);
   1.147 +   info_ptr->y_green = (float)(green_y/100000.);
   1.148 +   info_ptr->x_blue  = (float)( blue_x/100000.);
   1.149 +   info_ptr->y_blue  = (float)( blue_y/100000.);
   1.150 +#endif
   1.151 +   info_ptr->valid |= PNG_INFO_cHRM;
   1.152 +}
   1.153 +#endif
   1.154 +#endif
   1.155 +
   1.156 +#if defined(PNG_gAMA_SUPPORTED)
   1.157 +#ifdef PNG_FLOATING_POINT_SUPPORTED
   1.158 +void PNGAPI
   1.159 +png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)
   1.160 +{
   1.161 +   double gamma;
   1.162 +   png_debug1(1, "in %s storage function\n", "gAMA");
   1.163 +   if (png_ptr == NULL || info_ptr == NULL)
   1.164 +      return;
   1.165 +
   1.166 +   /* Check for overflow */
   1.167 +   if (file_gamma > 21474.83)
   1.168 +   {
   1.169 +      png_warning(png_ptr, "Limiting gamma to 21474.83");
   1.170 +      gamma=21474.83;
   1.171 +   }
   1.172 +   else
   1.173 +      gamma = file_gamma;
   1.174 +   info_ptr->gamma = (float)gamma;
   1.175 +#ifdef PNG_FIXED_POINT_SUPPORTED
   1.176 +   info_ptr->int_gamma = (int)(gamma*100000.+.5);
   1.177 +#endif
   1.178 +   info_ptr->valid |= PNG_INFO_gAMA;
   1.179 +   if (gamma == 0.0)
   1.180 +      png_warning(png_ptr, "Setting gamma=0");
   1.181 +}
   1.182 +#endif
   1.183 +void PNGAPI
   1.184 +png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point
   1.185 +   int_gamma)
   1.186 +{
   1.187 +   png_fixed_point gamma;
   1.188 +
   1.189 +   png_debug1(1, "in %s storage function\n", "gAMA");
   1.190 +   if (png_ptr == NULL || info_ptr == NULL)
   1.191 +      return;
   1.192 +
   1.193 +   if (int_gamma > (png_fixed_point) PNG_UINT_31_MAX)
   1.194 +   {
   1.195 +     png_warning(png_ptr, "Limiting gamma to 21474.83");
   1.196 +     gamma=PNG_UINT_31_MAX;
   1.197 +   }
   1.198 +   else
   1.199 +   {
   1.200 +     if (int_gamma < 0)
   1.201 +     {
   1.202 +       png_warning(png_ptr, "Setting negative gamma to zero");
   1.203 +       gamma = 0;
   1.204 +     }
   1.205 +     else
   1.206 +       gamma = int_gamma;
   1.207 +   }
   1.208 +#ifdef PNG_FLOATING_POINT_SUPPORTED
   1.209 +   info_ptr->gamma = (float)(gamma/100000.);
   1.210 +#endif
   1.211 +#ifdef PNG_FIXED_POINT_SUPPORTED
   1.212 +   info_ptr->int_gamma = gamma;
   1.213 +#endif
   1.214 +   info_ptr->valid |= PNG_INFO_gAMA;
   1.215 +   if (gamma == 0)
   1.216 +      png_warning(png_ptr, "Setting gamma=0");
   1.217 +}
   1.218 +#endif
   1.219 +
   1.220 +#if defined(PNG_hIST_SUPPORTED)
   1.221 +void PNGAPI
   1.222 +png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)
   1.223 +{
   1.224 +   int i;
   1.225 +
   1.226 +   png_debug1(1, "in %s storage function\n", "hIST");
   1.227 +   if (png_ptr == NULL || info_ptr == NULL)
   1.228 +      return;
   1.229 +   if (info_ptr->num_palette == 0 || info_ptr->num_palette
   1.230 +       > PNG_MAX_PALETTE_LENGTH)
   1.231 +   {
   1.232 +       png_warning(png_ptr,
   1.233 +          "Invalid palette size, hIST allocation skipped.");
   1.234 +       return;
   1.235 +   }
   1.236 +
   1.237 +#ifdef PNG_FREE_ME_SUPPORTED
   1.238 +   png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0);
   1.239 +#endif
   1.240 +   /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in version
   1.241 +      1.2.1 */
   1.242 +   png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr,
   1.243 +      (png_uint_32)(PNG_MAX_PALETTE_LENGTH * png_sizeof(png_uint_16)));
   1.244 +   if (png_ptr->hist == NULL)
   1.245 +     {
   1.246 +       png_warning(png_ptr, "Insufficient memory for hIST chunk data.");
   1.247 +       return;
   1.248 +     }
   1.249 +
   1.250 +   for (i = 0; i < info_ptr->num_palette; i++)
   1.251 +       png_ptr->hist[i] = hist[i];
   1.252 +   info_ptr->hist = png_ptr->hist;
   1.253 +   info_ptr->valid |= PNG_INFO_hIST;
   1.254 +
   1.255 +#ifdef PNG_FREE_ME_SUPPORTED
   1.256 +   info_ptr->free_me |= PNG_FREE_HIST;
   1.257 +#else
   1.258 +   png_ptr->flags |= PNG_FLAG_FREE_HIST;
   1.259 +#endif
   1.260 +}
   1.261 +#endif
   1.262 +
   1.263 +void PNGAPI
   1.264 +png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
   1.265 +   png_uint_32 width, png_uint_32 height, int bit_depth,
   1.266 +   int color_type, int interlace_type, int compression_type,
   1.267 +   int filter_type)
   1.268 +{
   1.269 +   png_debug1(1, "in %s storage function\n", "IHDR");
   1.270 +   if (png_ptr == NULL || info_ptr == NULL)
   1.271 +      return;
   1.272 +
   1.273 +   /* check for width and height valid values */
   1.274 +   if (width == 0 || height == 0)
   1.275 +      png_error(png_ptr, "Image width or height is zero in IHDR");
   1.276 +#ifdef PNG_SET_USER_LIMITS_SUPPORTED
   1.277 +   if (width > png_ptr->user_width_max || height > png_ptr->user_height_max)
   1.278 +      png_error(png_ptr, "image size exceeds user limits in IHDR");
   1.279 +#else
   1.280 +   if (width > PNG_USER_WIDTH_MAX || height > PNG_USER_HEIGHT_MAX)
   1.281 +      png_error(png_ptr, "image size exceeds user limits in IHDR");
   1.282 +#endif
   1.283 +   if (width > PNG_UINT_31_MAX || height > PNG_UINT_31_MAX)
   1.284 +      png_error(png_ptr, "Invalid image size in IHDR");
   1.285 +   if ( width > (PNG_UINT_32_MAX
   1.286 +                 >> 3)      /* 8-byte RGBA pixels */
   1.287 +                 - 64       /* bigrowbuf hack */
   1.288 +                 - 1        /* filter byte */
   1.289 +                 - 7*8      /* rounding of width to multiple of 8 pixels */
   1.290 +                 - 8)       /* extra max_pixel_depth pad */
   1.291 +      png_warning(png_ptr, "Width is too large for libpng to process pixels");
   1.292 +
   1.293 +   /* check other values */
   1.294 +   if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&
   1.295 +      bit_depth != 8 && bit_depth != 16)
   1.296 +      png_error(png_ptr, "Invalid bit depth in IHDR");
   1.297 +
   1.298 +   if (color_type < 0 || color_type == 1 ||
   1.299 +      color_type == 5 || color_type > 6)
   1.300 +      png_error(png_ptr, "Invalid color type in IHDR");
   1.301 +
   1.302 +   if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||
   1.303 +       ((color_type == PNG_COLOR_TYPE_RGB ||
   1.304 +         color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
   1.305 +         color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))
   1.306 +      png_error(png_ptr, "Invalid color type/bit depth combination in IHDR");
   1.307 +
   1.308 +   if (interlace_type >= PNG_INTERLACE_LAST)
   1.309 +      png_error(png_ptr, "Unknown interlace method in IHDR");
   1.310 +
   1.311 +   if (compression_type != PNG_COMPRESSION_TYPE_BASE)
   1.312 +      png_error(png_ptr, "Unknown compression method in IHDR");
   1.313 +
   1.314 +#if defined(PNG_MNG_FEATURES_SUPPORTED)
   1.315 +   /* Accept filter_method 64 (intrapixel differencing) only if
   1.316 +    * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
   1.317 +    * 2. Libpng did not read a PNG signature (this filter_method is only
   1.318 +    *    used in PNG datastreams that are embedded in MNG datastreams) and
   1.319 +    * 3. The application called png_permit_mng_features with a mask that
   1.320 +    *    included PNG_FLAG_MNG_FILTER_64 and
   1.321 +    * 4. The filter_method is 64 and
   1.322 +    * 5. The color_type is RGB or RGBA
   1.323 +    */
   1.324 +   if ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&png_ptr->mng_features_permitted)
   1.325 +      png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");
   1.326 +   if (filter_type != PNG_FILTER_TYPE_BASE)
   1.327 +   {
   1.328 +     if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
   1.329 +        (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&
   1.330 +        ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&
   1.331 +        (color_type == PNG_COLOR_TYPE_RGB ||
   1.332 +         color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
   1.333 +        png_error(png_ptr, "Unknown filter method in IHDR");
   1.334 +     if (png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)
   1.335 +        png_warning(png_ptr, "Invalid filter method in IHDR");
   1.336 +   }
   1.337 +#else
   1.338 +   if (filter_type != PNG_FILTER_TYPE_BASE)
   1.339 +      png_error(png_ptr, "Unknown filter method in IHDR");
   1.340 +#endif
   1.341 +
   1.342 +   info_ptr->width = width;
   1.343 +   info_ptr->height = height;
   1.344 +   info_ptr->bit_depth = (png_byte)bit_depth;
   1.345 +   info_ptr->color_type =(png_byte) color_type;
   1.346 +   info_ptr->compression_type = (png_byte)compression_type;
   1.347 +   info_ptr->filter_type = (png_byte)filter_type;
   1.348 +   info_ptr->interlace_type = (png_byte)interlace_type;
   1.349 +   if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
   1.350 +      info_ptr->channels = 1;
   1.351 +   else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
   1.352 +      info_ptr->channels = 3;
   1.353 +   else
   1.354 +      info_ptr->channels = 1;
   1.355 +   if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
   1.356 +      info_ptr->channels++;
   1.357 +   info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);
   1.358 +
   1.359 +   /* check for potential overflow */
   1.360 +   if (width > (PNG_UINT_32_MAX
   1.361 +                 >> 3)      /* 8-byte RGBA pixels */
   1.362 +                 - 64       /* bigrowbuf hack */
   1.363 +                 - 1        /* filter byte */
   1.364 +                 - 7*8      /* rounding of width to multiple of 8 pixels */
   1.365 +                 - 8)       /* extra max_pixel_depth pad */
   1.366 +      info_ptr->rowbytes = (png_size_t)0;
   1.367 +   else
   1.368 +      info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, width);
   1.369 +}
   1.370 +
   1.371 +#if defined(PNG_oFFs_SUPPORTED)
   1.372 +void PNGAPI
   1.373 +png_set_oFFs(png_structp png_ptr, png_infop info_ptr,
   1.374 +   png_int_32 offset_x, png_int_32 offset_y, int unit_type)
   1.375 +{
   1.376 +   png_debug1(1, "in %s storage function\n", "oFFs");
   1.377 +   if (png_ptr == NULL || info_ptr == NULL)
   1.378 +      return;
   1.379 +
   1.380 +   info_ptr->x_offset = offset_x;
   1.381 +   info_ptr->y_offset = offset_y;
   1.382 +   info_ptr->offset_unit_type = (png_byte)unit_type;
   1.383 +   info_ptr->valid |= PNG_INFO_oFFs;
   1.384 +}
   1.385 +#endif
   1.386 +
   1.387 +#if defined(PNG_pCAL_SUPPORTED)
   1.388 +void PNGAPI
   1.389 +png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
   1.390 +   png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,
   1.391 +   png_charp units, png_charpp params)
   1.392 +{
   1.393 +   png_uint_32 length;
   1.394 +   int i;
   1.395 +
   1.396 +   png_debug1(1, "in %s storage function\n", "pCAL");
   1.397 +   if (png_ptr == NULL || info_ptr == NULL)
   1.398 +      return;
   1.399 +
   1.400 +   length = png_strlen(purpose) + 1;
   1.401 +   png_debug1(3, "allocating purpose for info (%lu bytes)\n",
   1.402 +     (unsigned long)length);
   1.403 +   info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length);
   1.404 +   if (info_ptr->pcal_purpose == NULL)
   1.405 +   {
   1.406 +       png_warning(png_ptr, "Insufficient memory for pCAL purpose.");
   1.407 +      return;
   1.408 +   }
   1.409 +   png_memcpy(info_ptr->pcal_purpose, purpose, (png_size_t)length);
   1.410 +
   1.411 +   png_debug(3, "storing X0, X1, type, and nparams in info\n");
   1.412 +   info_ptr->pcal_X0 = X0;
   1.413 +   info_ptr->pcal_X1 = X1;
   1.414 +   info_ptr->pcal_type = (png_byte)type;
   1.415 +   info_ptr->pcal_nparams = (png_byte)nparams;
   1.416 +
   1.417 +   length = png_strlen(units) + 1;
   1.418 +   png_debug1(3, "allocating units for info (%lu bytes)\n",
   1.419 +     (unsigned long)length);
   1.420 +   info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length);
   1.421 +   if (info_ptr->pcal_units == NULL)
   1.422 +   {
   1.423 +       png_warning(png_ptr, "Insufficient memory for pCAL units.");
   1.424 +      return;
   1.425 +   }
   1.426 +   png_memcpy(info_ptr->pcal_units, units, (png_size_t)length);
   1.427 +
   1.428 +   info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr,
   1.429 +      (png_uint_32)((nparams + 1) * png_sizeof(png_charp)));
   1.430 +   if (info_ptr->pcal_params == NULL)
   1.431 +   {
   1.432 +       png_warning(png_ptr, "Insufficient memory for pCAL params.");
   1.433 +      return;
   1.434 +   }
   1.435 +
   1.436 +   info_ptr->pcal_params[nparams] = NULL;
   1.437 +
   1.438 +   for (i = 0; i < nparams; i++)
   1.439 +   {
   1.440 +      length = png_strlen(params[i]) + 1;
   1.441 +      png_debug2(3, "allocating parameter %d for info (%lu bytes)\n", i,
   1.442 +        (unsigned long)length);
   1.443 +      info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length);
   1.444 +      if (info_ptr->pcal_params[i] == NULL)
   1.445 +      {
   1.446 +          png_warning(png_ptr, "Insufficient memory for pCAL parameter.");
   1.447 +          return;
   1.448 +      }
   1.449 +      png_memcpy(info_ptr->pcal_params[i], params[i], (png_size_t)length);
   1.450 +   }
   1.451 +
   1.452 +   info_ptr->valid |= PNG_INFO_pCAL;
   1.453 +#ifdef PNG_FREE_ME_SUPPORTED
   1.454 +   info_ptr->free_me |= PNG_FREE_PCAL;
   1.455 +#endif
   1.456 +}
   1.457 +#endif
   1.458 +
   1.459 +#if defined(PNG_READ_sCAL_SUPPORTED) || defined(PNG_WRITE_sCAL_SUPPORTED)
   1.460 +#ifdef PNG_FLOATING_POINT_SUPPORTED
   1.461 +void PNGAPI
   1.462 +png_set_sCAL(png_structp png_ptr, png_infop info_ptr,
   1.463 +             int unit, double width, double height)
   1.464 +{
   1.465 +   png_debug1(1, "in %s storage function\n", "sCAL");
   1.466 +   if (png_ptr == NULL || info_ptr == NULL)
   1.467 +      return;
   1.468 +
   1.469 +   info_ptr->scal_unit = (png_byte)unit;
   1.470 +   info_ptr->scal_pixel_width = width;
   1.471 +   info_ptr->scal_pixel_height = height;
   1.472 +
   1.473 +   info_ptr->valid |= PNG_INFO_sCAL;
   1.474 +}
   1.475 +#else
   1.476 +#ifdef PNG_FIXED_POINT_SUPPORTED
   1.477 +void PNGAPI
   1.478 +png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,
   1.479 +             int unit, png_charp swidth, png_charp sheight)
   1.480 +{
   1.481 +   png_uint_32 length;
   1.482 +
   1.483 +   png_debug1(1, "in %s storage function\n", "sCAL");
   1.484 +   if (png_ptr == NULL || info_ptr == NULL)
   1.485 +      return;
   1.486 +
   1.487 +   info_ptr->scal_unit = (png_byte)unit;
   1.488 +
   1.489 +   length = png_strlen(swidth) + 1;
   1.490 +   png_debug1(3, "allocating unit for info (%u bytes)\n",
   1.491 +      (unsigned int)length);
   1.492 +   info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, length);
   1.493 +   if (info_ptr->scal_s_width == NULL)
   1.494 +   {
   1.495 +      png_warning(png_ptr,
   1.496 +       "Memory allocation failed while processing sCAL.");
   1.497 +      return;
   1.498 +   }
   1.499 +   png_memcpy(info_ptr->scal_s_width, swidth, (png_size_t)length);
   1.500 +
   1.501 +   length = png_strlen(sheight) + 1;
   1.502 +   png_debug1(3, "allocating unit for info (%u bytes)\n",
   1.503 +      (unsigned int)length);
   1.504 +   info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, length);
   1.505 +   if (info_ptr->scal_s_height == NULL)
   1.506 +   {
   1.507 +      png_free (png_ptr, info_ptr->scal_s_width);
   1.508 +      info_ptr->scal_s_width = NULL;
   1.509 +      png_warning(png_ptr,
   1.510 +       "Memory allocation failed while processing sCAL.");
   1.511 +      return;
   1.512 +   }
   1.513 +   png_memcpy(info_ptr->scal_s_height, sheight, (png_size_t)length);
   1.514 +   info_ptr->valid |= PNG_INFO_sCAL;
   1.515 +#ifdef PNG_FREE_ME_SUPPORTED
   1.516 +   info_ptr->free_me |= PNG_FREE_SCAL;
   1.517 +#endif
   1.518 +}
   1.519 +#endif
   1.520 +#endif
   1.521 +#endif
   1.522 +
   1.523 +#if defined(PNG_pHYs_SUPPORTED)
   1.524 +void PNGAPI
   1.525 +png_set_pHYs(png_structp png_ptr, png_infop info_ptr,
   1.526 +   png_uint_32 res_x, png_uint_32 res_y, int unit_type)
   1.527 +{
   1.528 +   png_debug1(1, "in %s storage function\n", "pHYs");
   1.529 +   if (png_ptr == NULL || info_ptr == NULL)
   1.530 +      return;
   1.531 +
   1.532 +   info_ptr->x_pixels_per_unit = res_x;
   1.533 +   info_ptr->y_pixels_per_unit = res_y;
   1.534 +   info_ptr->phys_unit_type = (png_byte)unit_type;
   1.535 +   info_ptr->valid |= PNG_INFO_pHYs;
   1.536 +}
   1.537 +#endif
   1.538 +
   1.539 +void PNGAPI
   1.540 +png_set_PLTE(png_structp png_ptr, png_infop info_ptr,
   1.541 +   png_colorp palette, int num_palette)
   1.542 +{
   1.543 +
   1.544 +   png_debug1(1, "in %s storage function\n", "PLTE");
   1.545 +   if (png_ptr == NULL || info_ptr == NULL)
   1.546 +      return;
   1.547 +
   1.548 +   if (num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH)
   1.549 +     {
   1.550 +       if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
   1.551 +         png_error(png_ptr, "Invalid palette length");
   1.552 +       else
   1.553 +       {
   1.554 +         png_warning(png_ptr, "Invalid palette length");
   1.555 +         return;
   1.556 +       }
   1.557 +     }
   1.558 +
   1.559 +   /*
   1.560 +    * It may not actually be necessary to set png_ptr->palette here;
   1.561 +    * we do it for backward compatibility with the way the png_handle_tRNS
   1.562 +    * function used to do the allocation.
   1.563 +    */
   1.564 +#ifdef PNG_FREE_ME_SUPPORTED
   1.565 +   png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0);
   1.566 +#endif
   1.567 +
   1.568 +   /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead
   1.569 +      of num_palette entries,
   1.570 +      in case of an invalid PNG file that has too-large sample values. */
   1.571 +   png_ptr->palette = (png_colorp)png_malloc(png_ptr,
   1.572 +      PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color));
   1.573 +   png_memset(png_ptr->palette, 0, PNG_MAX_PALETTE_LENGTH *
   1.574 +      png_sizeof(png_color));
   1.575 +   png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof(png_color));
   1.576 +   info_ptr->palette = png_ptr->palette;
   1.577 +   info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;
   1.578 +
   1.579 +#ifdef PNG_FREE_ME_SUPPORTED
   1.580 +   info_ptr->free_me |= PNG_FREE_PLTE;
   1.581 +#else
   1.582 +   png_ptr->flags |= PNG_FLAG_FREE_PLTE;
   1.583 +#endif
   1.584 +
   1.585 +   info_ptr->valid |= PNG_INFO_PLTE;
   1.586 +}
   1.587 +
   1.588 +#if defined(PNG_sBIT_SUPPORTED)
   1.589 +void PNGAPI
   1.590 +png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
   1.591 +   png_color_8p sig_bit)
   1.592 +{
   1.593 +   png_debug1(1, "in %s storage function\n", "sBIT");
   1.594 +   if (png_ptr == NULL || info_ptr == NULL)
   1.595 +      return;
   1.596 +
   1.597 +   png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof(png_color_8));
   1.598 +   info_ptr->valid |= PNG_INFO_sBIT;
   1.599 +}
   1.600 +#endif
   1.601 +
   1.602 +#if defined(PNG_sRGB_SUPPORTED)
   1.603 +void PNGAPI
   1.604 +png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent)
   1.605 +{
   1.606 +   png_debug1(1, "in %s storage function\n", "sRGB");
   1.607 +   if (png_ptr == NULL || info_ptr == NULL)
   1.608 +      return;
   1.609 +
   1.610 +   info_ptr->srgb_intent = (png_byte)intent;
   1.611 +   info_ptr->valid |= PNG_INFO_sRGB;
   1.612 +}
   1.613 +
   1.614 +void PNGAPI
   1.615 +png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
   1.616 +   int intent)
   1.617 +{
   1.618 +#if defined(PNG_gAMA_SUPPORTED)
   1.619 +#ifdef PNG_FLOATING_POINT_SUPPORTED
   1.620 +   float file_gamma;
   1.621 +#endif
   1.622 +#ifdef PNG_FIXED_POINT_SUPPORTED
   1.623 +   png_fixed_point int_file_gamma;
   1.624 +#endif
   1.625 +#endif
   1.626 +#if defined(PNG_cHRM_SUPPORTED)
   1.627 +#ifdef PNG_FLOATING_POINT_SUPPORTED
   1.628 +   float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
   1.629 +#endif
   1.630 +#ifdef PNG_FIXED_POINT_SUPPORTED
   1.631 +   png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
   1.632 +      int_green_y, int_blue_x, int_blue_y;
   1.633 +#endif
   1.634 +#endif
   1.635 +   png_debug1(1, "in %s storage function\n", "sRGB_gAMA_and_cHRM");
   1.636 +   if (png_ptr == NULL || info_ptr == NULL)
   1.637 +      return;
   1.638 +
   1.639 +   png_set_sRGB(png_ptr, info_ptr, intent);
   1.640 +
   1.641 +#if defined(PNG_gAMA_SUPPORTED)
   1.642 +#ifdef PNG_FLOATING_POINT_SUPPORTED
   1.643 +   file_gamma = (float).45455;
   1.644 +   png_set_gAMA(png_ptr, info_ptr, file_gamma);
   1.645 +#endif
   1.646 +#ifdef PNG_FIXED_POINT_SUPPORTED
   1.647 +   int_file_gamma = 45455L;
   1.648 +   png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma);
   1.649 +#endif
   1.650 +#endif
   1.651 +
   1.652 +#if defined(PNG_cHRM_SUPPORTED)
   1.653 +#ifdef PNG_FIXED_POINT_SUPPORTED
   1.654 +   int_white_x = 31270L;
   1.655 +   int_white_y = 32900L;
   1.656 +   int_red_x   = 64000L;
   1.657 +   int_red_y   = 33000L;
   1.658 +   int_green_x = 30000L;
   1.659 +   int_green_y = 60000L;
   1.660 +   int_blue_x  = 15000L;
   1.661 +   int_blue_y  =  6000L;
   1.662 +
   1.663 +   png_set_cHRM_fixed(png_ptr, info_ptr,
   1.664 +      int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, int_green_y,
   1.665 +      int_blue_x, int_blue_y);
   1.666 +#endif
   1.667 +#ifdef PNG_FLOATING_POINT_SUPPORTED
   1.668 +   white_x = (float).3127;
   1.669 +   white_y = (float).3290;
   1.670 +   red_x   = (float).64;
   1.671 +   red_y   = (float).33;
   1.672 +   green_x = (float).30;
   1.673 +   green_y = (float).60;
   1.674 +   blue_x  = (float).15;
   1.675 +   blue_y  = (float).06;
   1.676 +
   1.677 +   png_set_cHRM(png_ptr, info_ptr,
   1.678 +      white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
   1.679 +#endif
   1.680 +#endif
   1.681 +}
   1.682 +#endif
   1.683 +
   1.684 +
   1.685 +#if defined(PNG_iCCP_SUPPORTED)
   1.686 +void PNGAPI
   1.687 +png_set_iCCP(png_structp png_ptr, png_infop info_ptr,
   1.688 +             png_charp name, int compression_type,
   1.689 +             png_charp profile, png_uint_32 proflen)
   1.690 +{
   1.691 +   png_charp new_iccp_name;
   1.692 +   png_charp new_iccp_profile;
   1.693 +   png_uint_32 length;
   1.694 +
   1.695 +   png_debug1(1, "in %s storage function\n", "iCCP");
   1.696 +   if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)
   1.697 +      return;
   1.698 +
   1.699 +   length = png_strlen(name)+1;
   1.700 +   new_iccp_name = (png_charp)png_malloc_warn(png_ptr, length);
   1.701 +   if (new_iccp_name == NULL)
   1.702 +   {
   1.703 +      png_warning(png_ptr, "Insufficient memory to process iCCP chunk.");
   1.704 +      return;
   1.705 +   }
   1.706 +   png_memcpy(new_iccp_name, name, length);
   1.707 +   new_iccp_profile = (png_charp)png_malloc_warn(png_ptr, proflen);
   1.708 +   if (new_iccp_profile == NULL)
   1.709 +   {
   1.710 +      png_free (png_ptr, new_iccp_name);
   1.711 +      png_warning(png_ptr,
   1.712 +      "Insufficient memory to process iCCP profile.");
   1.713 +      return;
   1.714 +   }
   1.715 +   png_memcpy(new_iccp_profile, profile, (png_size_t)proflen);
   1.716 +
   1.717 +   png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0);
   1.718 +
   1.719 +   info_ptr->iccp_proflen = proflen;
   1.720 +   info_ptr->iccp_name = new_iccp_name;
   1.721 +   info_ptr->iccp_profile = new_iccp_profile;
   1.722 +   /* Compression is always zero but is here so the API and info structure
   1.723 +    * does not have to change if we introduce multiple compression types */
   1.724 +   info_ptr->iccp_compression = (png_byte)compression_type;
   1.725 +#ifdef PNG_FREE_ME_SUPPORTED
   1.726 +   info_ptr->free_me |= PNG_FREE_ICCP;
   1.727 +#endif
   1.728 +   info_ptr->valid |= PNG_INFO_iCCP;
   1.729 +}
   1.730 +#endif
   1.731 +
   1.732 +#if defined(PNG_TEXT_SUPPORTED)
   1.733 +void PNGAPI
   1.734 +png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
   1.735 +   int num_text)
   1.736 +{
   1.737 +   int ret;
   1.738 +   ret = png_set_text_2(png_ptr, info_ptr, text_ptr, num_text);
   1.739 +   if (ret)
   1.740 +     png_error(png_ptr, "Insufficient memory to store text");
   1.741 +}
   1.742 +
   1.743 +int /* PRIVATE */
   1.744 +png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
   1.745 +   int num_text)
   1.746 +{
   1.747 +   int i;
   1.748 +
   1.749 +   png_debug1(1, "in %s storage function\n", (png_ptr->chunk_name[0] == '\0' ?
   1.750 +      "text" : (png_const_charp)png_ptr->chunk_name));
   1.751 +
   1.752 +   if (png_ptr == NULL || info_ptr == NULL || num_text == 0)
   1.753 +      return(0);
   1.754 +
   1.755 +   /* Make sure we have enough space in the "text" array in info_struct
   1.756 +    * to hold all of the incoming text_ptr objects.
   1.757 +    */
   1.758 +   if (info_ptr->num_text + num_text > info_ptr->max_text)
   1.759 +   {
   1.760 +      if (info_ptr->text != NULL)
   1.761 +      {
   1.762 +         png_textp old_text;
   1.763 +         int old_max;
   1.764 +
   1.765 +         old_max = info_ptr->max_text;
   1.766 +         info_ptr->max_text = info_ptr->num_text + num_text + 8;
   1.767 +         old_text = info_ptr->text;
   1.768 +         info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
   1.769 +            (png_uint_32)(info_ptr->max_text * png_sizeof(png_text)));
   1.770 +         if (info_ptr->text == NULL)
   1.771 +           {
   1.772 +             png_free(png_ptr, old_text);
   1.773 +             return(1);
   1.774 +           }
   1.775 +         png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max *
   1.776 +            png_sizeof(png_text)));
   1.777 +         png_free(png_ptr, old_text);
   1.778 +      }
   1.779 +      else
   1.780 +      {
   1.781 +         info_ptr->max_text = num_text + 8;
   1.782 +         info_ptr->num_text = 0;
   1.783 +         info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
   1.784 +            (png_uint_32)(info_ptr->max_text * png_sizeof(png_text)));
   1.785 +         if (info_ptr->text == NULL)
   1.786 +           return(1);
   1.787 +#ifdef PNG_FREE_ME_SUPPORTED
   1.788 +         info_ptr->free_me |= PNG_FREE_TEXT;
   1.789 +#endif
   1.790 +      }
   1.791 +      png_debug1(3, "allocated %d entries for info_ptr->text\n",
   1.792 +         info_ptr->max_text);
   1.793 +   }
   1.794 +   for (i = 0; i < num_text; i++)
   1.795 +   {
   1.796 +      png_size_t text_length, key_len;
   1.797 +      png_size_t lang_len, lang_key_len;
   1.798 +      png_textp textp = &(info_ptr->text[info_ptr->num_text]);
   1.799 +
   1.800 +      if (text_ptr[i].key == NULL)
   1.801 +          continue;
   1.802 +
   1.803 +      key_len = png_strlen(text_ptr[i].key);
   1.804 +
   1.805 +      if (text_ptr[i].compression <= 0)
   1.806 +      {
   1.807 +        lang_len = 0;
   1.808 +        lang_key_len = 0;
   1.809 +      }
   1.810 +      else
   1.811 +#ifdef PNG_iTXt_SUPPORTED
   1.812 +      {
   1.813 +        /* set iTXt data */
   1.814 +        if (text_ptr[i].lang != NULL)
   1.815 +          lang_len = png_strlen(text_ptr[i].lang);
   1.816 +        else
   1.817 +          lang_len = 0;
   1.818 +        if (text_ptr[i].lang_key != NULL)
   1.819 +          lang_key_len = png_strlen(text_ptr[i].lang_key);
   1.820 +        else
   1.821 +          lang_key_len = 0;
   1.822 +      }
   1.823 +#else
   1.824 +      {
   1.825 +        png_warning(png_ptr, "iTXt chunk not supported.");
   1.826 +        continue;
   1.827 +      }
   1.828 +#endif
   1.829 +
   1.830 +      if (text_ptr[i].text == NULL || text_ptr[i].text[0] == '\0')
   1.831 +      {
   1.832 +         text_length = 0;
   1.833 +#ifdef PNG_iTXt_SUPPORTED
   1.834 +         if (text_ptr[i].compression > 0)
   1.835 +            textp->compression = PNG_ITXT_COMPRESSION_NONE;
   1.836 +         else
   1.837 +#endif
   1.838 +            textp->compression = PNG_TEXT_COMPRESSION_NONE;
   1.839 +      }
   1.840 +      else
   1.841 +      {
   1.842 +         text_length = png_strlen(text_ptr[i].text);
   1.843 +         textp->compression = text_ptr[i].compression;
   1.844 +      }
   1.845 +
   1.846 +      textp->key = (png_charp)png_malloc_warn(png_ptr,
   1.847 +         (png_uint_32)
   1.848 +         (key_len + text_length + lang_len + lang_key_len + 4));
   1.849 +      if (textp->key == NULL)
   1.850 +        return(1);
   1.851 +      png_debug2(2, "Allocated %lu bytes at %x in png_set_text\n",
   1.852 +         (png_uint_32)
   1.853 +         (key_len + lang_len + lang_key_len + text_length + 4),
   1.854 +         (int)textp->key);
   1.855 +
   1.856 +      png_memcpy(textp->key, text_ptr[i].key,
   1.857 +         (png_size_t)(key_len));
   1.858 +      *(textp->key + key_len) = '\0';
   1.859 +#ifdef PNG_iTXt_SUPPORTED
   1.860 +      if (text_ptr[i].compression > 0)
   1.861 +      {
   1.862 +         textp->lang = textp->key + key_len + 1;
   1.863 +         png_memcpy(textp->lang, text_ptr[i].lang, lang_len);
   1.864 +         *(textp->lang + lang_len) = '\0';
   1.865 +         textp->lang_key = textp->lang + lang_len + 1;
   1.866 +         png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len);
   1.867 +         *(textp->lang_key + lang_key_len) = '\0';
   1.868 +         textp->text = textp->lang_key + lang_key_len + 1;
   1.869 +      }
   1.870 +      else
   1.871 +#endif
   1.872 +      {
   1.873 +#ifdef PNG_iTXt_SUPPORTED
   1.874 +         textp->lang=NULL;
   1.875 +         textp->lang_key=NULL;
   1.876 +#endif
   1.877 +         textp->text = textp->key + key_len + 1;
   1.878 +      }
   1.879 +      if (text_length)
   1.880 +         png_memcpy(textp->text, text_ptr[i].text,
   1.881 +            (png_size_t)(text_length));
   1.882 +      *(textp->text + text_length) = '\0';
   1.883 +
   1.884 +#ifdef PNG_iTXt_SUPPORTED
   1.885 +      if (textp->compression > 0)
   1.886 +      {
   1.887 +         textp->text_length = 0;
   1.888 +         textp->itxt_length = text_length;
   1.889 +      }
   1.890 +      else
   1.891 +#endif
   1.892 +      {
   1.893 +         textp->text_length = text_length;
   1.894 +#ifdef PNG_iTXt_SUPPORTED
   1.895 +         textp->itxt_length = 0;
   1.896 +#endif
   1.897 +      }
   1.898 +      info_ptr->num_text++;
   1.899 +      png_debug1(3, "transferred text chunk %d\n", info_ptr->num_text);
   1.900 +   }
   1.901 +   return(0);
   1.902 +}
   1.903 +#endif
   1.904 +
   1.905 +#if defined(PNG_tIME_SUPPORTED)
   1.906 +void PNGAPI
   1.907 +png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time)
   1.908 +{
   1.909 +   png_debug1(1, "in %s storage function\n", "tIME");
   1.910 +   if (png_ptr == NULL || info_ptr == NULL ||
   1.911 +       (png_ptr->mode & PNG_WROTE_tIME))
   1.912 +      return;
   1.913 +
   1.914 +   png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof(png_time));
   1.915 +   info_ptr->valid |= PNG_INFO_tIME;
   1.916 +}
   1.917 +#endif
   1.918 +
   1.919 +#if defined(PNG_tRNS_SUPPORTED)
   1.920 +void PNGAPI
   1.921 +png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
   1.922 +   png_bytep trans, int num_trans, png_color_16p trans_values)
   1.923 +{
   1.924 +   png_debug1(1, "in %s storage function\n", "tRNS");
   1.925 +   if (png_ptr == NULL || info_ptr == NULL)
   1.926 +      return;
   1.927 +
   1.928 +   if (trans != NULL)
   1.929 +   {
   1.930 +       /*
   1.931 +        * It may not actually be necessary to set png_ptr->trans here;
   1.932 +        * we do it for backward compatibility with the way the png_handle_tRNS
   1.933 +        * function used to do the allocation.
   1.934 +        */
   1.935 +
   1.936 +#ifdef PNG_FREE_ME_SUPPORTED
   1.937 +       png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);
   1.938 +#endif
   1.939 +
   1.940 +       /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */
   1.941 +       png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr,
   1.942 +           (png_uint_32)PNG_MAX_PALETTE_LENGTH);
   1.943 +       if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH)
   1.944 +         png_memcpy(info_ptr->trans, trans, (png_size_t)num_trans);
   1.945 +   }
   1.946 +
   1.947 +   if (trans_values != NULL)
   1.948 +   {
   1.949 +      int sample_max = (1 << info_ptr->bit_depth);
   1.950 +      if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&
   1.951 +          (int)trans_values->gray > sample_max) ||
   1.952 +          (info_ptr->color_type == PNG_COLOR_TYPE_RGB &&
   1.953 +          ((int)trans_values->red > sample_max ||
   1.954 +          (int)trans_values->green > sample_max ||
   1.955 +          (int)trans_values->blue > sample_max)))
   1.956 +        png_warning(png_ptr,
   1.957 +           "tRNS chunk has out-of-range samples for bit_depth");
   1.958 +      png_memcpy(&(info_ptr->trans_values), trans_values,
   1.959 +         png_sizeof(png_color_16));
   1.960 +      if (num_trans == 0)
   1.961 +        num_trans = 1;
   1.962 +   }
   1.963 +
   1.964 +   info_ptr->num_trans = (png_uint_16)num_trans;
   1.965 +   if (num_trans != 0)
   1.966 +   {
   1.967 +      info_ptr->valid |= PNG_INFO_tRNS;
   1.968 +#ifdef PNG_FREE_ME_SUPPORTED
   1.969 +      info_ptr->free_me |= PNG_FREE_TRNS;
   1.970 +#else
   1.971 +      png_ptr->flags |= PNG_FLAG_FREE_TRNS;
   1.972 +#endif
   1.973 +   }
   1.974 +}
   1.975 +#endif
   1.976 +
   1.977 +#if defined(PNG_sPLT_SUPPORTED)
   1.978 +void PNGAPI
   1.979 +png_set_sPLT(png_structp png_ptr,
   1.980 +             png_infop info_ptr, png_sPLT_tp entries, int nentries)
   1.981 +/*
   1.982 + *  entries        - array of png_sPLT_t structures
   1.983 + *                   to be added to the list of palettes
   1.984 + *                   in the info structure.
   1.985 + *  nentries       - number of palette structures to be
   1.986 + *                   added.
   1.987 + */
   1.988 +{
   1.989 +    png_sPLT_tp np;
   1.990 +    int i;
   1.991 +
   1.992 +    if (png_ptr == NULL || info_ptr == NULL)
   1.993 +       return;
   1.994 +
   1.995 +    np = (png_sPLT_tp)png_malloc_warn(png_ptr,
   1.996 +        (info_ptr->splt_palettes_num + nentries) *
   1.997 +        (png_uint_32)png_sizeof(png_sPLT_t));
   1.998 +    if (np == NULL)
   1.999 +    {
  1.1000 +      png_warning(png_ptr, "No memory for sPLT palettes.");
  1.1001 +      return;
  1.1002 +    }
  1.1003 +
  1.1004 +    png_memcpy(np, info_ptr->splt_palettes,
  1.1005 +           info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t));
  1.1006 +    png_free(png_ptr, info_ptr->splt_palettes);
  1.1007 +    info_ptr->splt_palettes=NULL;
  1.1008 +
  1.1009 +    for (i = 0; i < nentries; i++)
  1.1010 +    {
  1.1011 +        png_sPLT_tp to = np + info_ptr->splt_palettes_num + i;
  1.1012 +        png_sPLT_tp from = entries + i;
  1.1013 +        png_uint_32 length;
  1.1014 +
  1.1015 +        length = png_strlen(from->name) + 1;
  1.1016 +        to->name = (png_charp)png_malloc_warn(png_ptr, length);
  1.1017 +        if (to->name == NULL)
  1.1018 +        {
  1.1019 +           png_warning(png_ptr,
  1.1020 +             "Out of memory while processing sPLT chunk");
  1.1021 +           continue;
  1.1022 +        }
  1.1023 +        png_memcpy(to->name, from->name, length);
  1.1024 +        to->entries = (png_sPLT_entryp)png_malloc_warn(png_ptr,
  1.1025 +            (png_uint_32)(from->nentries * png_sizeof(png_sPLT_entry)));
  1.1026 +        if (to->entries == NULL)
  1.1027 +        {
  1.1028 +           png_warning(png_ptr,
  1.1029 +             "Out of memory while processing sPLT chunk");
  1.1030 +           png_free(png_ptr, to->name);
  1.1031 +           to->name = NULL;
  1.1032 +           continue;
  1.1033 +        }
  1.1034 +        png_memcpy(to->entries, from->entries,
  1.1035 +            from->nentries * png_sizeof(png_sPLT_entry));
  1.1036 +        to->nentries = from->nentries;
  1.1037 +        to->depth = from->depth;
  1.1038 +    }
  1.1039 +
  1.1040 +    info_ptr->splt_palettes = np;
  1.1041 +    info_ptr->splt_palettes_num += nentries;
  1.1042 +    info_ptr->valid |= PNG_INFO_sPLT;
  1.1043 +#ifdef PNG_FREE_ME_SUPPORTED
  1.1044 +    info_ptr->free_me |= PNG_FREE_SPLT;
  1.1045 +#endif
  1.1046 +}
  1.1047 +#endif /* PNG_sPLT_SUPPORTED */
  1.1048 +
  1.1049 +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
  1.1050 +void PNGAPI
  1.1051 +png_set_unknown_chunks(png_structp png_ptr,
  1.1052 +   png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)
  1.1053 +{
  1.1054 +    png_unknown_chunkp np;
  1.1055 +    int i;
  1.1056 +
  1.1057 +    if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0)
  1.1058 +        return;
  1.1059 +
  1.1060 +    np = (png_unknown_chunkp)png_malloc_warn(png_ptr,
  1.1061 +        (png_uint_32)((info_ptr->unknown_chunks_num + num_unknowns) *
  1.1062 +        png_sizeof(png_unknown_chunk)));
  1.1063 +    if (np == NULL)
  1.1064 +    {
  1.1065 +       png_warning(png_ptr,
  1.1066 +          "Out of memory while processing unknown chunk.");
  1.1067 +       return;
  1.1068 +    }
  1.1069 +
  1.1070 +    png_memcpy(np, info_ptr->unknown_chunks,
  1.1071 +           info_ptr->unknown_chunks_num * png_sizeof(png_unknown_chunk));
  1.1072 +    png_free(png_ptr, info_ptr->unknown_chunks);
  1.1073 +    info_ptr->unknown_chunks=NULL;
  1.1074 +
  1.1075 +    for (i = 0; i < num_unknowns; i++)
  1.1076 +    {
  1.1077 +       png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i;
  1.1078 +       png_unknown_chunkp from = unknowns + i;
  1.1079 +
  1.1080 +       png_memcpy((png_charp)to->name, 
  1.1081 +                  (png_charp)from->name, 
  1.1082 +                  png_sizeof(from->name));
  1.1083 +       to->name[png_sizeof(to->name)-1] = '\0';
  1.1084 +       to->size = from->size;
  1.1085 +       /* note our location in the read or write sequence */
  1.1086 +       to->location = (png_byte)(png_ptr->mode & 0xff);
  1.1087 +
  1.1088 +       if (from->size == 0)
  1.1089 +          to->data=NULL;
  1.1090 +       else
  1.1091 +       {
  1.1092 +          to->data = (png_bytep)png_malloc_warn(png_ptr,
  1.1093 +            (png_uint_32)from->size);
  1.1094 +          if (to->data == NULL)
  1.1095 +          {
  1.1096 +             png_warning(png_ptr,
  1.1097 +              "Out of memory while processing unknown chunk.");
  1.1098 +             to->size = 0;
  1.1099 +          }
  1.1100 +          else
  1.1101 +             png_memcpy(to->data, from->data, from->size);
  1.1102 +       }
  1.1103 +    }
  1.1104 +
  1.1105 +    info_ptr->unknown_chunks = np;
  1.1106 +    info_ptr->unknown_chunks_num += num_unknowns;
  1.1107 +#ifdef PNG_FREE_ME_SUPPORTED
  1.1108 +    info_ptr->free_me |= PNG_FREE_UNKN;
  1.1109 +#endif
  1.1110 +}
  1.1111 +void PNGAPI
  1.1112 +png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr,
  1.1113 +   int chunk, int location)
  1.1114 +{
  1.1115 +   if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk <
  1.1116 +         (int)info_ptr->unknown_chunks_num)
  1.1117 +      info_ptr->unknown_chunks[chunk].location = (png_byte)location;
  1.1118 +}
  1.1119 +#endif
  1.1120 +
  1.1121 +#if defined(PNG_1_0_X) || defined(PNG_1_2_X)
  1.1122 +#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \
  1.1123 +    defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)
  1.1124 +void PNGAPI
  1.1125 +png_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted)
  1.1126 +{
  1.1127 +   /* This function is deprecated in favor of png_permit_mng_features()
  1.1128 +      and will be removed from libpng-1.3.0 */
  1.1129 +   png_debug(1, "in png_permit_empty_plte, DEPRECATED.\n");
  1.1130 +   if (png_ptr == NULL)
  1.1131 +      return;
  1.1132 +   png_ptr->mng_features_permitted = (png_byte)
  1.1133 +     ((png_ptr->mng_features_permitted & (~PNG_FLAG_MNG_EMPTY_PLTE)) |
  1.1134 +     ((empty_plte_permitted & PNG_FLAG_MNG_EMPTY_PLTE)));
  1.1135 +}
  1.1136 +#endif
  1.1137 +#endif
  1.1138 +
  1.1139 +#if defined(PNG_MNG_FEATURES_SUPPORTED)
  1.1140 +png_uint_32 PNGAPI
  1.1141 +png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features)
  1.1142 +{
  1.1143 +   png_debug(1, "in png_permit_mng_features\n");
  1.1144 +   if (png_ptr == NULL)
  1.1145 +      return (png_uint_32)0;
  1.1146 +   png_ptr->mng_features_permitted =
  1.1147 +     (png_byte)(mng_features & PNG_ALL_MNG_FEATURES);
  1.1148 +   return (png_uint_32)png_ptr->mng_features_permitted;
  1.1149 +}
  1.1150 +#endif
  1.1151 +
  1.1152 +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
  1.1153 +void PNGAPI
  1.1154 +png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep
  1.1155 +   chunk_list, int num_chunks)
  1.1156 +{
  1.1157 +    png_bytep new_list, p;
  1.1158 +    int i, old_num_chunks;
  1.1159 +    if (png_ptr == NULL)
  1.1160 +       return;
  1.1161 +    if (num_chunks == 0)
  1.1162 +    {
  1.1163 +      if (keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE)
  1.1164 +        png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
  1.1165 +      else
  1.1166 +        png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
  1.1167 +
  1.1168 +      if (keep == PNG_HANDLE_CHUNK_ALWAYS)
  1.1169 +        png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS;
  1.1170 +      else
  1.1171 +        png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;
  1.1172 +      return;
  1.1173 +    }
  1.1174 +    if (chunk_list == NULL)
  1.1175 +      return;
  1.1176 +    old_num_chunks = png_ptr->num_chunk_list;
  1.1177 +    new_list=(png_bytep)png_malloc(png_ptr,
  1.1178 +       (png_uint_32)
  1.1179 +       (5*(num_chunks + old_num_chunks)));
  1.1180 +    if (png_ptr->chunk_list != NULL)
  1.1181 +    {
  1.1182 +       png_memcpy(new_list, png_ptr->chunk_list,
  1.1183 +          (png_size_t)(5*old_num_chunks));
  1.1184 +       png_free(png_ptr, png_ptr->chunk_list);
  1.1185 +       png_ptr->chunk_list=NULL;
  1.1186 +    }
  1.1187 +    png_memcpy(new_list + 5*old_num_chunks, chunk_list,
  1.1188 +       (png_size_t)(5*num_chunks));
  1.1189 +    for (p = new_list + 5*old_num_chunks + 4, i = 0; i<num_chunks; i++, p += 5)
  1.1190 +       *p=(png_byte)keep;
  1.1191 +    png_ptr->num_chunk_list = old_num_chunks + num_chunks;
  1.1192 +    png_ptr->chunk_list = new_list;
  1.1193 +#ifdef PNG_FREE_ME_SUPPORTED
  1.1194 +    png_ptr->free_me |= PNG_FREE_LIST;
  1.1195 +#endif
  1.1196 +}
  1.1197 +#endif
  1.1198 +
  1.1199 +#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
  1.1200 +void PNGAPI
  1.1201 +png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr,
  1.1202 +   png_user_chunk_ptr read_user_chunk_fn)
  1.1203 +{
  1.1204 +   png_debug(1, "in png_set_read_user_chunk_fn\n");
  1.1205 +   if (png_ptr == NULL)
  1.1206 +      return;
  1.1207 +   png_ptr->read_user_chunk_fn = read_user_chunk_fn;
  1.1208 +   png_ptr->user_chunk_ptr = user_chunk_ptr;
  1.1209 +}
  1.1210 +#endif
  1.1211 +
  1.1212 +#if defined(PNG_INFO_IMAGE_SUPPORTED)
  1.1213 +void PNGAPI
  1.1214 +png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers)
  1.1215 +{
  1.1216 +   png_debug1(1, "in %s storage function\n", "rows");
  1.1217 +
  1.1218 +   if (png_ptr == NULL || info_ptr == NULL)
  1.1219 +      return;
  1.1220 +
  1.1221 +   if (info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers))
  1.1222 +      png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
  1.1223 +   info_ptr->row_pointers = row_pointers;
  1.1224 +   if (row_pointers)
  1.1225 +      info_ptr->valid |= PNG_INFO_IDAT;
  1.1226 +}
  1.1227 +#endif
  1.1228 +
  1.1229 +#ifdef PNG_WRITE_SUPPORTED
  1.1230 +void PNGAPI
  1.1231 +png_set_compression_buffer_size(png_structp png_ptr,
  1.1232 +    png_uint_32 size)
  1.1233 +{
  1.1234 +    if (png_ptr == NULL)
  1.1235 +       return;
  1.1236 +    png_free(png_ptr, png_ptr->zbuf);
  1.1237 +    png_ptr->zbuf_size = (png_size_t)size;
  1.1238 +    png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size);
  1.1239 +    png_ptr->zstream.next_out = png_ptr->zbuf;
  1.1240 +    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
  1.1241 +}
  1.1242 +#endif
  1.1243 +
  1.1244 +void PNGAPI
  1.1245 +png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask)
  1.1246 +{
  1.1247 +   if (png_ptr && info_ptr)
  1.1248 +      info_ptr->valid &= ~mask;
  1.1249 +}
  1.1250 +
  1.1251 +
  1.1252 +#ifndef PNG_1_0_X
  1.1253 +#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
  1.1254 +/* function was added to libpng 1.2.0 and should always exist by default */
  1.1255 +void PNGAPI
  1.1256 +png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags)
  1.1257 +{
  1.1258 +/* Obsolete as of libpng-1.2.20 and will be removed from libpng-1.4.0 */
  1.1259 +    if (png_ptr != NULL)
  1.1260 +    png_ptr->asm_flags = 0;
  1.1261 +    asm_flags = asm_flags; /* Quiet the compiler */
  1.1262 +}
  1.1263 +
  1.1264 +/* this function was added to libpng 1.2.0 */
  1.1265 +void PNGAPI
  1.1266 +png_set_mmx_thresholds (png_structp png_ptr,
  1.1267 +                        png_byte mmx_bitdepth_threshold,
  1.1268 +                        png_uint_32 mmx_rowbytes_threshold)
  1.1269 +{
  1.1270 +/* Obsolete as of libpng-1.2.20 and will be removed from libpng-1.4.0 */
  1.1271 +    if (png_ptr == NULL)
  1.1272 +       return;
  1.1273 +    /* Quiet the compiler */
  1.1274 +    mmx_bitdepth_threshold = mmx_bitdepth_threshold;
  1.1275 +    mmx_rowbytes_threshold = mmx_rowbytes_threshold;
  1.1276 +}
  1.1277 +#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */
  1.1278 +
  1.1279 +#ifdef PNG_SET_USER_LIMITS_SUPPORTED
  1.1280 +/* this function was added to libpng 1.2.6 */
  1.1281 +void PNGAPI
  1.1282 +png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max,
  1.1283 +    png_uint_32 user_height_max)
  1.1284 +{
  1.1285 +    /* Images with dimensions larger than these limits will be
  1.1286 +     * rejected by png_set_IHDR().  To accept any PNG datastream
  1.1287 +     * regardless of dimensions, set both limits to 0x7ffffffL.
  1.1288 +     */
  1.1289 +    if (png_ptr == NULL) return;
  1.1290 +    png_ptr->user_width_max = user_width_max;
  1.1291 +    png_ptr->user_height_max = user_height_max;
  1.1292 +}
  1.1293 +#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
  1.1294 +
  1.1295 +#endif /* ?PNG_1_0_X */
  1.1296 +#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */