src/png/pngset.c

   1
   2 /* pngset.c - storage of image information into info struct
   3  *
   4  * Last changed in libpng 1.4.1 [February 25, 2010]
   5  * Copyright (c) 1998-2010 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
  25 void PNGAPI
  26 png_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
  40 void PNGAPI
  41 png_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
  73 void PNGAPI
  74 png_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
 115 void PNGAPI
 116 png_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
 142 void PNGAPI
 143 png_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
 181 void PNGAPI
 182 png_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
 220 void PNGAPI
 221 png_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
 265 #ifdef PNG_oFFs_SUPPORTED
 266 void PNGAPI
 267 png_set_oFFs(png_structp png_ptr, png_infop info_ptr,
 268    png_int_32 offset_x, png_int_32 offset_y, int unit_type)
 269 {
 270    png_debug1(1, "in %s storage function", "oFFs");
 271
 272    if (png_ptr == NULL || info_ptr == NULL)
 273       return;
 274
 275    info_ptr->x_offset = offset_x;
 276    info_ptr->y_offset = offset_y;
 277    info_ptr->offset_unit_type = (png_byte)unit_type;
 278    info_ptr->valid |= PNG_INFO_oFFs;
 279 }
 280 #endif
 281
 282 #ifdef PNG_pCAL_SUPPORTED
 283 void PNGAPI
 284 png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
 285    png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,
 286    png_charp units, png_charpp params)
 287 {
 288    png_size_t length;
 289    int i;
 290
 291    png_debug1(1, "in %s storage function", "pCAL");
 292
 293    if (png_ptr == NULL || info_ptr == NULL)
 294       return;
 295
 296    length = png_strlen(purpose) + 1;
 297    png_debug1(3, "allocating purpose for info (%lu bytes)",
 298      (unsigned long)length);
 299    info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length);
 300    if (info_ptr->pcal_purpose == NULL)
 301    {
 302       png_warning(png_ptr, "Insufficient memory for pCAL purpose");
 303       return;
 304    }
 305    png_memcpy(info_ptr->pcal_purpose, purpose, length);
 306
 307    png_debug(3, "storing X0, X1, type, and nparams in info");
 308    info_ptr->pcal_X0 = X0;
 309    info_ptr->pcal_X1 = X1;
 310    info_ptr->pcal_type = (png_byte)type;
 311    info_ptr->pcal_nparams = (png_byte)nparams;
 312
 313    length = png_strlen(units) + 1;
 314    png_debug1(3, "allocating units for info (%lu bytes)",
 315      (unsigned long)length);
 316    info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length);
 317    if (info_ptr->pcal_units == NULL)
 318    {
 319       png_warning(png_ptr, "Insufficient memory for pCAL units");
 320       return;
 321    }
 322    png_memcpy(info_ptr->pcal_units, units, length);
 323
 324    info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr,
 325       (png_size_t)((nparams + 1) * png_sizeof(png_charp)));
 326    if (info_ptr->pcal_params == NULL)
 327    {
 328       png_warning(png_ptr, "Insufficient memory for pCAL params");
 329       return;
 330    }
 331
 332    png_memset(info_ptr->pcal_params, 0, (nparams + 1) * png_sizeof(png_charp));
 333
 334    for (i = 0; i < nparams; i++)
 335    {
 336       length = png_strlen(params[i]) + 1;
 337       png_debug2(3, "allocating parameter %d for info (%lu bytes)", i,
 338         (unsigned long)length);
 339       info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length);
 340       if (info_ptr->pcal_params[i] == NULL)
 341       {
 342          png_warning(png_ptr, "Insufficient memory for pCAL parameter");
 343          return;
 344       }
 345       png_memcpy(info_ptr->pcal_params[i], params[i], length);
 346    }
 347
 348    info_ptr->valid |= PNG_INFO_pCAL;
 349    info_ptr->free_me |= PNG_FREE_PCAL;
 350 }
 351 #endif
 352
 353 #if defined(PNG_READ_sCAL_SUPPORTED) || defined(PNG_WRITE_sCAL_SUPPORTED)
 354 #ifdef PNG_FLOATING_POINT_SUPPORTED
 355 void PNGAPI
 356 png_set_sCAL(png_structp png_ptr, png_infop info_ptr,
 357              int unit, double width, double height)
 358 {
 359    png_debug1(1, "in %s storage function", "sCAL");
 360
 361    if (png_ptr == NULL || info_ptr == NULL)
 362       return;
 363
 364    info_ptr->scal_unit = (png_byte)unit;
 365    info_ptr->scal_pixel_width = width;
 366    info_ptr->scal_pixel_height = height;
 367
 368    info_ptr->valid |= PNG_INFO_sCAL;
 369 }
 370 #else
 371 #ifdef PNG_FIXED_POINT_SUPPORTED
 372 void PNGAPI
 373 png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,
 374              int unit, png_charp swidth, png_charp sheight)
 375 {
 376    png_size_t length;
 377
 378    png_debug1(1, "in %s storage function", "sCAL");
 379
 380    if (png_ptr == NULL || info_ptr == NULL)
 381       return;
 382
 383    info_ptr->scal_unit = (png_byte)unit;
 384
 385    length = png_strlen(swidth) + 1;
 386    png_debug1(3, "allocating unit for info (%u bytes)",
 387       (unsigned int)length);
 388    info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, length);
 389    if (info_ptr->scal_s_width == NULL)
 390    {
 391       png_warning(png_ptr,
 392          "Memory allocation failed while processing sCAL");
 393       return;
 394    }
 395    png_memcpy(info_ptr->scal_s_width, swidth, length);
 396
 397    length = png_strlen(sheight) + 1;
 398    png_debug1(3, "allocating unit for info (%u bytes)",
 399       (unsigned int)length);
 400    info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, length);
 401    if (info_ptr->scal_s_height == NULL)
 402    {
 403       png_free (png_ptr, info_ptr->scal_s_width);
 404       info_ptr->scal_s_width = NULL;
 405       png_warning(png_ptr,
 406          "Memory allocation failed while processing sCAL");
 407       return;
 408    }
 409    png_memcpy(info_ptr->scal_s_height, sheight, length);
 410    info_ptr->valid |= PNG_INFO_sCAL;
 411    info_ptr->free_me |= PNG_FREE_SCAL;
 412 }
 413 #endif
 414 #endif
 415 #endif
 416
 417 #ifdef PNG_pHYs_SUPPORTED
 418 void PNGAPI
 419 png_set_pHYs(png_structp png_ptr, png_infop info_ptr,
 420    png_uint_32 res_x, png_uint_32 res_y, int unit_type)
 421 {
 422    png_debug1(1, "in %s storage function", "pHYs");
 423
 424    if (png_ptr == NULL || info_ptr == NULL)
 425       return;
 426
 427    info_ptr->x_pixels_per_unit = res_x;
 428    info_ptr->y_pixels_per_unit = res_y;
 429    info_ptr->phys_unit_type = (png_byte)unit_type;
 430    info_ptr->valid |= PNG_INFO_pHYs;
 431 }
 432 #endif
 433
 434 void PNGAPI
 435 png_set_PLTE(png_structp png_ptr, png_infop info_ptr,
 436    png_colorp palette, int num_palette)
 437 {
 438
 439    png_debug1(1, "in %s storage function", "PLTE");
 440
 441    if (png_ptr == NULL || info_ptr == NULL)
 442       return;
 443
 444    if (num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH)
 445    {
 446       if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
 447          png_error(png_ptr, "Invalid palette length");
 448       else
 449       {
 450          png_warning(png_ptr, "Invalid palette length");
 451          return;
 452       }
 453    }
 454
 455    /* It may not actually be necessary to set png_ptr->palette here;
 456     * we do it for backward compatibility with the way the png_handle_tRNS
 457     * function used to do the allocation.
 458     */
 459    png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0);
 460
 461    /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead
 462     * of num_palette entries, in case of an invalid PNG file that has
 463     * too-large sample values.
 464     */
 465    png_ptr->palette = (png_colorp)png_calloc(png_ptr,
 466       PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color));
 467    png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof(png_color));
 468    info_ptr->palette = png_ptr->palette;
 469    info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;
 470
 471    info_ptr->free_me |= PNG_FREE_PLTE;
 472
 473    info_ptr->valid |= PNG_INFO_PLTE;
 474 }
 475
 476 #ifdef PNG_sBIT_SUPPORTED
 477 void PNGAPI
 478 png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
 479    png_color_8p sig_bit)
 480 {
 481    png_debug1(1, "in %s storage function", "sBIT");
 482
 483    if (png_ptr == NULL || info_ptr == NULL)
 484       return;
 485
 486    png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof(png_color_8));
 487    info_ptr->valid |= PNG_INFO_sBIT;
 488 }
 489 #endif
 490
 491 #ifdef PNG_sRGB_SUPPORTED
 492 void PNGAPI
 493 png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent)
 494 {
 495    png_debug1(1, "in %s storage function", "sRGB");
 496
 497    if (png_ptr == NULL || info_ptr == NULL)
 498       return;
 499
 500    info_ptr->srgb_intent = (png_byte)intent;
 501    info_ptr->valid |= PNG_INFO_sRGB;
 502 }
 503
 504 void PNGAPI
 505 png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
 506    int intent)
 507 {
 508 #ifdef PNG_gAMA_SUPPORTED
 509 #ifdef PNG_FLOATING_POINT_SUPPORTED
 510    float file_gamma;
 511 #endif
 512 #ifdef PNG_FIXED_POINT_SUPPORTED
 513    png_fixed_point int_file_gamma;
 514 #endif
 515 #endif
 516 #ifdef PNG_cHRM_SUPPORTED
 517 #ifdef PNG_FLOATING_POINT_SUPPORTED
 518    float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
 519 #endif
 520    png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
 521       int_green_y, int_blue_x, int_blue_y;
 522 #endif
 523    png_debug1(1, "in %s storage function", "sRGB_gAMA_and_cHRM");
 524
 525    if (png_ptr == NULL || info_ptr == NULL)
 526       return;
 527
 528    png_set_sRGB(png_ptr, info_ptr, intent);
 529
 530 #ifdef PNG_gAMA_SUPPORTED
 531 #ifdef PNG_FLOATING_POINT_SUPPORTED
 532    file_gamma = (float).45455;
 533    png_set_gAMA(png_ptr, info_ptr, file_gamma);
 534 #endif
 535 #ifdef PNG_FIXED_POINT_SUPPORTED
 536    int_file_gamma = 45455L;
 537    png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma);
 538 #endif
 539 #endif
 540
 541 #ifdef PNG_cHRM_SUPPORTED
 542    int_white_x = 31270L;
 543    int_white_y = 32900L;
 544    int_red_x   = 64000L;
 545    int_red_y   = 33000L;
 546    int_green_x = 30000L;
 547    int_green_y = 60000L;
 548    int_blue_x  = 15000L;
 549    int_blue_y  =  6000L;
 550
 551 #ifdef PNG_FLOATING_POINT_SUPPORTED
 552    white_x = (float).3127;
 553    white_y = (float).3290;
 554    red_x   = (float).64;
 555    red_y   = (float).33;
 556    green_x = (float).30;
 557    green_y = (float).60;
 558    blue_x  = (float).15;
 559    blue_y  = (float).06;
 560 #endif
 561
 562 #ifdef PNG_FIXED_POINT_SUPPORTED
 563    png_set_cHRM_fixed(png_ptr, info_ptr,
 564        int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
 565        int_green_y, int_blue_x, int_blue_y);
 566 #endif
 567 #ifdef PNG_FLOATING_POINT_SUPPORTED
 568    png_set_cHRM(png_ptr, info_ptr,
 569        white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
 570 #endif
 571 #endif /* cHRM */
 572 }
 573 #endif /* sRGB */
 574
 575
 576 #ifdef PNG_iCCP_SUPPORTED
 577 void PNGAPI
 578 png_set_iCCP(png_structp png_ptr, png_infop info_ptr,
 579              png_charp name, int compression_type,
 580              png_charp profile, png_uint_32 proflen)
 581 {
 582    png_charp new_iccp_name;
 583    png_charp new_iccp_profile;
 584    png_uint_32 length;
 585
 586    png_debug1(1, "in %s storage function", "iCCP");
 587
 588    if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)
 589       return;
 590
 591    length = png_strlen(name)+1;
 592    new_iccp_name = (png_charp)png_malloc_warn(png_ptr, length);
 593    if (new_iccp_name == NULL)
 594    {
 595         png_warning(png_ptr, "Insufficient memory to process iCCP chunk");
 596       return;
 597    }
 598    png_memcpy(new_iccp_name, name, length);
 599    new_iccp_profile = (png_charp)png_malloc_warn(png_ptr, proflen);
 600    if (new_iccp_profile == NULL)
 601    {
 602       png_free (png_ptr, new_iccp_name);
 603       png_warning(png_ptr,
 604           "Insufficient memory to process iCCP profile");
 605       return;
 606    }
 607    png_memcpy(new_iccp_profile, profile, (png_size_t)proflen);
 608
 609    png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0);
 610
 611    info_ptr->iccp_proflen = proflen;
 612    info_ptr->iccp_name = new_iccp_name;
 613    info_ptr->iccp_profile = new_iccp_profile;
 614    /* Compression is always zero but is here so the API and info structure
 615     * does not have to change if we introduce multiple compression types
 616     */
 617    info_ptr->iccp_compression = (png_byte)compression_type;
 618    info_ptr->free_me |= PNG_FREE_ICCP;
 619    info_ptr->valid |= PNG_INFO_iCCP;
 620 }
 621 #endif
 622
 623 #ifdef PNG_TEXT_SUPPORTED
 624 void PNGAPI
 625 png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
 626              int num_text)
 627 {
 628    int ret;
 629    ret = png_set_text_2(png_ptr, info_ptr, text_ptr, num_text);
 630    if (ret)
 631       png_error(png_ptr, "Insufficient memory to store text");
 632 }
 633
 634 int /* PRIVATE */
 635 png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
 636                int num_text)
 637 {
 638    int i;
 639
 640    png_debug1(1, "in %s storage function", ((png_ptr == NULL ||
 641       png_ptr->chunk_name[0] == '\0') ?
 642       "text" : (png_const_charp)png_ptr->chunk_name));
 643
 644    if (png_ptr == NULL || info_ptr == NULL || num_text == 0)
 645       return(0);
 646
 647    /* Make sure we have enough space in the "text" array in info_struct
 648     * to hold all of the incoming text_ptr objects.
 649     */
 650    if (info_ptr->num_text + num_text > info_ptr->max_text)
 651    {
 652       if (info_ptr->text != NULL)
 653       {
 654          png_textp old_text;
 655          int old_max;
 656
 657          old_max = info_ptr->max_text;
 658          info_ptr->max_text = info_ptr->num_text + num_text + 8;
 659          old_text = info_ptr->text;
 660          info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
 661             (png_size_t)(info_ptr->max_text * png_sizeof(png_text)));
 662          if (info_ptr->text == NULL)
 663          {
 664             png_free(png_ptr, old_text);
 665             return(1);
 666          }
 667          png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max *
 668             png_sizeof(png_text)));
 669          png_free(png_ptr, old_text);
 670       }
 671       else
 672       {
 673          info_ptr->max_text = num_text + 8;
 674          info_ptr->num_text = 0;
 675          info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
 676             (png_size_t)(info_ptr->max_text * png_sizeof(png_text)));
 677          if (info_ptr->text == NULL)
 678             return(1);
 679          info_ptr->free_me |= PNG_FREE_TEXT;
 680       }
 681       png_debug1(3, "allocated %d entries for info_ptr->text",
 682          info_ptr->max_text);
 683    }
 684    for (i = 0; i < num_text; i++)
 685    {
 686       png_size_t text_length, key_len;
 687       png_size_t lang_len, lang_key_len;
 688       png_textp textp = &(info_ptr->text[info_ptr->num_text]);
 689
 690       if (text_ptr[i].key == NULL)
 691           continue;
 692
 693       key_len = png_strlen(text_ptr[i].key);
 694
 695       if (text_ptr[i].compression <= 0)
 696       {
 697          lang_len = 0;
 698          lang_key_len = 0;
 699       }
 700
 701       else
 702 #ifdef PNG_iTXt_SUPPORTED
 703       {
 704          /* Set iTXt data */
 705
 706          if (text_ptr[i].lang != NULL)
 707             lang_len = png_strlen(text_ptr[i].lang);
 708          else
 709             lang_len = 0;
 710          if (text_ptr[i].lang_key != NULL)
 711             lang_key_len = png_strlen(text_ptr[i].lang_key);
 712          else
 713             lang_key_len = 0;
 714       }
 715 #else /* PNG_iTXt_SUPPORTED */
 716       {
 717          png_warning(png_ptr, "iTXt chunk not supported");
 718          continue;
 719       }
 720 #endif
 721
 722       if (text_ptr[i].text == NULL || text_ptr[i].text[0] == '\0')
 723       {
 724          text_length = 0;
 725 #ifdef PNG_iTXt_SUPPORTED
 726          if (text_ptr[i].compression > 0)
 727             textp->compression = PNG_ITXT_COMPRESSION_NONE;
 728          else
 729 #endif
 730             textp->compression = PNG_TEXT_COMPRESSION_NONE;
 731       }
 732
 733       else
 734       {
 735          text_length = png_strlen(text_ptr[i].text);
 736          textp->compression = text_ptr[i].compression;
 737       }
 738
 739       textp->key = (png_charp)png_malloc_warn(png_ptr,
 740          (png_size_t)
 741          (key_len + text_length + lang_len + lang_key_len + 4));
 742       if (textp->key == NULL)
 743          return(1);
 744       png_debug2(2, "Allocated %lu bytes at %x in png_set_text",
 745                  (unsigned long)(png_uint_32)
 746                  (key_len + lang_len + lang_key_len + text_length + 4),
 747                  (int)textp->key);
 748
 749       png_memcpy(textp->key, text_ptr[i].key,(png_size_t)(key_len));
 750       *(textp->key + key_len) = '\0';
 751 #ifdef PNG_iTXt_SUPPORTED
 752       if (text_ptr[i].compression > 0)
 753       {
 754          textp->lang = textp->key + key_len + 1;
 755          png_memcpy(textp->lang, text_ptr[i].lang, lang_len);
 756          *(textp->lang + lang_len) = '\0';
 757          textp->lang_key = textp->lang + lang_len + 1;
 758          png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len);
 759          *(textp->lang_key + lang_key_len) = '\0';
 760          textp->text = textp->lang_key + lang_key_len + 1;
 761       }
 762       else
 763 #endif
 764       {
 765 #ifdef PNG_iTXt_SUPPORTED
 766          textp->lang=NULL;
 767          textp->lang_key=NULL;
 768 #endif
 769          textp->text = textp->key + key_len + 1;
 770       }
 771       if (text_length)
 772          png_memcpy(textp->text, text_ptr[i].text,
 773             (png_size_t)(text_length));
 774       *(textp->text + text_length) = '\0';
 775
 776 #ifdef PNG_iTXt_SUPPORTED
 777       if (textp->compression > 0)
 778       {
 779          textp->text_length = 0;
 780          textp->itxt_length = text_length;
 781       }
 782       else
 783 #endif
 784
 785       {
 786          textp->text_length = text_length;
 787 #ifdef PNG_iTXt_SUPPORTED
 788          textp->itxt_length = 0;
 789 #endif
 790       }
 791       info_ptr->num_text++;
 792       png_debug1(3, "transferred text chunk %d", info_ptr->num_text);
 793    }
 794    return(0);
 795 }
 796 #endif
 797
 798 #ifdef PNG_tIME_SUPPORTED
 799 void PNGAPI
 800 png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time)
 801 {
 802    png_debug1(1, "in %s storage function", "tIME");
 803
 804    if (png_ptr == NULL || info_ptr == NULL ||
 805        (png_ptr->mode & PNG_WROTE_tIME))
 806       return;
 807
 808    png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof(png_time));
 809    info_ptr->valid |= PNG_INFO_tIME;
 810 }
 811 #endif
 812
 813 #ifdef PNG_tRNS_SUPPORTED
 814 void PNGAPI
 815 png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
 816    png_bytep trans_alpha, int num_trans, png_color_16p trans_color)
 817 {
 818    png_debug1(1, "in %s storage function", "tRNS");
 819
 820    if (png_ptr == NULL || info_ptr == NULL)
 821       return;
 822
 823    if (trans_alpha != NULL)
 824    {
 825        /* It may not actually be necessary to set png_ptr->trans_alpha here;
 826         * we do it for backward compatibility with the way the png_handle_tRNS
 827         * function used to do the allocation.
 828         */
 829
 830        png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);
 831
 832        /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */
 833        png_ptr->trans_alpha = info_ptr->trans_alpha = (png_bytep)png_malloc(png_ptr,
 834            (png_size_t)PNG_MAX_PALETTE_LENGTH);
 835        if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH)
 836           png_memcpy(info_ptr->trans_alpha, trans_alpha, (png_size_t)num_trans);
 837    }
 838
 839    if (trans_color != NULL)
 840    {
 841       int sample_max = (1 << info_ptr->bit_depth);
 842       if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&
 843           (int)trans_color->gray > sample_max) ||
 844           (info_ptr->color_type == PNG_COLOR_TYPE_RGB &&
 845           ((int)trans_color->red > sample_max ||
 846           (int)trans_color->green > sample_max ||
 847           (int)trans_color->blue > sample_max)))
 848          png_warning(png_ptr,
 849             "tRNS chunk has out-of-range samples for bit_depth");
 850       png_memcpy(&(info_ptr->trans_color), trans_color,
 851          png_sizeof(png_color_16));
 852       if (num_trans == 0)
 853          num_trans = 1;
 854    }
 855
 856    info_ptr->num_trans = (png_uint_16)num_trans;
 857    if (num_trans != 0)
 858    {
 859       info_ptr->valid |= PNG_INFO_tRNS;
 860       info_ptr->free_me |= PNG_FREE_TRNS;
 861    }
 862 }
 863 #endif
 864
 865 #ifdef PNG_sPLT_SUPPORTED
 866 void PNGAPI
 867 png_set_sPLT(png_structp png_ptr,
 868              png_infop info_ptr, png_sPLT_tp entries, int nentries)
 869 /*
 870  *  entries        - array of png_sPLT_t structures
 871  *                   to be added to the list of palettes
 872  *                   in the info structure.
 873  *  nentries       - number of palette structures to be
 874  *                   added.
 875  */
 876 {
 877    png_sPLT_tp np;
 878    int i;
 879
 880    if (png_ptr == NULL || info_ptr == NULL)
 881       return;
 882
 883    np = (png_sPLT_tp)png_malloc_warn(png_ptr,
 884        (info_ptr->splt_palettes_num + nentries) *
 885         (png_size_t)png_sizeof(png_sPLT_t));
 886    if (np == NULL)
 887    {
 888       png_warning(png_ptr, "No memory for sPLT palettes");
 889       return;
 890    }
 891
 892    png_memcpy(np, info_ptr->splt_palettes,
 893        info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t));
 894    png_free(png_ptr, info_ptr->splt_palettes);
 895    info_ptr->splt_palettes=NULL;
 896
 897    for (i = 0; i < nentries; i++)
 898    {
 899       png_sPLT_tp to = np + info_ptr->splt_palettes_num + i;
 900       png_sPLT_tp from = entries + i;
 901       png_uint_32 length;
 902
 903       length = png_strlen(from->name) + 1;
 904       to->name = (png_charp)png_malloc_warn(png_ptr, (png_size_t)length);
 905       if (to->name == NULL)
 906       {
 907          png_warning(png_ptr,
 908            "Out of memory while processing sPLT chunk");
 909          continue;
 910       }
 911       png_memcpy(to->name, from->name, length);
 912       to->entries = (png_sPLT_entryp)png_malloc_warn(png_ptr,
 913           (png_size_t)(from->nentries * png_sizeof(png_sPLT_entry)));
 914       if (to->entries == NULL)
 915       {
 916          png_warning(png_ptr,
 917            "Out of memory while processing sPLT chunk");
 918          png_free(png_ptr, to->name);
 919          to->name = NULL;
 920          continue;
 921       }
 922       png_memcpy(to->entries, from->entries,
 923           from->nentries * png_sizeof(png_sPLT_entry));
 924       to->nentries = from->nentries;
 925       to->depth = from->depth;
 926    }
 927
 928    info_ptr->splt_palettes = np;
 929    info_ptr->splt_palettes_num += nentries;
 930    info_ptr->valid |= PNG_INFO_sPLT;
 931    info_ptr->free_me |= PNG_FREE_SPLT;
 932 }
 933 #endif /* PNG_sPLT_SUPPORTED */
 934
 935 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
 936 void PNGAPI
 937 png_set_unknown_chunks(png_structp png_ptr,
 938    png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)
 939 {
 940    png_unknown_chunkp np;
 941    int i;
 942
 943    if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0)
 944       return;
 945
 946    np = (png_unknown_chunkp)png_malloc_warn(png_ptr,
 947        (png_size_t)((info_ptr->unknown_chunks_num + num_unknowns) *
 948        png_sizeof(png_unknown_chunk)));
 949    if (np == NULL)
 950    {
 951       png_warning(png_ptr,
 952           "Out of memory while processing unknown chunk");
 953       return;
 954    }
 955
 956    png_memcpy(np, info_ptr->unknown_chunks,
 957        info_ptr->unknown_chunks_num * png_sizeof(png_unknown_chunk));
 958    png_free(png_ptr, info_ptr->unknown_chunks);
 959    info_ptr->unknown_chunks = NULL;
 960
 961    for (i = 0; i < num_unknowns; i++)
 962    {
 963       png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i;
 964       png_unknown_chunkp from = unknowns + i;
 965
 966       png_memcpy((png_charp)to->name, (png_charp)from->name,
 967           png_sizeof(from->name));
 968       to->name[png_sizeof(to->name)-1] = '\0';
 969       to->size = from->size;
 970       /* Note our location in the read or write sequence */
 971       to->location = (png_byte)(png_ptr->mode & 0xff);
 972
 973       if (from->size == 0)
 974          to->data=NULL;
 975       else
 976       {
 977          to->data = (png_bytep)png_malloc_warn(png_ptr,
 978            (png_size_t)from->size);
 979          if (to->data == NULL)
 980          {
 981             png_warning(png_ptr,
 982              "Out of memory while processing unknown chunk");
 983             to->size = 0;
 984          }
 985          else
 986             png_memcpy(to->data, from->data, from->size);
 987       }
 988    }
 989
 990    info_ptr->unknown_chunks = np;
 991    info_ptr->unknown_chunks_num += num_unknowns;
 992    info_ptr->free_me |= PNG_FREE_UNKN;
 993 }
 994 void PNGAPI
 995 png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr,
 996    int chunk, int location)
 997 {
 998    if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk <
 999        (int)info_ptr->unknown_chunks_num)
1000       info_ptr->unknown_chunks[chunk].location = (png_byte)location;
1001 }
1002 #endif
1003
1004
1005 #ifdef PNG_MNG_FEATURES_SUPPORTED
1006 png_uint_32 PNGAPI
1007 png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features)
1008 {
1009    png_debug(1, "in png_permit_mng_features");
1010
1011    if (png_ptr == NULL)
1012       return (png_uint_32)0;
1013    png_ptr->mng_features_permitted =
1014      (png_byte)(mng_features & PNG_ALL_MNG_FEATURES);
1015    return (png_uint_32)png_ptr->mng_features_permitted;
1016 }
1017 #endif
1018
1019 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
1020 void PNGAPI
1021 png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep
1022    chunk_list, int num_chunks)
1023 {
1024    png_bytep new_list, p;
1025    int i, old_num_chunks;
1026    if (png_ptr == NULL)
1027       return;
1028    if (num_chunks == 0)
1029    {
1030       if (keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE)
1031          png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
1032       else
1033          png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
1034
1035       if (keep == PNG_HANDLE_CHUNK_ALWAYS)
1036          png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS;
1037       else
1038          png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;
1039       return;
1040    }
1041    if (chunk_list == NULL)
1042       return;
1043    old_num_chunks = png_ptr->num_chunk_list;
1044    new_list=(png_bytep)png_malloc(png_ptr,
1045       (png_size_t)
1046        (5*(num_chunks + old_num_chunks)));
1047    if (png_ptr->chunk_list != NULL)
1048    {
1049       png_memcpy(new_list, png_ptr->chunk_list,
1050           (png_size_t)(5*old_num_chunks));
1051       png_free(png_ptr, png_ptr->chunk_list);
1052       png_ptr->chunk_list=NULL;
1053    }
1054    png_memcpy(new_list + 5*old_num_chunks, chunk_list,
1055        (png_size_t)(5*num_chunks));
1056    for (p = new_list + 5*old_num_chunks + 4, i = 0; i<num_chunks; i++, p += 5)
1057       *p=(png_byte)keep;
1058    png_ptr->num_chunk_list = old_num_chunks + num_chunks;
1059    png_ptr->chunk_list = new_list;
1060    png_ptr->free_me |= PNG_FREE_LIST;
1061 }
1062 #endif
1063
1064 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
1065 void PNGAPI
1066 png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr,
1067    png_user_chunk_ptr read_user_chunk_fn)
1068 {
1069    png_debug(1, "in png_set_read_user_chunk_fn");
1070
1071    if (png_ptr == NULL)
1072       return;
1073
1074    png_ptr->read_user_chunk_fn = read_user_chunk_fn;
1075    png_ptr->user_chunk_ptr = user_chunk_ptr;
1076 }
1077 #endif
1078
1079 #ifdef PNG_INFO_IMAGE_SUPPORTED
1080 void PNGAPI
1081 png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers)
1082 {
1083    png_debug1(1, "in %s storage function", "rows");
1084
1085    if (png_ptr == NULL || info_ptr == NULL)
1086       return;
1087
1088    if (info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers))
1089       png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
1090    info_ptr->row_pointers = row_pointers;
1091    if (row_pointers)
1092       info_ptr->valid |= PNG_INFO_IDAT;
1093 }
1094 #endif
1095
1096 void PNGAPI
1097 png_set_compression_buffer_size(png_structp png_ptr,
1098     png_size_t size)
1099 {
1100     if (png_ptr == NULL)
1101        return;
1102     png_free(png_ptr, png_ptr->zbuf);
1103     png_ptr->zbuf_size = size;
1104     png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size);
1105     png_ptr->zstream.next_out = png_ptr->zbuf;
1106     png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
1107 }
1108
1109 void PNGAPI
1110 png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask)
1111 {
1112    if (png_ptr && info_ptr)
1113       info_ptr->valid &= ~mask;
1114 }
1115
1116
1117
1118 #ifdef PNG_SET_USER_LIMITS_SUPPORTED
1119 /* This function was added to libpng 1.2.6 */
1120 void PNGAPI
1121 png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max,
1122     png_uint_32 user_height_max)
1123 {
1124    /* Images with dimensions larger than these limits will be
1125     * rejected by png_set_IHDR().  To accept any PNG datastream
1126     * regardless of dimensions, set both limits to 0x7ffffffL.
1127     */
1128    if (png_ptr == NULL)
1129       return;
1130    png_ptr->user_width_max = user_width_max;
1131    png_ptr->user_height_max = user_height_max;
1132 }
1133
1134 /* This function was added to libpng 1.4.0 */
1135 void PNGAPI
1136 png_set_chunk_cache_max (png_structp png_ptr,
1137    png_uint_32 user_chunk_cache_max)
1138 {
1139     if (png_ptr)
1140        png_ptr->user_chunk_cache_max = user_chunk_cache_max;
1141 }
1142
1143 /* This function was added to libpng 1.4.1 */
1144 void PNGAPI
1145 png_set_chunk_malloc_max (png_structp png_ptr,
1146    png_alloc_size_t user_chunk_malloc_max)
1147 {
1148     if (png_ptr)
1149        png_ptr->user_chunk_malloc_max =
1150           (png_size_t)user_chunk_malloc_max;
1151 }
1152 #endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
1153
1154
1155 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
1156 void PNGAPI
1157 png_set_benign_errors(png_structp png_ptr, int allowed)
1158 {
1159    png_debug(1, "in png_set_benign_errors");
1160
1161    if (allowed)
1162       png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;
1163    else
1164       png_ptr->flags &= ~PNG_FLAG_BENIGN_ERRORS_WARN;
1165 }
1166 #endif /* PNG_BENIGN_ERRORS_SUPPORTED */
1167 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */