source/Irrlicht/libpng/pngget.c

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