PageRenderTime 85ms CodeModel.GetById 13ms app.highlight 62ms RepoModel.GetById 1ms app.codeStats 1ms

/media/libpng/pngset.c

http://github.com/zpao/v8monkey
C | 1319 lines | 1090 code | 168 blank | 61 comment | 267 complexity | 2daf7da68d78f4ea45bc25f97cbc8c06 MD5 | raw file
   1
   2/* pngset.c - storage of image information into info struct
   3 *
   4 * Last changed in libpng 1.4.6 [January 14, 2011]
   5 * Copyright (c) 1998-2011 Glenn Randers-Pehrson
   6 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
   7 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
   8 *
   9 * This code is released under the libpng license.
  10 * For conditions of distribution and use, see the disclaimer
  11 * and license in png.h
  12 *
  13 * The functions here are used during reads to store data from the file
  14 * into the info struct, and during writes to store application data
  15 * into the info struct for writing into the file.  This abstracts the
  16 * info struct and allows us to change the structure in the future.
  17 */
  18
  19#define PNG_NO_PEDANTIC_WARNINGS
  20#include "png.h"
  21#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  22#include "pngpriv.h"
  23
  24#ifdef PNG_bKGD_SUPPORTED
  25void PNGAPI
  26png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background)
  27{
  28   png_debug1(1, "in %s storage function", "bKGD");
  29
  30   if (png_ptr == NULL || info_ptr == NULL)
  31      return;
  32
  33   png_memcpy(&(info_ptr->background), background, png_sizeof(png_color_16));
  34   info_ptr->valid |= PNG_INFO_bKGD;
  35}
  36#endif
  37
  38#ifdef PNG_cHRM_SUPPORTED
  39#ifdef PNG_FLOATING_POINT_SUPPORTED
  40void PNGAPI
  41png_set_cHRM(png_structp png_ptr, png_infop info_ptr,
  42   double white_x, double white_y, double red_x, double red_y,
  43   double green_x, double green_y, double blue_x, double blue_y)
  44{
  45   png_debug1(1, "in %s storage function", "cHRM");
  46
  47   if (png_ptr == NULL || info_ptr == NULL)
  48      return;
  49
  50   info_ptr->x_white = (float)white_x;
  51   info_ptr->y_white = (float)white_y;
  52   info_ptr->x_red   = (float)red_x;
  53   info_ptr->y_red   = (float)red_y;
  54   info_ptr->x_green = (float)green_x;
  55   info_ptr->y_green = (float)green_y;
  56   info_ptr->x_blue  = (float)blue_x;
  57   info_ptr->y_blue  = (float)blue_y;
  58#ifdef PNG_FIXED_POINT_SUPPORTED
  59   info_ptr->int_x_white = (png_fixed_point)(white_x*100000.+0.5);
  60   info_ptr->int_y_white = (png_fixed_point)(white_y*100000.+0.5);
  61   info_ptr->int_x_red   = (png_fixed_point)(  red_x*100000.+0.5);
  62   info_ptr->int_y_red   = (png_fixed_point)(  red_y*100000.+0.5);
  63   info_ptr->int_x_green = (png_fixed_point)(green_x*100000.+0.5);
  64   info_ptr->int_y_green = (png_fixed_point)(green_y*100000.+0.5);
  65   info_ptr->int_x_blue  = (png_fixed_point)( blue_x*100000.+0.5);
  66   info_ptr->int_y_blue  = (png_fixed_point)( blue_y*100000.+0.5);
  67#endif
  68   info_ptr->valid |= PNG_INFO_cHRM;
  69}
  70#endif /* PNG_FLOATING_POINT_SUPPORTED */
  71
  72#ifdef PNG_FIXED_POINT_SUPPORTED
  73void PNGAPI
  74png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
  75   png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,
  76   png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,
  77   png_fixed_point blue_x, png_fixed_point blue_y)
  78{
  79   png_debug1(1, "in %s storage function", "cHRM fixed");
  80
  81   if (png_ptr == NULL || info_ptr == NULL)
  82      return;
  83
  84#ifdef PNG_CHECK_cHRM_SUPPORTED
  85   if (png_check_cHRM_fixed(png_ptr,
  86      white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y))
  87#endif
  88   {
  89      info_ptr->int_x_white = white_x;
  90      info_ptr->int_y_white = white_y;
  91      info_ptr->int_x_red   = red_x;
  92      info_ptr->int_y_red   = red_y;
  93      info_ptr->int_x_green = green_x;
  94      info_ptr->int_y_green = green_y;
  95      info_ptr->int_x_blue  = blue_x;
  96      info_ptr->int_y_blue  = blue_y;
  97#ifdef  PNG_FLOATING_POINT_SUPPORTED
  98      info_ptr->x_white = (float)(white_x/100000.);
  99      info_ptr->y_white = (float)(white_y/100000.);
 100      info_ptr->x_red   = (float)(  red_x/100000.);
 101      info_ptr->y_red   = (float)(  red_y/100000.);
 102      info_ptr->x_green = (float)(green_x/100000.);
 103      info_ptr->y_green = (float)(green_y/100000.);
 104      info_ptr->x_blue  = (float)( blue_x/100000.);
 105      info_ptr->y_blue  = (float)( blue_y/100000.);
 106#endif
 107      info_ptr->valid |= PNG_INFO_cHRM;
 108   }
 109}
 110#endif /* PNG_FIXED_POINT_SUPPORTED */
 111#endif /* PNG_cHRM_SUPPORTED */
 112
 113#ifdef PNG_gAMA_SUPPORTED
 114#ifdef PNG_FLOATING_POINT_SUPPORTED
 115void PNGAPI
 116png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)
 117{
 118   double png_gamma;
 119
 120   png_debug1(1, "in %s storage function", "gAMA");
 121
 122   if (png_ptr == NULL || info_ptr == NULL)
 123      return;
 124
 125   /* Check for overflow */
 126   if (file_gamma > 21474.83)
 127   {
 128      png_warning(png_ptr, "Limiting gamma to 21474.83");
 129      png_gamma=21474.83;
 130   }
 131   else
 132      png_gamma = file_gamma;
 133   info_ptr->gamma = (float)png_gamma;
 134#ifdef PNG_FIXED_POINT_SUPPORTED
 135   info_ptr->int_gamma = (int)(png_gamma*100000.+.5);
 136#endif
 137   info_ptr->valid |= PNG_INFO_gAMA;
 138   if (png_gamma == 0.0)
 139      png_warning(png_ptr, "Setting gamma=0");
 140}
 141#endif
 142void PNGAPI
 143png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point
 144   int_gamma)
 145{
 146   png_fixed_point png_gamma;
 147
 148   png_debug1(1, "in %s storage function", "gAMA");
 149
 150   if (png_ptr == NULL || info_ptr == NULL)
 151      return;
 152
 153   if (int_gamma > (png_fixed_point)PNG_UINT_31_MAX)
 154   {
 155      png_warning(png_ptr, "Limiting gamma to 21474.83");
 156      png_gamma=PNG_UINT_31_MAX;
 157   }
 158   else
 159   {
 160      if (int_gamma < 0)
 161      {
 162         png_warning(png_ptr, "Setting negative gamma to zero");
 163         png_gamma = 0;
 164      }
 165      else
 166         png_gamma = int_gamma;
 167   }
 168#ifdef PNG_FLOATING_POINT_SUPPORTED
 169   info_ptr->gamma = (float)(png_gamma/100000.);
 170#endif
 171#ifdef PNG_FIXED_POINT_SUPPORTED
 172   info_ptr->int_gamma = png_gamma;
 173#endif
 174   info_ptr->valid |= PNG_INFO_gAMA;
 175   if (png_gamma == 0)
 176      png_warning(png_ptr, "Setting gamma=0");
 177}
 178#endif
 179
 180#ifdef PNG_hIST_SUPPORTED
 181void PNGAPI
 182png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)
 183{
 184   int i;
 185
 186   png_debug1(1, "in %s storage function", "hIST");
 187
 188   if (png_ptr == NULL || info_ptr == NULL)
 189      return;
 190
 191   if (info_ptr->num_palette == 0 || info_ptr->num_palette
 192       > PNG_MAX_PALETTE_LENGTH)
 193   {
 194      png_warning(png_ptr,
 195         "Invalid palette size, hIST allocation skipped");
 196      return;
 197   }
 198
 199   png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0);
 200   /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in
 201    * version 1.2.1
 202    */
 203   png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr,
 204      PNG_MAX_PALETTE_LENGTH * png_sizeof(png_uint_16));
 205   if (png_ptr->hist == NULL)
 206   {
 207      png_warning(png_ptr, "Insufficient memory for hIST chunk data");
 208      return;
 209   }
 210
 211   for (i = 0; i < info_ptr->num_palette; i++)
 212      png_ptr->hist[i] = hist[i];
 213   info_ptr->hist = png_ptr->hist;
 214   info_ptr->valid |= PNG_INFO_hIST;
 215
 216   info_ptr->free_me |= PNG_FREE_HIST;
 217}
 218#endif
 219
 220void PNGAPI
 221png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
 222   png_uint_32 width, png_uint_32 height, int bit_depth,
 223   int color_type, int interlace_type, int compression_type,
 224   int filter_type)
 225{
 226   png_debug1(1, "in %s storage function", "IHDR");
 227
 228   if (png_ptr == NULL || info_ptr == NULL)
 229      return;
 230
 231   info_ptr->width = width;
 232   info_ptr->height = height;
 233   info_ptr->bit_depth = (png_byte)bit_depth;
 234   info_ptr->color_type = (png_byte)color_type;
 235   info_ptr->compression_type = (png_byte)compression_type;
 236   info_ptr->filter_type = (png_byte)filter_type;
 237   info_ptr->interlace_type = (png_byte)interlace_type;
 238
 239   png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height,
 240       info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,
 241       info_ptr->compression_type, info_ptr->filter_type);
 242
 243   if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
 244      info_ptr->channels = 1;
 245   else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)
 246      info_ptr->channels = 3;
 247   else
 248      info_ptr->channels = 1;
 249   if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
 250      info_ptr->channels++;
 251   info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);
 252
 253   /* Check for potential overflow */
 254   if (width > (PNG_UINT_32_MAX
 255                 >> 3)      /* 8-byte RGBA pixels */
 256                 - 64       /* bigrowbuf hack */
 257                 - 1        /* filter byte */
 258                 - 7*8      /* rounding of width to multiple of 8 pixels */
 259                 - 8)       /* extra max_pixel_depth pad */
 260      info_ptr->rowbytes = 0;
 261   else
 262      info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, width);
 263
 264#if defined(PNG_APNG_SUPPORTED)
 265   /* for non-animated png. this may be overwritten from an acTL chunk later */
 266   info_ptr->num_frames = 1;
 267#endif
 268}
 269
 270#ifdef PNG_oFFs_SUPPORTED
 271void PNGAPI
 272png_set_oFFs(png_structp png_ptr, png_infop info_ptr,
 273   png_int_32 offset_x, png_int_32 offset_y, int unit_type)
 274{
 275   png_debug1(1, "in %s storage function", "oFFs");
 276
 277   if (png_ptr == NULL || info_ptr == NULL)
 278      return;
 279
 280   info_ptr->x_offset = offset_x;
 281   info_ptr->y_offset = offset_y;
 282   info_ptr->offset_unit_type = (png_byte)unit_type;
 283   info_ptr->valid |= PNG_INFO_oFFs;
 284}
 285#endif
 286
 287#ifdef PNG_pCAL_SUPPORTED
 288void PNGAPI
 289png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
 290   png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,
 291   png_charp units, png_charpp params)
 292{
 293   png_size_t length;
 294   int i;
 295
 296   png_debug1(1, "in %s storage function", "pCAL");
 297
 298   if (png_ptr == NULL || info_ptr == NULL)
 299      return;
 300
 301   length = png_strlen(purpose) + 1;
 302   png_debug1(3, "allocating purpose for info (%lu bytes)",
 303     (unsigned long)length);
 304   info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length);
 305   if (info_ptr->pcal_purpose == NULL)
 306   {
 307      png_warning(png_ptr, "Insufficient memory for pCAL purpose");
 308      return;
 309   }
 310   png_memcpy(info_ptr->pcal_purpose, purpose, length);
 311
 312   png_debug(3, "storing X0, X1, type, and nparams in info");
 313   info_ptr->pcal_X0 = X0;
 314   info_ptr->pcal_X1 = X1;
 315   info_ptr->pcal_type = (png_byte)type;
 316   info_ptr->pcal_nparams = (png_byte)nparams;
 317
 318   length = png_strlen(units) + 1;
 319   png_debug1(3, "allocating units for info (%lu bytes)",
 320     (unsigned long)length);
 321   info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length);
 322   if (info_ptr->pcal_units == NULL)
 323   {
 324      png_warning(png_ptr, "Insufficient memory for pCAL units");
 325      return;
 326   }
 327   png_memcpy(info_ptr->pcal_units, units, length);
 328
 329   info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr,
 330      (png_size_t)((nparams + 1) * png_sizeof(png_charp)));
 331   if (info_ptr->pcal_params == NULL)
 332   {
 333      png_warning(png_ptr, "Insufficient memory for pCAL params");
 334      return;
 335   }
 336
 337   png_memset(info_ptr->pcal_params, 0, (nparams + 1) * png_sizeof(png_charp));
 338
 339   for (i = 0; i < nparams; i++)
 340   {
 341      length = png_strlen(params[i]) + 1;
 342      png_debug2(3, "allocating parameter %d for info (%lu bytes)", i,
 343        (unsigned long)length);
 344      info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length);
 345      if (info_ptr->pcal_params[i] == NULL)
 346      {
 347         png_warning(png_ptr, "Insufficient memory for pCAL parameter");
 348         return;
 349      }
 350      png_memcpy(info_ptr->pcal_params[i], params[i], length);
 351   }
 352
 353   info_ptr->valid |= PNG_INFO_pCAL;
 354   info_ptr->free_me |= PNG_FREE_PCAL;
 355}
 356#endif
 357
 358#if defined(PNG_READ_sCAL_SUPPORTED) || defined(PNG_WRITE_sCAL_SUPPORTED)
 359#ifdef PNG_FLOATING_POINT_SUPPORTED
 360void PNGAPI
 361png_set_sCAL(png_structp png_ptr, png_infop info_ptr,
 362             int unit, double width, double height)
 363{
 364   png_debug1(1, "in %s storage function", "sCAL");
 365
 366   if (png_ptr == NULL || info_ptr == NULL)
 367      return;
 368
 369   info_ptr->scal_unit = (png_byte)unit;
 370   info_ptr->scal_pixel_width = width;
 371   info_ptr->scal_pixel_height = height;
 372
 373   info_ptr->valid |= PNG_INFO_sCAL;
 374}
 375#else
 376#ifdef PNG_FIXED_POINT_SUPPORTED
 377void PNGAPI
 378png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,
 379             int unit, png_charp swidth, png_charp sheight)
 380{
 381   png_size_t length;
 382
 383   png_debug1(1, "in %s storage function", "sCAL");
 384
 385   if (png_ptr == NULL || info_ptr == NULL)
 386      return;
 387
 388   info_ptr->scal_unit = (png_byte)unit;
 389
 390   length = png_strlen(swidth) + 1;
 391   png_debug1(3, "allocating unit for info (%u bytes)",
 392      (unsigned int)length);
 393   info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, length);
 394   if (info_ptr->scal_s_width == NULL)
 395   {
 396      png_warning(png_ptr,
 397       "Memory allocation failed while processing sCAL");
 398      return;
 399   }
 400   png_memcpy(info_ptr->scal_s_width, swidth, length);
 401
 402   length = png_strlen(sheight) + 1;
 403   png_debug1(3, "allocating unit for info (%u bytes)",
 404      (unsigned int)length);
 405   info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, length);
 406   if (info_ptr->scal_s_height == NULL)
 407   {
 408      png_free (png_ptr, info_ptr->scal_s_width);
 409      info_ptr->scal_s_width = NULL;
 410      png_warning(png_ptr,
 411       "Memory allocation failed while processing sCAL");
 412      return;
 413   }
 414   png_memcpy(info_ptr->scal_s_height, sheight, length);
 415   info_ptr->valid |= PNG_INFO_sCAL;
 416   info_ptr->free_me |= PNG_FREE_SCAL;
 417}
 418#endif
 419#endif
 420#endif
 421
 422#ifdef PNG_pHYs_SUPPORTED
 423void PNGAPI
 424png_set_pHYs(png_structp png_ptr, png_infop info_ptr,
 425   png_uint_32 res_x, png_uint_32 res_y, int unit_type)
 426{
 427   png_debug1(1, "in %s storage function", "pHYs");
 428
 429   if (png_ptr == NULL || info_ptr == NULL)
 430      return;
 431
 432   info_ptr->x_pixels_per_unit = res_x;
 433   info_ptr->y_pixels_per_unit = res_y;
 434   info_ptr->phys_unit_type = (png_byte)unit_type;
 435   info_ptr->valid |= PNG_INFO_pHYs;
 436}
 437#endif
 438
 439void PNGAPI
 440png_set_PLTE(png_structp png_ptr, png_infop info_ptr,
 441   png_colorp palette, int num_palette)
 442{
 443
 444   png_debug1(1, "in %s storage function", "PLTE");
 445
 446   if (png_ptr == NULL || info_ptr == NULL)
 447      return;
 448
 449   if (num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH)
 450   {
 451      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
 452         png_error(png_ptr, "Invalid palette length");
 453      else
 454      {
 455         png_warning(png_ptr, "Invalid palette length");
 456         return;
 457      }
 458   }
 459
 460   /*
 461    * It may not actually be necessary to set png_ptr->palette here;
 462    * we do it for backward compatibility with the way the png_handle_tRNS
 463    * function used to do the allocation.
 464    */
 465   png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0);
 466
 467   /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead
 468    * of num_palette entries, in case of an invalid PNG file that has
 469    * too-large sample values.
 470    */
 471   png_ptr->palette = (png_colorp)png_calloc(png_ptr,
 472      PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color));
 473   png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof(png_color));
 474   info_ptr->palette = png_ptr->palette;
 475   info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;
 476
 477   info_ptr->free_me |= PNG_FREE_PLTE;
 478
 479   info_ptr->valid |= PNG_INFO_PLTE;
 480}
 481
 482#ifdef PNG_sBIT_SUPPORTED
 483void PNGAPI
 484png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
 485   png_color_8p sig_bit)
 486{
 487   png_debug1(1, "in %s storage function", "sBIT");
 488
 489   if (png_ptr == NULL || info_ptr == NULL)
 490      return;
 491
 492   png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof(png_color_8));
 493   info_ptr->valid |= PNG_INFO_sBIT;
 494}
 495#endif
 496
 497#ifdef PNG_sRGB_SUPPORTED
 498void PNGAPI
 499png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent)
 500{
 501   png_debug1(1, "in %s storage function", "sRGB");
 502
 503   if (png_ptr == NULL || info_ptr == NULL)
 504      return;
 505
 506   info_ptr->srgb_intent = (png_byte)intent;
 507   info_ptr->valid |= PNG_INFO_sRGB;
 508}
 509
 510void PNGAPI
 511png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
 512   int intent)
 513{
 514#ifdef PNG_gAMA_SUPPORTED
 515#ifdef PNG_FLOATING_POINT_SUPPORTED
 516   float file_gamma;
 517#endif
 518#ifdef PNG_FIXED_POINT_SUPPORTED
 519   png_fixed_point int_file_gamma;
 520#endif
 521#endif
 522#ifdef PNG_cHRM_SUPPORTED
 523#ifdef PNG_FLOATING_POINT_SUPPORTED
 524   float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
 525#endif
 526   png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
 527      int_green_y, int_blue_x, int_blue_y;
 528#endif
 529   png_debug1(1, "in %s storage function", "sRGB_gAMA_and_cHRM");
 530
 531   if (png_ptr == NULL || info_ptr == NULL)
 532      return;
 533
 534   png_set_sRGB(png_ptr, info_ptr, intent);
 535
 536#ifdef PNG_gAMA_SUPPORTED
 537#ifdef PNG_FLOATING_POINT_SUPPORTED
 538   file_gamma = (float).45455;
 539   png_set_gAMA(png_ptr, info_ptr, file_gamma);
 540#endif
 541#ifdef PNG_FIXED_POINT_SUPPORTED
 542   int_file_gamma = 45455L;
 543   png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma);
 544#endif
 545#endif
 546
 547#ifdef PNG_cHRM_SUPPORTED
 548   int_white_x = 31270L;
 549   int_white_y = 32900L;
 550   int_red_x   = 64000L;
 551   int_red_y   = 33000L;
 552   int_green_x = 30000L;
 553   int_green_y = 60000L;
 554   int_blue_x  = 15000L;
 555   int_blue_y  =  6000L;
 556
 557#ifdef PNG_FLOATING_POINT_SUPPORTED
 558   white_x = (float).3127;
 559   white_y = (float).3290;
 560   red_x   = (float).64;
 561   red_y   = (float).33;
 562   green_x = (float).30;
 563   green_y = (float).60;
 564   blue_x  = (float).15;
 565   blue_y  = (float).06;
 566#endif
 567
 568#ifdef PNG_FIXED_POINT_SUPPORTED
 569   png_set_cHRM_fixed(png_ptr, info_ptr,
 570       int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
 571       int_green_y, int_blue_x, int_blue_y);
 572#endif
 573#ifdef PNG_FLOATING_POINT_SUPPORTED
 574   png_set_cHRM(png_ptr, info_ptr,
 575       white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
 576#endif
 577#endif /* cHRM */
 578}
 579#endif /* sRGB */
 580
 581
 582#ifdef PNG_iCCP_SUPPORTED
 583void PNGAPI
 584png_set_iCCP(png_structp png_ptr, png_infop info_ptr,
 585             png_charp name, int compression_type,
 586             png_charp profile, png_uint_32 proflen)
 587{
 588   png_charp new_iccp_name;
 589   png_charp new_iccp_profile;
 590   png_uint_32 length;
 591
 592   png_debug1(1, "in %s storage function", "iCCP");
 593
 594   if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)
 595      return;
 596
 597   length = png_strlen(name)+1;
 598   new_iccp_name = (png_charp)png_malloc_warn(png_ptr, length);
 599   if (new_iccp_name == NULL)
 600   {
 601      png_warning(png_ptr, "Insufficient memory to process iCCP chunk");
 602      return;
 603   }
 604   png_memcpy(new_iccp_name, name, length);
 605   new_iccp_profile = (png_charp)png_malloc_warn(png_ptr, proflen);
 606   if (new_iccp_profile == NULL)
 607   {
 608      png_free (png_ptr, new_iccp_name);
 609      png_warning(png_ptr,
 610      "Insufficient memory to process iCCP profile");
 611      return;
 612   }
 613   png_memcpy(new_iccp_profile, profile, (png_size_t)proflen);
 614
 615   png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0);
 616
 617   info_ptr->iccp_proflen = proflen;
 618   info_ptr->iccp_name = new_iccp_name;
 619   info_ptr->iccp_profile = new_iccp_profile;
 620   /* Compression is always zero but is here so the API and info structure
 621    * does not have to change if we introduce multiple compression types */
 622   info_ptr->iccp_compression = (png_byte)compression_type;
 623   info_ptr->free_me |= PNG_FREE_ICCP;
 624   info_ptr->valid |= PNG_INFO_iCCP;
 625}
 626#endif
 627
 628#ifdef PNG_TEXT_SUPPORTED
 629void PNGAPI
 630png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
 631             int num_text)
 632{
 633   int ret;
 634   ret = png_set_text_2(png_ptr, info_ptr, text_ptr, num_text);
 635   if (ret)
 636      png_error(png_ptr, "Insufficient memory to store text");
 637}
 638
 639int /* PRIVATE */
 640png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
 641               int num_text)
 642{
 643   int i;
 644
 645   png_debug1(1, "in %s storage function", ((png_ptr == NULL ||
 646      png_ptr->chunk_name[0] == '\0') ?
 647      "text" : (png_const_charp)png_ptr->chunk_name));
 648
 649   if (png_ptr == NULL || info_ptr == NULL || num_text == 0)
 650      return(0);
 651
 652   /* Make sure we have enough space in the "text" array in info_struct
 653    * to hold all of the incoming text_ptr objects.
 654    */
 655   if (info_ptr->num_text + num_text > info_ptr->max_text)
 656   {
 657      if (info_ptr->text != NULL)
 658      {
 659         png_textp old_text;
 660         int old_max;
 661
 662         old_max = info_ptr->max_text;
 663         info_ptr->max_text = info_ptr->num_text + num_text + 8;
 664         old_text = info_ptr->text;
 665         info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
 666            (png_size_t)(info_ptr->max_text * png_sizeof(png_text)));
 667         if (info_ptr->text == NULL)
 668         {
 669            png_free(png_ptr, old_text);
 670            return(1);
 671         }
 672         png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max *
 673            png_sizeof(png_text)));
 674         png_free(png_ptr, old_text);
 675      }
 676      else
 677      {
 678         info_ptr->max_text = num_text + 8;
 679         info_ptr->num_text = 0;
 680         info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
 681            (png_size_t)(info_ptr->max_text * png_sizeof(png_text)));
 682         if (info_ptr->text == NULL)
 683            return(1);
 684         info_ptr->free_me |= PNG_FREE_TEXT;
 685      }
 686      png_debug1(3, "allocated %d entries for info_ptr->text",
 687         info_ptr->max_text);
 688   }
 689   for (i = 0; i < num_text; i++)
 690   {
 691      png_size_t text_length, key_len;
 692      png_size_t lang_len, lang_key_len;
 693      png_textp textp = &(info_ptr->text[info_ptr->num_text]);
 694
 695      if (text_ptr[i].key == NULL)
 696          continue;
 697
 698      if (text_ptr[i].compression < PNG_TEXT_COMPRESSION_NONE ||
 699          text_ptr[i].compression >= PNG_TEXT_COMPRESSION_LAST)
 700      {
 701         png_warning(png_ptr, "text compression mode is out of range");
 702         continue;
 703      }
 704
 705      key_len = png_strlen(text_ptr[i].key);
 706
 707      if (text_ptr[i].compression <= 0)
 708      {
 709         lang_len = 0;
 710         lang_key_len = 0;
 711      }
 712
 713      else
 714#ifdef PNG_iTXt_SUPPORTED
 715      {
 716         /* Set iTXt data */
 717
 718         if (text_ptr[i].lang != NULL)
 719            lang_len = png_strlen(text_ptr[i].lang);
 720         else
 721            lang_len = 0;
 722         if (text_ptr[i].lang_key != NULL)
 723            lang_key_len = png_strlen(text_ptr[i].lang_key);
 724         else
 725            lang_key_len = 0;
 726      }
 727#else /* PNG_iTXt_SUPPORTED */
 728      {
 729         png_warning(png_ptr, "iTXt chunk not supported");
 730         continue;
 731      }
 732#endif
 733
 734      if (text_ptr[i].text == NULL || text_ptr[i].text[0] == '\0')
 735      {
 736         text_length = 0;
 737#ifdef PNG_iTXt_SUPPORTED
 738         if (text_ptr[i].compression > 0)
 739            textp->compression = PNG_ITXT_COMPRESSION_NONE;
 740         else
 741#endif
 742            textp->compression = PNG_TEXT_COMPRESSION_NONE;
 743      }
 744
 745      else
 746      {
 747         text_length = png_strlen(text_ptr[i].text);
 748         textp->compression = text_ptr[i].compression;
 749      }
 750
 751      textp->key = (png_charp)png_malloc_warn(png_ptr,
 752         (png_size_t)
 753         (key_len + text_length + lang_len + lang_key_len + 4));
 754      if (textp->key == NULL)
 755         return(1);
 756      png_debug2(2, "Allocated %lu bytes at %x in png_set_text",
 757                 (unsigned long)(png_uint_32)
 758                 (key_len + lang_len + lang_key_len + text_length + 4),
 759                 (int)textp->key);
 760
 761      png_memcpy(textp->key, text_ptr[i].key,(png_size_t)(key_len));
 762      *(textp->key + key_len) = '\0';
 763#ifdef PNG_iTXt_SUPPORTED
 764      if (text_ptr[i].compression > 0)
 765      {
 766         textp->lang = textp->key + key_len + 1;
 767         png_memcpy(textp->lang, text_ptr[i].lang, lang_len);
 768         *(textp->lang + lang_len) = '\0';
 769         textp->lang_key = textp->lang + lang_len + 1;
 770         png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len);
 771         *(textp->lang_key + lang_key_len) = '\0';
 772         textp->text = textp->lang_key + lang_key_len + 1;
 773      }
 774      else
 775#endif
 776      {
 777#ifdef PNG_iTXt_SUPPORTED
 778         textp->lang=NULL;
 779         textp->lang_key=NULL;
 780#endif
 781         textp->text = textp->key + key_len + 1;
 782      }
 783      if (text_length)
 784         png_memcpy(textp->text, text_ptr[i].text,
 785            (png_size_t)(text_length));
 786      *(textp->text + text_length) = '\0';
 787
 788#ifdef PNG_iTXt_SUPPORTED
 789      if (textp->compression > 0)
 790      {
 791         textp->text_length = 0;
 792         textp->itxt_length = text_length;
 793      }
 794      else
 795#endif
 796
 797      {
 798         textp->text_length = text_length;
 799#ifdef PNG_iTXt_SUPPORTED
 800         textp->itxt_length = 0;
 801#endif
 802      }
 803      info_ptr->num_text++;
 804      png_debug1(3, "transferred text chunk %d", info_ptr->num_text);
 805   }
 806   return(0);
 807}
 808#endif
 809
 810#ifdef PNG_tIME_SUPPORTED
 811void PNGAPI
 812png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time)
 813{
 814   png_debug1(1, "in %s storage function", "tIME");
 815
 816   if (png_ptr == NULL || info_ptr == NULL ||
 817       (png_ptr->mode & PNG_WROTE_tIME))
 818      return;
 819
 820   png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof(png_time));
 821   info_ptr->valid |= PNG_INFO_tIME;
 822}
 823#endif
 824
 825#ifdef PNG_tRNS_SUPPORTED
 826void PNGAPI
 827png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
 828   png_bytep trans_alpha, int num_trans, png_color_16p trans_color)
 829{
 830   png_debug1(1, "in %s storage function", "tRNS");
 831
 832   if (png_ptr == NULL || info_ptr == NULL)
 833      return;
 834
 835   if (trans_alpha != NULL)
 836   {
 837       /* It may not actually be necessary to set png_ptr->trans_alpha here;
 838        * we do it for backward compatibility with the way the png_handle_tRNS
 839        * function used to do the allocation.
 840        */
 841
 842       png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);
 843
 844       /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */
 845       png_ptr->trans_alpha = info_ptr->trans_alpha = (png_bytep)png_malloc(png_ptr,
 846           (png_size_t)PNG_MAX_PALETTE_LENGTH);
 847       if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH)
 848          png_memcpy(info_ptr->trans_alpha, trans_alpha, (png_size_t)num_trans);
 849   }
 850
 851   if (trans_color != NULL)
 852   {
 853      int sample_max = (1 << info_ptr->bit_depth);
 854      if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&
 855          (int)trans_color->gray > sample_max) ||
 856          (info_ptr->color_type == PNG_COLOR_TYPE_RGB &&
 857          ((int)trans_color->red > sample_max ||
 858          (int)trans_color->green > sample_max ||
 859          (int)trans_color->blue > sample_max)))
 860         png_warning(png_ptr,
 861            "tRNS chunk has out-of-range samples for bit_depth");
 862      png_memcpy(&(info_ptr->trans_color), trans_color,
 863         png_sizeof(png_color_16));
 864      if (num_trans == 0)
 865         num_trans = 1;
 866   }
 867
 868   info_ptr->num_trans = (png_uint_16)num_trans;
 869   if (num_trans != 0)
 870   {
 871      info_ptr->valid |= PNG_INFO_tRNS;
 872      info_ptr->free_me |= PNG_FREE_TRNS;
 873   }
 874}
 875#endif
 876
 877#ifdef PNG_sPLT_SUPPORTED
 878void PNGAPI
 879png_set_sPLT(png_structp png_ptr,
 880             png_infop info_ptr, png_sPLT_tp entries, int nentries)
 881/*
 882 *  entries        - array of png_sPLT_t structures
 883 *                   to be added to the list of palettes
 884 *                   in the info structure.
 885 *  nentries       - number of palette structures to be
 886 *                   added.
 887 */
 888{
 889   png_sPLT_tp np;
 890   int i;
 891
 892   if (png_ptr == NULL || info_ptr == NULL)
 893      return;
 894
 895   np = (png_sPLT_tp)png_malloc_warn(png_ptr,
 896       (info_ptr->splt_palettes_num + nentries) *
 897        (png_size_t)png_sizeof(png_sPLT_t));
 898   if (np == NULL)
 899   {
 900      png_warning(png_ptr, "No memory for sPLT palettes");
 901     return;
 902   }
 903
 904   png_memcpy(np, info_ptr->splt_palettes,
 905          info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t));
 906   png_free(png_ptr, info_ptr->splt_palettes);
 907   info_ptr->splt_palettes=NULL;
 908
 909   for (i = 0; i < nentries; i++)
 910   {
 911      png_sPLT_tp to = np + info_ptr->splt_palettes_num + i;
 912      png_sPLT_tp from = entries + i;
 913      png_uint_32 length;
 914
 915      length = png_strlen(from->name) + 1;
 916        to->name = (png_charp)png_malloc_warn(png_ptr, (png_size_t)length);
 917      if (to->name == NULL)
 918      {
 919         png_warning(png_ptr,
 920           "Out of memory while processing sPLT chunk");
 921         continue;
 922      }
 923      png_memcpy(to->name, from->name, length);
 924      to->entries = (png_sPLT_entryp)png_malloc_warn(png_ptr,
 925            (png_size_t)(from->nentries * png_sizeof(png_sPLT_entry)));
 926      if (to->entries == NULL)
 927      {
 928         png_warning(png_ptr,
 929           "Out of memory while processing sPLT chunk");
 930         png_free(png_ptr, to->name);
 931         to->name = NULL;
 932         continue;
 933      }
 934      png_memcpy(to->entries, from->entries,
 935          from->nentries * png_sizeof(png_sPLT_entry));
 936      to->nentries = from->nentries;
 937      to->depth = from->depth;
 938   }
 939
 940   info_ptr->splt_palettes = np;
 941   info_ptr->splt_palettes_num += nentries;
 942   info_ptr->valid |= PNG_INFO_sPLT;
 943   info_ptr->free_me |= PNG_FREE_SPLT;
 944}
 945#endif /* PNG_sPLT_SUPPORTED */
 946
 947#if defined(PNG_APNG_SUPPORTED)
 948png_uint_32 PNGAPI
 949png_set_acTL(png_structp png_ptr, png_infop info_ptr,
 950    png_uint_32 num_frames, png_uint_32 num_plays)
 951{
 952    png_debug1(1, "in %s storage function", "acTL");
 953
 954    if (png_ptr == NULL || info_ptr == NULL)
 955    {
 956        png_warning(png_ptr,
 957                    "Call to png_set_acTL() with NULL png_ptr "
 958                    "or info_ptr ignored");
 959        return (0);
 960    }
 961    if (num_frames == 0)
 962    {
 963        png_warning(png_ptr,
 964                    "Ignoring attempt to set acTL with num_frames zero");
 965        return (0);
 966    }
 967    if (num_frames > PNG_UINT_31_MAX)
 968    {
 969        png_warning(png_ptr,
 970                    "Ignoring attempt to set acTL with num_frames > 2^31-1");
 971        return (0);
 972    }
 973    if (num_plays > PNG_UINT_31_MAX)
 974    {
 975        png_warning(png_ptr,
 976                    "Ignoring attempt to set acTL with num_plays "
 977                    "> 2^31-1");
 978        return (0);
 979    }
 980
 981    info_ptr->num_frames = num_frames;
 982    info_ptr->num_plays = num_plays;
 983
 984    info_ptr->valid |= PNG_INFO_acTL;
 985
 986    return (1);
 987}
 988
 989/* delay_num and delay_den can hold any 16-bit values including zero */
 990png_uint_32 PNGAPI
 991png_set_next_frame_fcTL(png_structp png_ptr, png_infop info_ptr,
 992    png_uint_32 width, png_uint_32 height,
 993    png_uint_32 x_offset, png_uint_32 y_offset,
 994    png_uint_16 delay_num, png_uint_16 delay_den,
 995    png_byte dispose_op, png_byte blend_op)
 996{
 997    png_debug1(1, "in %s storage function", "fcTL");
 998
 999    if (png_ptr == NULL || info_ptr == NULL)
1000    {
1001        png_warning(png_ptr,
1002                    "Call to png_set_fcTL() with NULL png_ptr or info_ptr "
1003                    "ignored");
1004        return (0);
1005    }
1006
1007    png_ensure_fcTL_is_valid(png_ptr, width, height, x_offset, y_offset,
1008                             delay_num, delay_den, dispose_op, blend_op);
1009
1010    /* For efficiency, ignore BLEND_OP_OVER when image is opaque.
1011     * See bug #441971 and #455140
1012     */
1013    if (blend_op == PNG_BLEND_OP_OVER)
1014    {
1015        if (!(png_ptr->color_type & PNG_COLOR_MASK_ALPHA) &&
1016            !(png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)))
1017        {
1018          png_warning(png_ptr,
1019                      "PNG_BLEND_OP_OVER is meaningless and wasteful "
1020                      "for opaque images, ignored");
1021          blend_op = PNG_BLEND_OP_SOURCE;
1022        }
1023    }
1024
1025    info_ptr->next_frame_width = width;
1026    info_ptr->next_frame_height = height;
1027    info_ptr->next_frame_x_offset = x_offset;
1028    info_ptr->next_frame_y_offset = y_offset;
1029    info_ptr->next_frame_delay_num = delay_num;
1030    info_ptr->next_frame_delay_den = delay_den;
1031    info_ptr->next_frame_dispose_op = dispose_op;
1032    info_ptr->next_frame_blend_op = blend_op;
1033
1034    info_ptr->valid |= PNG_INFO_fcTL;
1035
1036    return (1);
1037}
1038
1039void /* PRIVATE */
1040png_ensure_fcTL_is_valid(png_structp png_ptr,
1041    png_uint_32 width, png_uint_32 height,
1042    png_uint_32 x_offset, png_uint_32 y_offset,
1043    png_uint_16 delay_num, png_uint_16 delay_den,
1044    png_byte dispose_op, png_byte blend_op)
1045{
1046    if (width + x_offset > png_ptr->first_frame_width ||
1047        height + y_offset > png_ptr->first_frame_height)
1048        png_error(png_ptr, "dimensions of a frame are greater than"
1049                           "the ones in IHDR");
1050    if (width > PNG_UINT_31_MAX)
1051        png_error(png_ptr, "invalid width in fcTL (> 2^31-1)");
1052    if (height > PNG_UINT_31_MAX)
1053        png_error(png_ptr, "invalid height in fcTL (> 2^31-1)");
1054    if (x_offset > PNG_UINT_31_MAX)
1055        png_error(png_ptr, "invalid x_offset in fcTL (> 2^31-1)");
1056    if (y_offset > PNG_UINT_31_MAX)
1057        png_error(png_ptr, "invalid y_offset in fcTL (> 2^31-1)");
1058
1059    if (dispose_op != PNG_DISPOSE_OP_NONE &&
1060	dispose_op != PNG_DISPOSE_OP_BACKGROUND &&
1061	dispose_op != PNG_DISPOSE_OP_PREVIOUS)
1062        png_error(png_ptr, "invalid dispose_op in fcTL");
1063
1064    if (blend_op != PNG_BLEND_OP_SOURCE &&
1065	blend_op != PNG_BLEND_OP_OVER)
1066        png_error(png_ptr, "invalid blend_op in fcTL");
1067}
1068
1069png_uint_32 PNGAPI
1070png_set_first_frame_is_hidden(png_structp png_ptr, png_infop info_ptr,
1071                              png_byte is_hidden)
1072{
1073    png_debug(1, "in png_first_frame_is_hidden()");
1074
1075    if (png_ptr == NULL)
1076        return 0;
1077
1078    if(is_hidden)
1079        png_ptr->apng_flags |= PNG_FIRST_FRAME_HIDDEN;
1080    else
1081        png_ptr->apng_flags &= ~PNG_FIRST_FRAME_HIDDEN;
1082
1083    return 1;
1084}
1085#endif /* PNG_APNG_SUPPORTED */
1086
1087#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
1088void PNGAPI
1089png_set_unknown_chunks(png_structp png_ptr,
1090   png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)
1091{
1092   png_unknown_chunkp np;
1093   int i;
1094
1095   if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0)
1096      return;
1097
1098   np = (png_unknown_chunkp)png_malloc_warn(png_ptr,
1099       (png_size_t)((info_ptr->unknown_chunks_num + num_unknowns) *
1100       png_sizeof(png_unknown_chunk)));
1101   if (np == NULL)
1102   {
1103      png_warning(png_ptr,
1104         "Out of memory while processing unknown chunk");
1105      return;
1106   }
1107
1108   png_memcpy(np, info_ptr->unknown_chunks,
1109          info_ptr->unknown_chunks_num * png_sizeof(png_unknown_chunk));
1110   png_free(png_ptr, info_ptr->unknown_chunks);
1111
1112   for (i = 0; i < num_unknowns; i++)
1113   {
1114      png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i;
1115      png_unknown_chunkp from = unknowns + i;
1116
1117      png_memcpy((png_charp)to->name,
1118                 (png_charp)from->name,
1119                 png_sizeof(from->name));
1120      to->name[png_sizeof(to->name)-1] = '\0';
1121      to->size = from->size;
1122      /* Note our location in the read or write sequence */
1123      to->location = (png_byte)(png_ptr->mode & 0xff);
1124
1125      if (from->size == 0)
1126         to->data=NULL;
1127      else
1128      {
1129         to->data = (png_bytep)png_malloc_warn(png_ptr,
1130           (png_size_t)from->size);
1131         if (to->data == NULL)
1132         {
1133            png_warning(png_ptr,
1134             "Out of memory while processing unknown chunk");
1135            to->size = 0;
1136         }
1137         else
1138            png_memcpy(to->data, from->data, from->size);
1139      }
1140   }
1141
1142   info_ptr->unknown_chunks = np;
1143   info_ptr->unknown_chunks_num += num_unknowns;
1144   info_ptr->free_me |= PNG_FREE_UNKN;
1145}
1146void PNGAPI
1147png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr,
1148   int chunk, int location)
1149{
1150   if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk <
1151         (int)info_ptr->unknown_chunks_num)
1152      info_ptr->unknown_chunks[chunk].location = (png_byte)location;
1153}
1154#endif
1155
1156
1157#ifdef PNG_MNG_FEATURES_SUPPORTED
1158png_uint_32 PNGAPI
1159png_permit_mng_features(png_structp png_ptr, png_uint_32 mng_features)
1160{
1161   png_debug(1, "in png_permit_mng_features");
1162
1163   if (png_ptr == NULL)
1164      return (png_uint_32)0;
1165   png_ptr->mng_features_permitted =
1166     (png_byte)(mng_features & PNG_ALL_MNG_FEATURES);
1167   return (png_uint_32)png_ptr->mng_features_permitted;
1168}
1169#endif
1170
1171#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
1172void PNGAPI
1173png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep
1174   chunk_list, int num_chunks)
1175{
1176   png_bytep new_list, p;
1177   int i, old_num_chunks;
1178   if (png_ptr == NULL)
1179      return;
1180   if (num_chunks == 0)
1181   {
1182      if (keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE)
1183         png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
1184      else
1185         png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
1186
1187      if (keep == PNG_HANDLE_CHUNK_ALWAYS)
1188         png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS;
1189      else
1190         png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;
1191      return;
1192   }
1193   if (chunk_list == NULL)
1194      return;
1195   old_num_chunks = png_ptr->num_chunk_list;
1196   new_list=(png_bytep)png_malloc(png_ptr,
1197      (png_size_t)
1198      (5*(num_chunks + old_num_chunks)));
1199   if (png_ptr->chunk_list != NULL)
1200   {
1201      png_memcpy(new_list, png_ptr->chunk_list,
1202         (png_size_t)(5*old_num_chunks));
1203      png_free(png_ptr, png_ptr->chunk_list);
1204      png_ptr->chunk_list=NULL;
1205   }
1206   png_memcpy(new_list + 5*old_num_chunks, chunk_list,
1207      (png_size_t)(5*num_chunks));
1208   for (p = new_list + 5*old_num_chunks + 4, i = 0; i<num_chunks; i++, p += 5)
1209      *p=(png_byte)keep;
1210   png_ptr->num_chunk_list = old_num_chunks + num_chunks;
1211   png_ptr->chunk_list = new_list;
1212   png_ptr->free_me |= PNG_FREE_LIST;
1213}
1214#endif
1215
1216#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
1217void PNGAPI
1218png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr,
1219   png_user_chunk_ptr read_user_chunk_fn)
1220{
1221   png_debug(1, "in png_set_read_user_chunk_fn");
1222
1223   if (png_ptr == NULL)
1224      return;
1225
1226   png_ptr->read_user_chunk_fn = read_user_chunk_fn;
1227   png_ptr->user_chunk_ptr = user_chunk_ptr;
1228}
1229#endif
1230
1231#ifdef PNG_INFO_IMAGE_SUPPORTED
1232void PNGAPI
1233png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers)
1234{
1235   png_debug1(1, "in %s storage function", "rows");
1236
1237   if (png_ptr == NULL || info_ptr == NULL)
1238      return;
1239
1240   if (info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers))
1241      png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
1242   info_ptr->row_pointers = row_pointers;
1243   if (row_pointers)
1244      info_ptr->valid |= PNG_INFO_IDAT;
1245}
1246#endif
1247
1248void PNGAPI
1249png_set_compression_buffer_size(png_structp png_ptr,
1250    png_size_t size)
1251{
1252    if (png_ptr == NULL)
1253       return;
1254    png_free(png_ptr, png_ptr->zbuf);
1255    png_ptr->zbuf_size = size;
1256    png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size);
1257    png_ptr->zstream.next_out = png_ptr->zbuf;
1258    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
1259}
1260
1261void PNGAPI
1262png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask)
1263{
1264   if (png_ptr && info_ptr)
1265      info_ptr->valid &= ~mask;
1266}
1267
1268
1269
1270#ifdef PNG_SET_USER_LIMITS_SUPPORTED
1271/* This function was added to libpng 1.2.6 */
1272void PNGAPI
1273png_set_user_limits(png_structp png_ptr, png_uint_32 user_width_max,
1274    png_uint_32 user_height_max)
1275{
1276   /* Images with dimensions larger than these limits will be
1277    * rejected by png_set_IHDR().  To accept any PNG datastream
1278    * regardless of dimensions, set both limits to 0x7ffffffL.
1279    */
1280   if (png_ptr == NULL)
1281      return;
1282   png_ptr->user_width_max = user_width_max;
1283   png_ptr->user_height_max = user_height_max;
1284}
1285
1286/* This function was added to libpng 1.4.0 */
1287void PNGAPI
1288png_set_chunk_cache_max(png_structp png_ptr,
1289   png_uint_32 user_chunk_cache_max)
1290{
1291    if (png_ptr)
1292       png_ptr->user_chunk_cache_max = user_chunk_cache_max;
1293}
1294
1295/* This function was added to libpng 1.4.1 */
1296void PNGAPI
1297png_set_chunk_malloc_max(png_structp png_ptr,
1298   png_alloc_size_t user_chunk_malloc_max)
1299{
1300    if (png_ptr)
1301       png_ptr->user_chunk_malloc_max =
1302          (png_size_t)user_chunk_malloc_max;
1303}
1304#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
1305
1306
1307#ifdef PNG_BENIGN_ERRORS_SUPPORTED
1308void PNGAPI
1309png_set_benign_errors(png_structp png_ptr, int allowed)
1310{
1311   png_debug(1, "in png_set_benign_errors");
1312
1313   if (allowed)
1314      png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;
1315   else
1316      png_ptr->flags &= ~PNG_FLAG_BENIGN_ERRORS_WARN;
1317}
1318#endif /* PNG_BENIGN_ERRORS_SUPPORTED */
1319#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */