pngget.c (41982B)
1 /* pngget.c - retrieval of values from info struct 2 * 3 * Copyright (c) 2018-2025 Cosmin Truta 4 * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson 5 * Copyright (c) 1996-1997 Andreas Dilger 6 * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. 7 * 8 * This code is released under the libpng license. 9 * For conditions of distribution and use, see the disclaimer 10 * and license in png.h 11 * 12 */ 13 14 #include "pngpriv.h" 15 16 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) 17 18 png_uint_32 PNGAPI 19 png_get_valid(png_const_structrp png_ptr, png_const_inforp info_ptr, 20 png_uint_32 flag) 21 { 22 if (png_ptr != NULL && info_ptr != NULL) 23 { 24 #ifdef PNG_READ_tRNS_SUPPORTED 25 /* png_handle_PLTE() may have canceled a valid tRNS chunk but left the 26 * 'valid' flag for the detection of duplicate chunks. Do not report a 27 * valid tRNS chunk in this case. 28 */ 29 if (flag == PNG_INFO_tRNS && png_ptr->num_trans == 0) 30 return 0; 31 #endif 32 33 return info_ptr->valid & flag; 34 } 35 36 return 0; 37 } 38 39 size_t PNGAPI 40 png_get_rowbytes(png_const_structrp png_ptr, png_const_inforp info_ptr) 41 { 42 if (png_ptr != NULL && info_ptr != NULL) 43 return info_ptr->rowbytes; 44 45 return 0; 46 } 47 48 #ifdef PNG_INFO_IMAGE_SUPPORTED 49 png_bytepp PNGAPI 50 png_get_rows(png_const_structrp png_ptr, png_const_inforp info_ptr) 51 { 52 if (png_ptr != NULL && info_ptr != NULL) 53 return info_ptr->row_pointers; 54 55 return 0; 56 } 57 #endif 58 59 #ifdef PNG_EASY_ACCESS_SUPPORTED 60 /* Easy access to info, added in libpng-0.99 */ 61 png_uint_32 PNGAPI 62 png_get_image_width(png_const_structrp png_ptr, png_const_inforp info_ptr) 63 { 64 if (png_ptr != NULL && info_ptr != NULL) 65 return info_ptr->width; 66 67 return 0; 68 } 69 70 png_uint_32 PNGAPI 71 png_get_image_height(png_const_structrp png_ptr, png_const_inforp info_ptr) 72 { 73 if (png_ptr != NULL && info_ptr != NULL) 74 return info_ptr->height; 75 76 return 0; 77 } 78 79 png_byte PNGAPI 80 png_get_bit_depth(png_const_structrp png_ptr, png_const_inforp info_ptr) 81 { 82 if (png_ptr != NULL && info_ptr != NULL) 83 return info_ptr->bit_depth; 84 85 return 0; 86 } 87 88 png_byte PNGAPI 89 png_get_color_type(png_const_structrp png_ptr, png_const_inforp info_ptr) 90 { 91 if (png_ptr != NULL && info_ptr != NULL) 92 return info_ptr->color_type; 93 94 return 0; 95 } 96 97 png_byte PNGAPI 98 png_get_filter_type(png_const_structrp png_ptr, png_const_inforp info_ptr) 99 { 100 if (png_ptr != NULL && info_ptr != NULL) 101 return info_ptr->filter_type; 102 103 return 0; 104 } 105 106 png_byte PNGAPI 107 png_get_interlace_type(png_const_structrp png_ptr, png_const_inforp info_ptr) 108 { 109 if (png_ptr != NULL && info_ptr != NULL) 110 return info_ptr->interlace_type; 111 112 return 0; 113 } 114 115 png_byte PNGAPI 116 png_get_compression_type(png_const_structrp png_ptr, png_const_inforp info_ptr) 117 { 118 if (png_ptr != NULL && info_ptr != NULL) 119 return info_ptr->compression_type; 120 121 return 0; 122 } 123 124 png_uint_32 PNGAPI 125 png_get_x_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp 126 info_ptr) 127 { 128 #ifdef PNG_pHYs_SUPPORTED 129 png_debug(1, "in png_get_x_pixels_per_meter"); 130 131 if (png_ptr != NULL && info_ptr != NULL && 132 (info_ptr->valid & PNG_INFO_pHYs) != 0) 133 { 134 if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER) 135 return info_ptr->x_pixels_per_unit; 136 } 137 #else 138 PNG_UNUSED(png_ptr) 139 PNG_UNUSED(info_ptr) 140 #endif 141 142 return 0; 143 } 144 145 png_uint_32 PNGAPI 146 png_get_y_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp 147 info_ptr) 148 { 149 #ifdef PNG_pHYs_SUPPORTED 150 png_debug(1, "in png_get_y_pixels_per_meter"); 151 152 if (png_ptr != NULL && info_ptr != NULL && 153 (info_ptr->valid & PNG_INFO_pHYs) != 0) 154 { 155 if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER) 156 return info_ptr->y_pixels_per_unit; 157 } 158 #else 159 PNG_UNUSED(png_ptr) 160 PNG_UNUSED(info_ptr) 161 #endif 162 163 return 0; 164 } 165 166 png_uint_32 PNGAPI 167 png_get_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp info_ptr) 168 { 169 #ifdef PNG_pHYs_SUPPORTED 170 png_debug(1, "in png_get_pixels_per_meter"); 171 172 if (png_ptr != NULL && info_ptr != NULL && 173 (info_ptr->valid & PNG_INFO_pHYs) != 0) 174 { 175 if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER && 176 info_ptr->x_pixels_per_unit == info_ptr->y_pixels_per_unit) 177 return info_ptr->x_pixels_per_unit; 178 } 179 #else 180 PNG_UNUSED(png_ptr) 181 PNG_UNUSED(info_ptr) 182 #endif 183 184 return 0; 185 } 186 187 #ifdef PNG_FLOATING_POINT_SUPPORTED 188 float PNGAPI 189 png_get_pixel_aspect_ratio(png_const_structrp png_ptr, png_const_inforp 190 info_ptr) 191 { 192 #ifdef PNG_READ_pHYs_SUPPORTED 193 png_debug(1, "in png_get_pixel_aspect_ratio"); 194 195 if (png_ptr != NULL && info_ptr != NULL && 196 (info_ptr->valid & PNG_INFO_pHYs) != 0) 197 { 198 if (info_ptr->x_pixels_per_unit != 0) 199 return (float)info_ptr->y_pixels_per_unit 200 / (float)info_ptr->x_pixels_per_unit; 201 } 202 #else 203 PNG_UNUSED(png_ptr) 204 PNG_UNUSED(info_ptr) 205 #endif 206 207 return (float)0.0; 208 } 209 #endif 210 211 #ifdef PNG_FIXED_POINT_SUPPORTED 212 png_fixed_point PNGAPI 213 png_get_pixel_aspect_ratio_fixed(png_const_structrp png_ptr, 214 png_const_inforp info_ptr) 215 { 216 #ifdef PNG_READ_pHYs_SUPPORTED 217 png_debug(1, "in png_get_pixel_aspect_ratio_fixed"); 218 219 if (png_ptr != NULL && info_ptr != NULL && 220 (info_ptr->valid & PNG_INFO_pHYs) != 0 && 221 info_ptr->x_pixels_per_unit > 0 && info_ptr->y_pixels_per_unit > 0 && 222 info_ptr->x_pixels_per_unit <= PNG_UINT_31_MAX && 223 info_ptr->y_pixels_per_unit <= PNG_UINT_31_MAX) 224 { 225 png_fixed_point res; 226 227 /* The following casts work because a PNG 4 byte integer only has a valid 228 * range of 0..2^31-1; otherwise the cast might overflow. 229 */ 230 if (png_muldiv(&res, (png_int_32)info_ptr->y_pixels_per_unit, PNG_FP_1, 231 (png_int_32)info_ptr->x_pixels_per_unit) != 0) 232 return res; 233 } 234 #else 235 PNG_UNUSED(png_ptr) 236 PNG_UNUSED(info_ptr) 237 #endif 238 239 return 0; 240 } 241 #endif 242 243 png_int_32 PNGAPI 244 png_get_x_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr) 245 { 246 #ifdef PNG_oFFs_SUPPORTED 247 png_debug(1, "in png_get_x_offset_microns"); 248 249 if (png_ptr != NULL && info_ptr != NULL && 250 (info_ptr->valid & PNG_INFO_oFFs) != 0) 251 { 252 if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER) 253 return info_ptr->x_offset; 254 } 255 #else 256 PNG_UNUSED(png_ptr) 257 PNG_UNUSED(info_ptr) 258 #endif 259 260 return 0; 261 } 262 263 png_int_32 PNGAPI 264 png_get_y_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr) 265 { 266 #ifdef PNG_oFFs_SUPPORTED 267 png_debug(1, "in png_get_y_offset_microns"); 268 269 if (png_ptr != NULL && info_ptr != NULL && 270 (info_ptr->valid & PNG_INFO_oFFs) != 0) 271 { 272 if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER) 273 return info_ptr->y_offset; 274 } 275 #else 276 PNG_UNUSED(png_ptr) 277 PNG_UNUSED(info_ptr) 278 #endif 279 280 return 0; 281 } 282 283 png_int_32 PNGAPI 284 png_get_x_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr) 285 { 286 #ifdef PNG_oFFs_SUPPORTED 287 png_debug(1, "in png_get_x_offset_pixels"); 288 289 if (png_ptr != NULL && info_ptr != NULL && 290 (info_ptr->valid & PNG_INFO_oFFs) != 0) 291 { 292 if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL) 293 return info_ptr->x_offset; 294 } 295 #else 296 PNG_UNUSED(png_ptr) 297 PNG_UNUSED(info_ptr) 298 #endif 299 300 return 0; 301 } 302 303 png_int_32 PNGAPI 304 png_get_y_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr) 305 { 306 #ifdef PNG_oFFs_SUPPORTED 307 png_debug(1, "in png_get_y_offset_pixels"); 308 309 if (png_ptr != NULL && info_ptr != NULL && 310 (info_ptr->valid & PNG_INFO_oFFs) != 0) 311 { 312 if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL) 313 return info_ptr->y_offset; 314 } 315 #else 316 PNG_UNUSED(png_ptr) 317 PNG_UNUSED(info_ptr) 318 #endif 319 320 return 0; 321 } 322 323 #ifdef PNG_INCH_CONVERSIONS_SUPPORTED 324 static png_uint_32 325 ppi_from_ppm(png_uint_32 ppm) 326 { 327 #if 0 328 /* The conversion is *(2.54/100), in binary (32 digits): 329 * .00000110100000001001110101001001 330 */ 331 png_uint_32 t1001, t1101; 332 ppm >>= 1; /* .1 */ 333 t1001 = ppm + (ppm >> 3); /* .1001 */ 334 t1101 = t1001 + (ppm >> 1); /* .1101 */ 335 ppm >>= 20; /* .000000000000000000001 */ 336 t1101 += t1101 >> 15; /* .1101000000000001101 */ 337 t1001 >>= 11; /* .000000000001001 */ 338 t1001 += t1001 >> 12; /* .000000000001001000000001001 */ 339 ppm += t1001; /* .000000000001001000001001001 */ 340 ppm += t1101; /* .110100000001001110101001001 */ 341 return (ppm + 16) >> 5;/* .00000110100000001001110101001001 */ 342 #else 343 /* The argument is a PNG unsigned integer, so it is not permitted 344 * to be bigger than 2^31. 345 */ 346 png_fixed_point result; 347 if (ppm <= PNG_UINT_31_MAX && png_muldiv(&result, (png_int_32)ppm, 127, 348 5000) != 0) 349 return (png_uint_32)result; 350 351 /* Overflow. */ 352 return 0; 353 #endif 354 } 355 356 png_uint_32 PNGAPI 357 png_get_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr) 358 { 359 return ppi_from_ppm(png_get_pixels_per_meter(png_ptr, info_ptr)); 360 } 361 362 png_uint_32 PNGAPI 363 png_get_x_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr) 364 { 365 return ppi_from_ppm(png_get_x_pixels_per_meter(png_ptr, info_ptr)); 366 } 367 368 png_uint_32 PNGAPI 369 png_get_y_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr) 370 { 371 return ppi_from_ppm(png_get_y_pixels_per_meter(png_ptr, info_ptr)); 372 } 373 374 #ifdef PNG_FIXED_POINT_SUPPORTED 375 static png_fixed_point 376 png_fixed_inches_from_microns(png_const_structrp png_ptr, png_int_32 microns) 377 { 378 /* Convert from meters * 1,000,000 to inches * 100,000, meters to 379 * inches is simply *(100/2.54), so we want *(10/2.54) == 500/127. 380 * Notice that this can overflow - a warning is output and 0 is 381 * returned. 382 */ 383 png_fixed_point result; 384 385 if (png_muldiv(&result, microns, 500, 127) != 0) 386 return result; 387 388 png_warning(png_ptr, "fixed point overflow ignored"); 389 return 0; 390 } 391 392 png_fixed_point PNGAPI 393 png_get_x_offset_inches_fixed(png_const_structrp png_ptr, 394 png_const_inforp info_ptr) 395 { 396 return png_fixed_inches_from_microns(png_ptr, 397 png_get_x_offset_microns(png_ptr, info_ptr)); 398 } 399 #endif /* FIXED_POINT */ 400 401 #ifdef PNG_FIXED_POINT_SUPPORTED 402 png_fixed_point PNGAPI 403 png_get_y_offset_inches_fixed(png_const_structrp png_ptr, 404 png_const_inforp info_ptr) 405 { 406 return png_fixed_inches_from_microns(png_ptr, 407 png_get_y_offset_microns(png_ptr, info_ptr)); 408 } 409 #endif 410 411 #ifdef PNG_FLOATING_POINT_SUPPORTED 412 float PNGAPI 413 png_get_x_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr) 414 { 415 /* To avoid the overflow do the conversion directly in floating 416 * point. 417 */ 418 return (float)(png_get_x_offset_microns(png_ptr, info_ptr) * .00003937); 419 } 420 #endif 421 422 #ifdef PNG_FLOATING_POINT_SUPPORTED 423 float PNGAPI 424 png_get_y_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr) 425 { 426 /* To avoid the overflow do the conversion directly in floating 427 * point. 428 */ 429 return (float)(png_get_y_offset_microns(png_ptr, info_ptr) * .00003937); 430 } 431 #endif 432 433 #ifdef PNG_pHYs_SUPPORTED 434 png_uint_32 PNGAPI 435 png_get_pHYs_dpi(png_const_structrp png_ptr, png_const_inforp info_ptr, 436 png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) 437 { 438 png_uint_32 retval = 0; 439 440 png_debug1(1, "in %s retrieval function", "pHYs"); 441 442 if (png_ptr != NULL && info_ptr != NULL && 443 (info_ptr->valid & PNG_INFO_pHYs) != 0) 444 { 445 if (res_x != NULL) 446 { 447 *res_x = info_ptr->x_pixels_per_unit; 448 retval |= PNG_INFO_pHYs; 449 } 450 451 if (res_y != NULL) 452 { 453 *res_y = info_ptr->y_pixels_per_unit; 454 retval |= PNG_INFO_pHYs; 455 } 456 457 if (unit_type != NULL) 458 { 459 *unit_type = (int)info_ptr->phys_unit_type; 460 retval |= PNG_INFO_pHYs; 461 462 if (*unit_type == 1) 463 { 464 if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50); 465 if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50); 466 } 467 } 468 } 469 470 return retval; 471 } 472 #endif /* pHYs */ 473 #endif /* INCH_CONVERSIONS */ 474 475 /* png_get_channels really belongs in here, too, but it's been around longer */ 476 477 #endif /* EASY_ACCESS */ 478 479 480 png_byte PNGAPI 481 png_get_channels(png_const_structrp png_ptr, png_const_inforp info_ptr) 482 { 483 if (png_ptr != NULL && info_ptr != NULL) 484 return info_ptr->channels; 485 486 return 0; 487 } 488 489 #ifdef PNG_READ_SUPPORTED 490 png_const_bytep PNGAPI 491 png_get_signature(png_const_structrp png_ptr, png_const_inforp info_ptr) 492 { 493 if (png_ptr != NULL && info_ptr != NULL) 494 return info_ptr->signature; 495 496 return NULL; 497 } 498 #endif 499 500 #ifdef PNG_bKGD_SUPPORTED 501 png_uint_32 PNGAPI 502 png_get_bKGD(png_const_structrp png_ptr, png_inforp info_ptr, 503 png_color_16p *background) 504 { 505 png_debug1(1, "in %s retrieval function", "bKGD"); 506 507 if (png_ptr != NULL && info_ptr != NULL && 508 (info_ptr->valid & PNG_INFO_bKGD) != 0 && 509 background != NULL) 510 { 511 *background = &(info_ptr->background); 512 return PNG_INFO_bKGD; 513 } 514 515 return 0; 516 } 517 #endif 518 519 #ifdef PNG_cHRM_SUPPORTED 520 /* The XYZ APIs were added in 1.5.5 to take advantage of the code added at the 521 * same time to correct the rgb grayscale coefficient defaults obtained from the 522 * cHRM chunk in 1.5.4 523 */ 524 # ifdef PNG_FLOATING_POINT_SUPPORTED 525 png_uint_32 PNGAPI 526 png_get_cHRM(png_const_structrp png_ptr, png_const_inforp info_ptr, 527 double *whitex, double *whitey, double *redx, double *redy, 528 double *greenx, double *greeny, double *bluex, double *bluey) 529 { 530 png_debug1(1, "in %s retrieval function", "cHRM"); 531 532 /* PNGv3: this just returns the values store from the cHRM, if any. */ 533 if (png_ptr != NULL && info_ptr != NULL && 534 (info_ptr->valid & PNG_INFO_cHRM) != 0) 535 { 536 if (whitex != NULL) 537 *whitex = png_float(png_ptr, info_ptr->cHRM.whitex, "cHRM wx"); 538 if (whitey != NULL) 539 *whitey = png_float(png_ptr, info_ptr->cHRM.whitey, "cHRM wy"); 540 if (redx != NULL) 541 *redx = png_float(png_ptr, info_ptr->cHRM.redx, "cHRM rx"); 542 if (redy != NULL) 543 *redy = png_float(png_ptr, info_ptr->cHRM.redy, "cHRM ry"); 544 if (greenx != NULL) 545 *greenx = png_float(png_ptr, info_ptr->cHRM.greenx, "cHRM gx"); 546 if (greeny != NULL) 547 *greeny = png_float(png_ptr, info_ptr->cHRM.greeny, "cHRM gy"); 548 if (bluex != NULL) 549 *bluex = png_float(png_ptr, info_ptr->cHRM.bluex, "cHRM bx"); 550 if (bluey != NULL) 551 *bluey = png_float(png_ptr, info_ptr->cHRM.bluey, "cHRM by"); 552 return PNG_INFO_cHRM; 553 } 554 555 return 0; 556 } 557 558 png_uint_32 PNGAPI 559 png_get_cHRM_XYZ(png_const_structrp png_ptr, png_const_inforp info_ptr, 560 double *red_X, double *red_Y, double *red_Z, double *green_X, 561 double *green_Y, double *green_Z, double *blue_X, double *blue_Y, 562 double *blue_Z) 563 { 564 png_XYZ XYZ; 565 png_debug1(1, "in %s retrieval function", "cHRM_XYZ(float)"); 566 567 if (png_ptr != NULL && info_ptr != NULL && 568 (info_ptr->valid & PNG_INFO_cHRM) != 0 && 569 png_XYZ_from_xy(&XYZ, &info_ptr->cHRM) == 0) 570 { 571 if (red_X != NULL) 572 *red_X = png_float(png_ptr, XYZ.red_X, "cHRM red X"); 573 if (red_Y != NULL) 574 *red_Y = png_float(png_ptr, XYZ.red_Y, "cHRM red Y"); 575 if (red_Z != NULL) 576 *red_Z = png_float(png_ptr, XYZ.red_Z, "cHRM red Z"); 577 if (green_X != NULL) 578 *green_X = png_float(png_ptr, XYZ.green_X, "cHRM green X"); 579 if (green_Y != NULL) 580 *green_Y = png_float(png_ptr, XYZ.green_Y, "cHRM green Y"); 581 if (green_Z != NULL) 582 *green_Z = png_float(png_ptr, XYZ.green_Z, "cHRM green Z"); 583 if (blue_X != NULL) 584 *blue_X = png_float(png_ptr, XYZ.blue_X, "cHRM blue X"); 585 if (blue_Y != NULL) 586 *blue_Y = png_float(png_ptr, XYZ.blue_Y, "cHRM blue Y"); 587 if (blue_Z != NULL) 588 *blue_Z = png_float(png_ptr, XYZ.blue_Z, "cHRM blue Z"); 589 return PNG_INFO_cHRM; 590 } 591 592 return 0; 593 } 594 # endif 595 596 # ifdef PNG_FIXED_POINT_SUPPORTED 597 png_uint_32 PNGAPI 598 png_get_cHRM_XYZ_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr, 599 png_fixed_point *int_red_X, png_fixed_point *int_red_Y, 600 png_fixed_point *int_red_Z, png_fixed_point *int_green_X, 601 png_fixed_point *int_green_Y, png_fixed_point *int_green_Z, 602 png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y, 603 png_fixed_point *int_blue_Z) 604 { 605 png_XYZ XYZ; 606 png_debug1(1, "in %s retrieval function", "cHRM_XYZ"); 607 608 if (png_ptr != NULL && info_ptr != NULL && 609 (info_ptr->valid & PNG_INFO_cHRM) != 0U && 610 png_XYZ_from_xy(&XYZ, &info_ptr->cHRM) == 0) 611 { 612 if (int_red_X != NULL) *int_red_X = XYZ.red_X; 613 if (int_red_Y != NULL) *int_red_Y = XYZ.red_Y; 614 if (int_red_Z != NULL) *int_red_Z = XYZ.red_Z; 615 if (int_green_X != NULL) *int_green_X = XYZ.green_X; 616 if (int_green_Y != NULL) *int_green_Y = XYZ.green_Y; 617 if (int_green_Z != NULL) *int_green_Z = XYZ.green_Z; 618 if (int_blue_X != NULL) *int_blue_X = XYZ.blue_X; 619 if (int_blue_Y != NULL) *int_blue_Y = XYZ.blue_Y; 620 if (int_blue_Z != NULL) *int_blue_Z = XYZ.blue_Z; 621 return PNG_INFO_cHRM; 622 } 623 624 return 0; 625 } 626 627 png_uint_32 PNGAPI 628 png_get_cHRM_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr, 629 png_fixed_point *whitex, png_fixed_point *whitey, png_fixed_point *redx, 630 png_fixed_point *redy, png_fixed_point *greenx, png_fixed_point *greeny, 631 png_fixed_point *bluex, png_fixed_point *bluey) 632 { 633 png_debug1(1, "in %s retrieval function", "cHRM"); 634 635 /* PNGv3: this just returns the values store from the cHRM, if any. */ 636 if (png_ptr != NULL && info_ptr != NULL && 637 (info_ptr->valid & PNG_INFO_cHRM) != 0) 638 { 639 if (whitex != NULL) *whitex = info_ptr->cHRM.whitex; 640 if (whitey != NULL) *whitey = info_ptr->cHRM.whitey; 641 if (redx != NULL) *redx = info_ptr->cHRM.redx; 642 if (redy != NULL) *redy = info_ptr->cHRM.redy; 643 if (greenx != NULL) *greenx = info_ptr->cHRM.greenx; 644 if (greeny != NULL) *greeny = info_ptr->cHRM.greeny; 645 if (bluex != NULL) *bluex = info_ptr->cHRM.bluex; 646 if (bluey != NULL) *bluey = info_ptr->cHRM.bluey; 647 return PNG_INFO_cHRM; 648 } 649 650 return 0; 651 } 652 # endif 653 #endif 654 655 #ifdef PNG_gAMA_SUPPORTED 656 # ifdef PNG_FIXED_POINT_SUPPORTED 657 png_uint_32 PNGAPI 658 png_get_gAMA_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr, 659 png_fixed_point *file_gamma) 660 { 661 png_debug1(1, "in %s retrieval function", "gAMA"); 662 663 /* PNGv3 compatibility: only report gAMA if it is really present. */ 664 if (png_ptr != NULL && info_ptr != NULL && 665 (info_ptr->valid & PNG_INFO_gAMA) != 0) 666 { 667 if (file_gamma != NULL) *file_gamma = info_ptr->gamma; 668 return PNG_INFO_gAMA; 669 } 670 671 return 0; 672 } 673 # endif 674 675 # ifdef PNG_FLOATING_POINT_SUPPORTED 676 png_uint_32 PNGAPI 677 png_get_gAMA(png_const_structrp png_ptr, png_const_inforp info_ptr, 678 double *file_gamma) 679 { 680 png_debug1(1, "in %s retrieval function", "gAMA(float)"); 681 682 /* PNGv3 compatibility: only report gAMA if it is really present. */ 683 if (png_ptr != NULL && info_ptr != NULL && 684 (info_ptr->valid & PNG_INFO_gAMA) != 0) 685 { 686 if (file_gamma != NULL) 687 *file_gamma = png_float(png_ptr, info_ptr->gamma, "gAMA"); 688 689 return PNG_INFO_gAMA; 690 } 691 692 return 0; 693 } 694 # endif 695 #endif 696 697 #ifdef PNG_sRGB_SUPPORTED 698 png_uint_32 PNGAPI 699 png_get_sRGB(png_const_structrp png_ptr, png_const_inforp info_ptr, 700 int *file_srgb_intent) 701 { 702 png_debug1(1, "in %s retrieval function", "sRGB"); 703 704 if (png_ptr != NULL && info_ptr != NULL && 705 (info_ptr->valid & PNG_INFO_sRGB) != 0) 706 { 707 if (file_srgb_intent != NULL) 708 *file_srgb_intent = info_ptr->rendering_intent; 709 return PNG_INFO_sRGB; 710 } 711 712 return 0; 713 } 714 #endif 715 716 #ifdef PNG_iCCP_SUPPORTED 717 png_uint_32 PNGAPI 718 png_get_iCCP(png_const_structrp png_ptr, png_inforp info_ptr, 719 png_charpp name, int *compression_type, 720 png_bytepp profile, png_uint_32 *proflen) 721 { 722 png_debug1(1, "in %s retrieval function", "iCCP"); 723 724 if (png_ptr != NULL && info_ptr != NULL && 725 (info_ptr->valid & PNG_INFO_iCCP) != 0 && 726 name != NULL && profile != NULL && proflen != NULL) 727 { 728 *name = info_ptr->iccp_name; 729 *profile = info_ptr->iccp_profile; 730 *proflen = png_get_uint_32(info_ptr->iccp_profile); 731 /* This is somewhat irrelevant since the profile data returned has 732 * actually been uncompressed. 733 */ 734 if (compression_type != NULL) 735 *compression_type = PNG_COMPRESSION_TYPE_BASE; 736 return PNG_INFO_iCCP; 737 } 738 739 return 0; 740 741 } 742 #endif 743 744 #ifdef PNG_sPLT_SUPPORTED 745 int PNGAPI 746 png_get_sPLT(png_const_structrp png_ptr, png_inforp info_ptr, 747 png_sPLT_tpp spalettes) 748 { 749 png_debug1(1, "in %s retrieval function", "sPLT"); 750 751 if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL) 752 { 753 *spalettes = info_ptr->splt_palettes; 754 return info_ptr->splt_palettes_num; 755 } 756 757 return 0; 758 } 759 #endif 760 761 #ifdef PNG_cICP_SUPPORTED 762 png_uint_32 PNGAPI 763 png_get_cICP(png_const_structrp png_ptr, 764 png_const_inforp info_ptr, png_bytep colour_primaries, 765 png_bytep transfer_function, png_bytep matrix_coefficients, 766 png_bytep video_full_range_flag) 767 { 768 png_debug1(1, "in %s retrieval function", "cICP"); 769 770 if (png_ptr != NULL && info_ptr != NULL && 771 (info_ptr->valid & PNG_INFO_cICP) != 0 && 772 colour_primaries != NULL && transfer_function != NULL && 773 matrix_coefficients != NULL && video_full_range_flag != NULL) 774 { 775 *colour_primaries = info_ptr->cicp_colour_primaries; 776 *transfer_function = info_ptr->cicp_transfer_function; 777 *matrix_coefficients = info_ptr->cicp_matrix_coefficients; 778 *video_full_range_flag = info_ptr->cicp_video_full_range_flag; 779 return (PNG_INFO_cICP); 780 } 781 782 return 0; 783 } 784 #endif 785 786 #ifdef PNG_cLLI_SUPPORTED 787 # ifdef PNG_FIXED_POINT_SUPPORTED 788 png_uint_32 PNGAPI 789 png_get_cLLI_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr, 790 png_uint_32p maxCLL, 791 png_uint_32p maxFALL) 792 { 793 png_debug1(1, "in %s retrieval function", "cLLI"); 794 795 if (png_ptr != NULL && info_ptr != NULL && 796 (info_ptr->valid & PNG_INFO_cLLI) != 0) 797 { 798 if (maxCLL != NULL) *maxCLL = info_ptr->maxCLL; 799 if (maxFALL != NULL) *maxFALL = info_ptr->maxFALL; 800 return PNG_INFO_cLLI; 801 } 802 803 return 0; 804 } 805 # endif 806 807 # ifdef PNG_FLOATING_POINT_SUPPORTED 808 png_uint_32 PNGAPI 809 png_get_cLLI(png_const_structrp png_ptr, png_const_inforp info_ptr, 810 double *maxCLL, double *maxFALL) 811 { 812 png_debug1(1, "in %s retrieval function", "cLLI(float)"); 813 814 if (png_ptr != NULL && info_ptr != NULL && 815 (info_ptr->valid & PNG_INFO_cLLI) != 0) 816 { 817 if (maxCLL != NULL) *maxCLL = info_ptr->maxCLL * .0001; 818 if (maxFALL != NULL) *maxFALL = info_ptr->maxFALL * .0001; 819 return PNG_INFO_cLLI; 820 } 821 822 return 0; 823 } 824 # endif 825 #endif /* cLLI */ 826 827 #ifdef PNG_mDCV_SUPPORTED 828 # ifdef PNG_FIXED_POINT_SUPPORTED 829 png_uint_32 PNGAPI 830 png_get_mDCV_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr, 831 png_fixed_point *white_x, png_fixed_point *white_y, 832 png_fixed_point *red_x, png_fixed_point *red_y, 833 png_fixed_point *green_x, png_fixed_point *green_y, 834 png_fixed_point *blue_x, png_fixed_point *blue_y, 835 png_uint_32p mastering_maxDL, png_uint_32p mastering_minDL) 836 { 837 png_debug1(1, "in %s retrieval function", "mDCV"); 838 839 if (png_ptr != NULL && info_ptr != NULL && 840 (info_ptr->valid & PNG_INFO_mDCV) != 0) 841 { 842 if (white_x != NULL) *white_x = info_ptr->mastering_white_x * 2; 843 if (white_y != NULL) *white_y = info_ptr->mastering_white_y * 2; 844 if (red_x != NULL) *red_x = info_ptr->mastering_red_x * 2; 845 if (red_y != NULL) *red_y = info_ptr->mastering_red_y * 2; 846 if (green_x != NULL) *green_x = info_ptr->mastering_green_x * 2; 847 if (green_y != NULL) *green_y = info_ptr->mastering_green_y * 2; 848 if (blue_x != NULL) *blue_x = info_ptr->mastering_blue_x * 2; 849 if (blue_y != NULL) *blue_y = info_ptr->mastering_blue_y * 2; 850 if (mastering_maxDL != NULL) *mastering_maxDL = info_ptr->mastering_maxDL; 851 if (mastering_minDL != NULL) *mastering_minDL = info_ptr->mastering_minDL; 852 return PNG_INFO_mDCV; 853 } 854 855 return 0; 856 } 857 # endif 858 859 # ifdef PNG_FLOATING_POINT_SUPPORTED 860 png_uint_32 PNGAPI 861 png_get_mDCV(png_const_structrp png_ptr, png_const_inforp info_ptr, 862 double *white_x, double *white_y, double *red_x, double *red_y, 863 double *green_x, double *green_y, double *blue_x, double *blue_y, 864 double *mastering_maxDL, double *mastering_minDL) 865 { 866 png_debug1(1, "in %s retrieval function", "mDCV(float)"); 867 868 if (png_ptr != NULL && info_ptr != NULL && 869 (info_ptr->valid & PNG_INFO_mDCV) != 0) 870 { 871 if (white_x != NULL) *white_x = info_ptr->mastering_white_x * .00002; 872 if (white_y != NULL) *white_y = info_ptr->mastering_white_y * .00002; 873 if (red_x != NULL) *red_x = info_ptr->mastering_red_x * .00002; 874 if (red_y != NULL) *red_y = info_ptr->mastering_red_y * .00002; 875 if (green_x != NULL) *green_x = info_ptr->mastering_green_x * .00002; 876 if (green_y != NULL) *green_y = info_ptr->mastering_green_y * .00002; 877 if (blue_x != NULL) *blue_x = info_ptr->mastering_blue_x * .00002; 878 if (blue_y != NULL) *blue_y = info_ptr->mastering_blue_y * .00002; 879 if (mastering_maxDL != NULL) 880 *mastering_maxDL = info_ptr->mastering_maxDL * .0001; 881 if (mastering_minDL != NULL) 882 *mastering_minDL = info_ptr->mastering_minDL * .0001; 883 return PNG_INFO_mDCV; 884 } 885 886 return 0; 887 } 888 # endif /* FLOATING_POINT */ 889 #endif /* mDCV */ 890 891 #ifdef PNG_eXIf_SUPPORTED 892 png_uint_32 PNGAPI 893 png_get_eXIf(png_const_structrp png_ptr, png_inforp info_ptr, 894 png_bytep *exif) 895 { 896 png_warning(png_ptr, "png_get_eXIf does not work; use png_get_eXIf_1"); 897 PNG_UNUSED(info_ptr) 898 PNG_UNUSED(exif) 899 return 0; 900 } 901 902 png_uint_32 PNGAPI 903 png_get_eXIf_1(png_const_structrp png_ptr, png_const_inforp info_ptr, 904 png_uint_32 *num_exif, png_bytep *exif) 905 { 906 png_debug1(1, "in %s retrieval function", "eXIf"); 907 908 if (png_ptr != NULL && info_ptr != NULL && 909 (info_ptr->valid & PNG_INFO_eXIf) != 0 && exif != NULL) 910 { 911 *num_exif = info_ptr->num_exif; 912 *exif = info_ptr->exif; 913 return PNG_INFO_eXIf; 914 } 915 916 return 0; 917 } 918 #endif 919 920 #ifdef PNG_hIST_SUPPORTED 921 png_uint_32 PNGAPI 922 png_get_hIST(png_const_structrp png_ptr, png_inforp info_ptr, 923 png_uint_16p *hist) 924 { 925 png_debug1(1, "in %s retrieval function", "hIST"); 926 927 if (png_ptr != NULL && info_ptr != NULL && 928 (info_ptr->valid & PNG_INFO_hIST) != 0 && hist != NULL) 929 { 930 *hist = info_ptr->hist; 931 return PNG_INFO_hIST; 932 } 933 934 return 0; 935 } 936 #endif 937 938 png_uint_32 PNGAPI 939 png_get_IHDR(png_const_structrp png_ptr, png_const_inforp info_ptr, 940 png_uint_32 *width, png_uint_32 *height, int *bit_depth, 941 int *color_type, int *interlace_type, int *compression_type, 942 int *filter_type) 943 { 944 png_debug1(1, "in %s retrieval function", "IHDR"); 945 946 if (png_ptr == NULL || info_ptr == NULL) 947 return 0; 948 949 if (width != NULL) 950 *width = info_ptr->width; 951 952 if (height != NULL) 953 *height = info_ptr->height; 954 955 if (bit_depth != NULL) 956 *bit_depth = info_ptr->bit_depth; 957 958 if (color_type != NULL) 959 *color_type = info_ptr->color_type; 960 961 if (compression_type != NULL) 962 *compression_type = info_ptr->compression_type; 963 964 if (filter_type != NULL) 965 *filter_type = info_ptr->filter_type; 966 967 if (interlace_type != NULL) 968 *interlace_type = info_ptr->interlace_type; 969 970 /* This is redundant if we can be sure that the info_ptr values were all 971 * assigned in png_set_IHDR(). We do the check anyhow in case an 972 * application has ignored our advice not to mess with the members 973 * of info_ptr directly. 974 */ 975 png_check_IHDR(png_ptr, info_ptr->width, info_ptr->height, 976 info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type, 977 info_ptr->compression_type, info_ptr->filter_type); 978 979 return 1; 980 } 981 982 #ifdef PNG_oFFs_SUPPORTED 983 png_uint_32 PNGAPI 984 png_get_oFFs(png_const_structrp png_ptr, png_const_inforp info_ptr, 985 png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type) 986 { 987 png_debug1(1, "in %s retrieval function", "oFFs"); 988 989 if (png_ptr != NULL && info_ptr != NULL && 990 (info_ptr->valid & PNG_INFO_oFFs) != 0 && 991 offset_x != NULL && offset_y != NULL && unit_type != NULL) 992 { 993 *offset_x = info_ptr->x_offset; 994 *offset_y = info_ptr->y_offset; 995 *unit_type = (int)info_ptr->offset_unit_type; 996 return PNG_INFO_oFFs; 997 } 998 999 return 0; 1000 } 1001 #endif 1002 1003 #ifdef PNG_pCAL_SUPPORTED 1004 png_uint_32 PNGAPI 1005 png_get_pCAL(png_const_structrp png_ptr, png_inforp info_ptr, 1006 png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams, 1007 png_charp *units, png_charpp *params) 1008 { 1009 png_debug1(1, "in %s retrieval function", "pCAL"); 1010 1011 if (png_ptr != NULL && info_ptr != NULL && 1012 (info_ptr->valid & PNG_INFO_pCAL) != 0 && 1013 purpose != NULL && X0 != NULL && X1 != NULL && type != NULL && 1014 nparams != NULL && units != NULL && params != NULL) 1015 { 1016 *purpose = info_ptr->pcal_purpose; 1017 *X0 = info_ptr->pcal_X0; 1018 *X1 = info_ptr->pcal_X1; 1019 *type = (int)info_ptr->pcal_type; 1020 *nparams = (int)info_ptr->pcal_nparams; 1021 *units = info_ptr->pcal_units; 1022 *params = info_ptr->pcal_params; 1023 return PNG_INFO_pCAL; 1024 } 1025 1026 return 0; 1027 } 1028 #endif 1029 1030 #ifdef PNG_sCAL_SUPPORTED 1031 # ifdef PNG_FIXED_POINT_SUPPORTED 1032 # if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \ 1033 defined(PNG_FLOATING_POINT_SUPPORTED) 1034 png_uint_32 PNGAPI 1035 png_get_sCAL_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr, 1036 int *unit, png_fixed_point *width, png_fixed_point *height) 1037 { 1038 png_debug1(1, "in %s retrieval function", "sCAL"); 1039 1040 if (png_ptr != NULL && info_ptr != NULL && 1041 (info_ptr->valid & PNG_INFO_sCAL) != 0) 1042 { 1043 *unit = info_ptr->scal_unit; 1044 /*TODO: make this work without FP support; the API is currently eliminated 1045 * if neither floating point APIs nor internal floating point arithmetic 1046 * are enabled. 1047 */ 1048 *width = png_fixed(png_ptr, atof(info_ptr->scal_s_width), "sCAL width"); 1049 *height = png_fixed(png_ptr, atof(info_ptr->scal_s_height), 1050 "sCAL height"); 1051 return PNG_INFO_sCAL; 1052 } 1053 1054 return 0; 1055 } 1056 # endif /* FLOATING_ARITHMETIC */ 1057 # endif /* FIXED_POINT */ 1058 # ifdef PNG_FLOATING_POINT_SUPPORTED 1059 png_uint_32 PNGAPI 1060 png_get_sCAL(png_const_structrp png_ptr, png_const_inforp info_ptr, 1061 int *unit, double *width, double *height) 1062 { 1063 png_debug1(1, "in %s retrieval function", "sCAL(float)"); 1064 1065 if (png_ptr != NULL && info_ptr != NULL && 1066 (info_ptr->valid & PNG_INFO_sCAL) != 0) 1067 { 1068 *unit = info_ptr->scal_unit; 1069 *width = atof(info_ptr->scal_s_width); 1070 *height = atof(info_ptr->scal_s_height); 1071 return PNG_INFO_sCAL; 1072 } 1073 1074 return 0; 1075 } 1076 # endif /* FLOATING POINT */ 1077 png_uint_32 PNGAPI 1078 png_get_sCAL_s(png_const_structrp png_ptr, png_const_inforp info_ptr, 1079 int *unit, png_charpp width, png_charpp height) 1080 { 1081 png_debug1(1, "in %s retrieval function", "sCAL(str)"); 1082 1083 if (png_ptr != NULL && info_ptr != NULL && 1084 (info_ptr->valid & PNG_INFO_sCAL) != 0) 1085 { 1086 *unit = info_ptr->scal_unit; 1087 *width = info_ptr->scal_s_width; 1088 *height = info_ptr->scal_s_height; 1089 return PNG_INFO_sCAL; 1090 } 1091 1092 return 0; 1093 } 1094 #endif /* sCAL */ 1095 1096 #ifdef PNG_pHYs_SUPPORTED 1097 png_uint_32 PNGAPI 1098 png_get_pHYs(png_const_structrp png_ptr, png_const_inforp info_ptr, 1099 png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) 1100 { 1101 png_uint_32 retval = 0; 1102 1103 png_debug1(1, "in %s retrieval function", "pHYs"); 1104 1105 if (png_ptr != NULL && info_ptr != NULL && 1106 (info_ptr->valid & PNG_INFO_pHYs) != 0) 1107 { 1108 if (res_x != NULL) 1109 { 1110 *res_x = info_ptr->x_pixels_per_unit; 1111 retval |= PNG_INFO_pHYs; 1112 } 1113 1114 if (res_y != NULL) 1115 { 1116 *res_y = info_ptr->y_pixels_per_unit; 1117 retval |= PNG_INFO_pHYs; 1118 } 1119 1120 if (unit_type != NULL) 1121 { 1122 *unit_type = (int)info_ptr->phys_unit_type; 1123 retval |= PNG_INFO_pHYs; 1124 } 1125 } 1126 1127 return retval; 1128 } 1129 #endif /* pHYs */ 1130 1131 png_uint_32 PNGAPI 1132 png_get_PLTE(png_const_structrp png_ptr, png_inforp info_ptr, 1133 png_colorp *palette, int *num_palette) 1134 { 1135 png_debug1(1, "in %s retrieval function", "PLTE"); 1136 1137 if (png_ptr != NULL && info_ptr != NULL && 1138 (info_ptr->valid & PNG_INFO_PLTE) != 0 && palette != NULL) 1139 { 1140 *palette = info_ptr->palette; 1141 *num_palette = info_ptr->num_palette; 1142 png_debug1(3, "num_palette = %d", *num_palette); 1143 return PNG_INFO_PLTE; 1144 } 1145 1146 return 0; 1147 } 1148 1149 #ifdef PNG_sBIT_SUPPORTED 1150 png_uint_32 PNGAPI 1151 png_get_sBIT(png_const_structrp png_ptr, png_inforp info_ptr, 1152 png_color_8p *sig_bit) 1153 { 1154 png_debug1(1, "in %s retrieval function", "sBIT"); 1155 1156 if (png_ptr != NULL && info_ptr != NULL && 1157 (info_ptr->valid & PNG_INFO_sBIT) != 0 && sig_bit != NULL) 1158 { 1159 *sig_bit = &(info_ptr->sig_bit); 1160 return PNG_INFO_sBIT; 1161 } 1162 1163 return 0; 1164 } 1165 #endif 1166 1167 #ifdef PNG_TEXT_SUPPORTED 1168 int PNGAPI 1169 png_get_text(png_const_structrp png_ptr, png_inforp info_ptr, 1170 png_textp *text_ptr, int *num_text) 1171 { 1172 if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0) 1173 { 1174 png_debug1(1, "in text retrieval function, chunk typeid = 0x%lx", 1175 (unsigned long)png_ptr->chunk_name); 1176 1177 if (text_ptr != NULL) 1178 *text_ptr = info_ptr->text; 1179 1180 if (num_text != NULL) 1181 *num_text = info_ptr->num_text; 1182 1183 return info_ptr->num_text; 1184 } 1185 1186 if (num_text != NULL) 1187 *num_text = 0; 1188 1189 return 0; 1190 } 1191 #endif 1192 1193 #ifdef PNG_tIME_SUPPORTED 1194 png_uint_32 PNGAPI 1195 png_get_tIME(png_const_structrp png_ptr, png_inforp info_ptr, 1196 png_timep *mod_time) 1197 { 1198 png_debug1(1, "in %s retrieval function", "tIME"); 1199 1200 if (png_ptr != NULL && info_ptr != NULL && 1201 (info_ptr->valid & PNG_INFO_tIME) != 0 && mod_time != NULL) 1202 { 1203 *mod_time = &(info_ptr->mod_time); 1204 return PNG_INFO_tIME; 1205 } 1206 1207 return 0; 1208 } 1209 #endif 1210 1211 #ifdef PNG_tRNS_SUPPORTED 1212 png_uint_32 PNGAPI 1213 png_get_tRNS(png_const_structrp png_ptr, png_inforp info_ptr, 1214 png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color) 1215 { 1216 png_uint_32 retval = 0; 1217 1218 png_debug1(1, "in %s retrieval function", "tRNS"); 1219 1220 if (png_ptr != NULL && info_ptr != NULL && 1221 (info_ptr->valid & PNG_INFO_tRNS) != 0) 1222 { 1223 if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) 1224 { 1225 if (trans_alpha != NULL) 1226 { 1227 *trans_alpha = info_ptr->trans_alpha; 1228 retval |= PNG_INFO_tRNS; 1229 } 1230 1231 if (trans_color != NULL) 1232 *trans_color = &(info_ptr->trans_color); 1233 } 1234 1235 else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */ 1236 { 1237 if (trans_color != NULL) 1238 { 1239 *trans_color = &(info_ptr->trans_color); 1240 retval |= PNG_INFO_tRNS; 1241 } 1242 1243 if (trans_alpha != NULL) 1244 *trans_alpha = NULL; 1245 } 1246 1247 if (num_trans != NULL) 1248 { 1249 *num_trans = info_ptr->num_trans; 1250 retval |= PNG_INFO_tRNS; 1251 } 1252 } 1253 1254 return retval; 1255 } 1256 #endif 1257 1258 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED 1259 int PNGAPI 1260 png_get_unknown_chunks(png_const_structrp png_ptr, png_inforp info_ptr, 1261 png_unknown_chunkpp unknowns) 1262 { 1263 if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL) 1264 { 1265 *unknowns = info_ptr->unknown_chunks; 1266 return info_ptr->unknown_chunks_num; 1267 } 1268 1269 return 0; 1270 } 1271 #endif 1272 1273 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED 1274 png_byte PNGAPI 1275 png_get_rgb_to_gray_status(png_const_structrp png_ptr) 1276 { 1277 return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0); 1278 } 1279 #endif 1280 1281 #ifdef PNG_USER_CHUNKS_SUPPORTED 1282 png_voidp PNGAPI 1283 png_get_user_chunk_ptr(png_const_structrp png_ptr) 1284 { 1285 return (png_ptr ? png_ptr->user_chunk_ptr : NULL); 1286 } 1287 #endif 1288 1289 size_t PNGAPI 1290 png_get_compression_buffer_size(png_const_structrp png_ptr) 1291 { 1292 if (png_ptr == NULL) 1293 return 0; 1294 1295 #ifdef PNG_WRITE_SUPPORTED 1296 if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0) 1297 #endif 1298 { 1299 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED 1300 return png_ptr->IDAT_read_size; 1301 #else 1302 return PNG_IDAT_READ_SIZE; 1303 #endif 1304 } 1305 1306 #ifdef PNG_WRITE_SUPPORTED 1307 else 1308 return png_ptr->zbuffer_size; 1309 #endif 1310 } 1311 1312 #ifdef PNG_SET_USER_LIMITS_SUPPORTED 1313 /* These functions were added to libpng 1.2.6 and were enabled 1314 * by default in libpng-1.4.0 */ 1315 png_uint_32 PNGAPI 1316 png_get_user_width_max(png_const_structrp png_ptr) 1317 { 1318 return (png_ptr ? png_ptr->user_width_max : 0); 1319 } 1320 1321 png_uint_32 PNGAPI 1322 png_get_user_height_max(png_const_structrp png_ptr) 1323 { 1324 return (png_ptr ? png_ptr->user_height_max : 0); 1325 } 1326 1327 /* This function was added to libpng 1.4.0 */ 1328 png_uint_32 PNGAPI 1329 png_get_chunk_cache_max(png_const_structrp png_ptr) 1330 { 1331 return (png_ptr ? png_ptr->user_chunk_cache_max : 0); 1332 } 1333 1334 /* This function was added to libpng 1.4.1 */ 1335 png_alloc_size_t PNGAPI 1336 png_get_chunk_malloc_max(png_const_structrp png_ptr) 1337 { 1338 return (png_ptr ? png_ptr->user_chunk_malloc_max : 0); 1339 } 1340 #endif /* SET_USER_LIMITS */ 1341 1342 /* These functions were added to libpng 1.4.0 */ 1343 #ifdef PNG_IO_STATE_SUPPORTED 1344 png_uint_32 PNGAPI 1345 png_get_io_state(png_const_structrp png_ptr) 1346 { 1347 return png_ptr->io_state; 1348 } 1349 1350 png_uint_32 PNGAPI 1351 png_get_io_chunk_type(png_const_structrp png_ptr) 1352 { 1353 return png_ptr->chunk_name; 1354 } 1355 #endif /* IO_STATE */ 1356 1357 #ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED 1358 # ifdef PNG_GET_PALETTE_MAX_SUPPORTED 1359 int PNGAPI 1360 png_get_palette_max(png_const_structp png_ptr, png_const_infop info_ptr) 1361 { 1362 if (png_ptr != NULL && info_ptr != NULL) 1363 return png_ptr->num_palette_max; 1364 1365 return -1; 1366 } 1367 # endif 1368 #endif 1369 1370 #ifdef PNG_APNG_SUPPORTED 1371 png_uint_32 PNGAPI 1372 png_get_acTL(png_structp png_ptr, png_infop info_ptr, 1373 png_uint_32 *num_frames, png_uint_32 *num_plays) 1374 { 1375 png_debug1(1, "in %s retrieval function", "acTL"); 1376 1377 if (png_ptr != NULL && info_ptr != NULL && 1378 (info_ptr->valid & PNG_INFO_acTL) != 0 && 1379 num_frames != NULL && num_plays != NULL) 1380 { 1381 *num_frames = info_ptr->num_frames; 1382 *num_plays = info_ptr->num_plays; 1383 return (1); 1384 } 1385 1386 return (0); 1387 } 1388 1389 png_uint_32 PNGAPI 1390 png_get_num_frames(png_structp png_ptr, png_infop info_ptr) 1391 { 1392 png_debug(1, "in png_get_num_frames()"); 1393 1394 if (png_ptr != NULL && info_ptr != NULL) 1395 return (info_ptr->num_frames); 1396 return (0); 1397 } 1398 1399 png_uint_32 PNGAPI 1400 png_get_num_plays(png_structp png_ptr, png_infop info_ptr) 1401 { 1402 png_debug(1, "in png_get_num_plays()"); 1403 1404 if (png_ptr != NULL && info_ptr != NULL) 1405 return (info_ptr->num_plays); 1406 return (0); 1407 } 1408 1409 png_uint_32 PNGAPI 1410 png_get_next_frame_fcTL(png_structp png_ptr, png_infop info_ptr, 1411 png_uint_32 *width, png_uint_32 *height, 1412 png_uint_32 *x_offset, png_uint_32 *y_offset, 1413 png_uint_16 *delay_num, png_uint_16 *delay_den, 1414 png_byte *dispose_op, png_byte *blend_op) 1415 { 1416 png_debug1(1, "in %s retrieval function", "fcTL"); 1417 1418 if (png_ptr != NULL && info_ptr != NULL && 1419 (info_ptr->valid & PNG_INFO_fcTL) != 0 && 1420 width != NULL && height != NULL && 1421 x_offset != NULL && y_offset != NULL && 1422 delay_num != NULL && delay_den != NULL && 1423 dispose_op != NULL && blend_op != NULL) 1424 { 1425 *width = info_ptr->next_frame_width; 1426 *height = info_ptr->next_frame_height; 1427 *x_offset = info_ptr->next_frame_x_offset; 1428 *y_offset = info_ptr->next_frame_y_offset; 1429 *delay_num = info_ptr->next_frame_delay_num; 1430 *delay_den = info_ptr->next_frame_delay_den; 1431 *dispose_op = info_ptr->next_frame_dispose_op; 1432 *blend_op = info_ptr->next_frame_blend_op; 1433 return (1); 1434 } 1435 1436 return (0); 1437 } 1438 1439 png_uint_32 PNGAPI 1440 png_get_next_frame_width(png_structp png_ptr, png_infop info_ptr) 1441 { 1442 png_debug(1, "in png_get_next_frame_width()"); 1443 1444 if (png_ptr != NULL && info_ptr != NULL) 1445 return (info_ptr->next_frame_width); 1446 return (0); 1447 } 1448 1449 png_uint_32 PNGAPI 1450 png_get_next_frame_height(png_structp png_ptr, png_infop info_ptr) 1451 { 1452 png_debug(1, "in png_get_next_frame_height()"); 1453 1454 if (png_ptr != NULL && info_ptr != NULL) 1455 return (info_ptr->next_frame_height); 1456 return (0); 1457 } 1458 1459 png_uint_32 PNGAPI 1460 png_get_next_frame_x_offset(png_structp png_ptr, png_infop info_ptr) 1461 { 1462 png_debug(1, "in png_get_next_frame_x_offset()"); 1463 1464 if (png_ptr != NULL && info_ptr != NULL) 1465 return (info_ptr->next_frame_x_offset); 1466 return (0); 1467 } 1468 1469 png_uint_32 PNGAPI 1470 png_get_next_frame_y_offset(png_structp png_ptr, png_infop info_ptr) 1471 { 1472 png_debug(1, "in png_get_next_frame_y_offset()"); 1473 1474 if (png_ptr != NULL && info_ptr != NULL) 1475 return (info_ptr->next_frame_y_offset); 1476 return (0); 1477 } 1478 1479 png_uint_16 PNGAPI 1480 png_get_next_frame_delay_num(png_structp png_ptr, png_infop info_ptr) 1481 { 1482 png_debug(1, "in png_get_next_frame_delay_num()"); 1483 1484 if (png_ptr != NULL && info_ptr != NULL) 1485 return (info_ptr->next_frame_delay_num); 1486 return (0); 1487 } 1488 1489 png_uint_16 PNGAPI 1490 png_get_next_frame_delay_den(png_structp png_ptr, png_infop info_ptr) 1491 { 1492 png_debug(1, "in png_get_next_frame_delay_den()"); 1493 1494 if (png_ptr != NULL && info_ptr != NULL) 1495 return (info_ptr->next_frame_delay_den); 1496 return (0); 1497 } 1498 1499 png_byte PNGAPI 1500 png_get_next_frame_dispose_op(png_structp png_ptr, png_infop info_ptr) 1501 { 1502 png_debug(1, "in png_get_next_frame_dispose_op()"); 1503 1504 if (png_ptr != NULL && info_ptr != NULL) 1505 return (info_ptr->next_frame_dispose_op); 1506 return (0); 1507 } 1508 1509 png_byte PNGAPI 1510 png_get_next_frame_blend_op(png_structp png_ptr, png_infop info_ptr) 1511 { 1512 png_debug(1, "in png_get_next_frame_blend_op()"); 1513 1514 if (png_ptr != NULL && info_ptr != NULL) 1515 return (info_ptr->next_frame_blend_op); 1516 return (0); 1517 } 1518 1519 png_byte PNGAPI 1520 png_get_first_frame_is_hidden(png_structp png_ptr, png_infop info_ptr) 1521 { 1522 png_debug(1, "in png_first_frame_is_hidden()"); 1523 1524 if (png_ptr != NULL) 1525 return (png_byte)(png_ptr->apng_flags & PNG_FIRST_FRAME_HIDDEN); 1526 1527 PNG_UNUSED(info_ptr) 1528 1529 return 0; 1530 } 1531 #endif /* APNG */ 1532 #endif /* READ || WRITE */