/media/libpng/pngset.c
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 */