reactos/dll/3rdparty/libpng/pngget.c

   1
   2 /* pngget.c - retrieval of values from info struct
   3  *
   4  * Last changed in libpng 1.4.2 [May 6, 2010]
   5  * Copyright (c) 1998-2010 Glenn Randers-Pehrson
   6  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
   7  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
   8  *
   9  * This code is released under the libpng license.
  10  * For conditions of distribution and use, see the disclaimer
  11  * and license in png.h
  12  *
  13  */
  14
  15 #define PNG_NO_PEDANTIC_WARNINGS
  16 #include "png.h"
  17 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  18 #include "pngpriv.h"
  19
  20 png_uint_32 PNGAPI
  21 png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag)
  22 {
  23    if (png_ptr != NULL && info_ptr != NULL)
  24       return(info_ptr->valid & flag);
  25
  26    else
  27       return(0);
  28 }
  29
  30 png_size_t PNGAPI
  31 png_get_rowbytes(png_structp png_ptr, png_infop info_ptr)
  32 {
  33    if (png_ptr != NULL && info_ptr != NULL)
  34       return(info_ptr->rowbytes);
  35
  36    else
  37       return(0);
  38 }
  39
  40 #ifdef PNG_INFO_IMAGE_SUPPORTED
  41 png_bytepp PNGAPI
  42 png_get_rows(png_structp png_ptr, png_infop info_ptr)
  43 {
  44    if (png_ptr != NULL && info_ptr != NULL)
  45       return(info_ptr->row_pointers);
  46
  47    else
  48       return(0);
  49 }
  50 #endif
  51
  52 #ifdef PNG_EASY_ACCESS_SUPPORTED
  53 /* Easy access to info, added in libpng-0.99 */
  54 png_uint_32 PNGAPI
  55 png_get_image_width(png_structp png_ptr, png_infop info_ptr)
  56 {
  57    if (png_ptr != NULL && info_ptr != NULL)
  58       return info_ptr->width;
  59
  60    return (0);
  61 }
  62
  63 png_uint_32 PNGAPI
  64 png_get_image_height(png_structp png_ptr, png_infop info_ptr)
  65 {
  66    if (png_ptr != NULL && info_ptr != NULL)
  67       return info_ptr->height;
  68
  69    return (0);
  70 }
  71
  72 png_byte PNGAPI
  73 png_get_bit_depth(png_structp png_ptr, png_infop info_ptr)
  74 {
  75    if (png_ptr != NULL && info_ptr != NULL)
  76       return info_ptr->bit_depth;
  77
  78    return (0);
  79 }
  80
  81 png_byte PNGAPI
  82 png_get_color_type(png_structp png_ptr, png_infop info_ptr)
  83 {
  84    if (png_ptr != NULL && info_ptr != NULL)
  85       return info_ptr->color_type;
  86
  87    return (0);
  88 }
  89
  90 png_byte PNGAPI
  91 png_get_filter_type(png_structp png_ptr, png_infop info_ptr)
  92 {
  93    if (png_ptr != NULL && info_ptr != NULL)
  94       return info_ptr->filter_type;
  95
  96    return (0);
  97 }
  98
  99 png_byte PNGAPI
 100 png_get_interlace_type(png_structp png_ptr, png_infop info_ptr)
 101 {
 102    if (png_ptr != NULL && info_ptr != NULL)
 103       return info_ptr->interlace_type;
 104
 105    return (0);
 106 }
 107
 108 png_byte PNGAPI
 109 png_get_compression_type(png_structp png_ptr, png_infop info_ptr)
 110 {
 111    if (png_ptr != NULL && info_ptr != NULL)
 112       return info_ptr->compression_type;
 113
 114    return (0);
 115 }
 116
 117 png_uint_32 PNGAPI
 118 png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
 119 {
 120    if (png_ptr != NULL && info_ptr != NULL)
 121 #ifdef PNG_pHYs_SUPPORTED
 122    if (info_ptr->valid & PNG_INFO_pHYs)
 123    {
 124       png_debug1(1, "in %s retrieval function", "png_get_x_pixels_per_meter");
 125
 126       if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
 127           return (0);
 128
 129       else
 130           return (info_ptr->x_pixels_per_unit);
 131    }
 132 #else
 133    return (0);
 134 #endif
 135    return (0);
 136 }
 137
 138 png_uint_32 PNGAPI
 139 png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
 140 {
 141    if (png_ptr != NULL && info_ptr != NULL)
 142 #ifdef PNG_pHYs_SUPPORTED
 143    if (info_ptr->valid & PNG_INFO_pHYs)
 144    {
 145       png_debug1(1, "in %s retrieval function", "png_get_y_pixels_per_meter");
 146
 147       if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
 148           return (0);
 149
 150       else
 151           return (info_ptr->y_pixels_per_unit);
 152    }
 153 #else
 154    return (0);
 155 #endif
 156    return (0);
 157 }
 158
 159 png_uint_32 PNGAPI
 160 png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
 161 {
 162    if (png_ptr != NULL && info_ptr != NULL)
 163 #ifdef PNG_pHYs_SUPPORTED
 164    if (info_ptr->valid & PNG_INFO_pHYs)
 165    {
 166       png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");
 167
 168       if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER ||
 169          info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit)
 170           return (0);
 171
 172       else
 173           return (info_ptr->x_pixels_per_unit);
 174    }
 175 #else
 176    return (0);
 177 #endif
 178    return (0);
 179 }
 180
 181 #ifdef PNG_FLOATING_POINT_SUPPORTED
 182 float PNGAPI
 183 png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr)
 184    {
 185    if (png_ptr != NULL && info_ptr != NULL)
 186 #ifdef PNG_pHYs_SUPPORTED
 187
 188    if (info_ptr->valid & PNG_INFO_pHYs)
 189    {
 190       png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");
 191
 192       if (info_ptr->x_pixels_per_unit == 0)
 193          return ((float)0.0);
 194
 195       else
 196          return ((float)((float)info_ptr->y_pixels_per_unit
 197             /(float)info_ptr->x_pixels_per_unit));
 198    }
 199 #else
 200       return (0.0);
 201 #endif
 202    return ((float)0.0);
 203 }
 204 #endif
 205
 206 png_int_32 PNGAPI
 207 png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr)
 208 {
 209    if (png_ptr != NULL && info_ptr != NULL)
 210 #ifdef PNG_oFFs_SUPPORTED
 211
 212    if (info_ptr->valid & PNG_INFO_oFFs)
 213    {
 214       png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
 215
 216       if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
 217           return (0);
 218
 219       else
 220           return (info_ptr->x_offset);
 221    }
 222 #else
 223       return (0);
 224 #endif
 225    return (0);
 226 }
 227
 228 png_int_32 PNGAPI
 229 png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr)
 230 {
 231    if (png_ptr != NULL && info_ptr != NULL)
 232
 233 #ifdef PNG_oFFs_SUPPORTED
 234    if (info_ptr->valid & PNG_INFO_oFFs)
 235    {
 236       png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
 237
 238       if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
 239           return (0);
 240
 241       else
 242           return (info_ptr->y_offset);
 243    }
 244 #else
 245    return (0);
 246 #endif
 247    return (0);
 248 }
 249
 250 png_int_32 PNGAPI
 251 png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr)
 252 {
 253    if (png_ptr != NULL && info_ptr != NULL)
 254
 255 #ifdef PNG_oFFs_SUPPORTED
 256    if (info_ptr->valid & PNG_INFO_oFFs)
 257    {
 258       png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
 259
 260       if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
 261           return (0);
 262
 263       else
 264           return (info_ptr->x_offset);
 265    }
 266 #else
 267    return (0);
 268 #endif
 269    return (0);
 270 }
 271
 272 png_int_32 PNGAPI
 273 png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr)
 274 {
 275    if (png_ptr != NULL && info_ptr != NULL)
 276
 277 #ifdef PNG_oFFs_SUPPORTED
 278    if (info_ptr->valid & PNG_INFO_oFFs)
 279    {
 280       png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
 281
 282       if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
 283           return (0);
 284
 285       else
 286           return (info_ptr->y_offset);
 287    }
 288 #else
 289    return (0);
 290 #endif
 291    return (0);
 292 }
 293
 294 #if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED)
 295 png_uint_32 PNGAPI
 296 png_get_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
 297 {
 298    return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr)
 299      *.0254 +.5));
 300 }
 301
 302 png_uint_32 PNGAPI
 303 png_get_x_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
 304 {
 305    return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr)
 306      *.0254 +.5));
 307 }
 308
 309 png_uint_32 PNGAPI
 310 png_get_y_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
 311 {
 312    return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr)
 313      *.0254 +.5));
 314 }
 315
 316 float PNGAPI
 317 png_get_x_offset_inches(png_structp png_ptr, png_infop info_ptr)
 318 {
 319    return ((float)png_get_x_offset_microns(png_ptr, info_ptr)
 320      *.00003937);
 321 }
 322
 323 float PNGAPI
 324 png_get_y_offset_inches(png_structp png_ptr, png_infop info_ptr)
 325 {
 326    return ((float)png_get_y_offset_microns(png_ptr, info_ptr)
 327      *.00003937);
 328 }
 329
 330 #ifdef PNG_pHYs_SUPPORTED
 331 png_uint_32 PNGAPI
 332 png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr,
 333    png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
 334 {
 335    png_uint_32 retval = 0;
 336
 337    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
 338    {
 339       png_debug1(1, "in %s retrieval function", "pHYs");
 340
 341       if (res_x != NULL)
 342       {
 343          *res_x = info_ptr->x_pixels_per_unit;
 344          retval |= PNG_INFO_pHYs;
 345       }
 346       if (res_y != NULL)
 347       {
 348          *res_y = info_ptr->y_pixels_per_unit;
 349          retval |= PNG_INFO_pHYs;
 350       }
 351       if (unit_type != NULL)
 352       {
 353          *unit_type = (int)info_ptr->phys_unit_type;
 354          retval |= PNG_INFO_pHYs;
 355          if (*unit_type == 1)
 356          {
 357             if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);
 358             if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);
 359          }
 360       }
 361    }
 362    return (retval);
 363 }
 364 #endif /* PNG_pHYs_SUPPORTED */
 365 #endif  /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */
 366
 367 /* png_get_channels really belongs in here, too, but it's been around longer */
 368
 369 #endif  /* PNG_EASY_ACCESS_SUPPORTED */
 370
 371 png_byte PNGAPI
 372 png_get_channels(png_structp png_ptr, png_infop info_ptr)
 373 {
 374    if (png_ptr != NULL && info_ptr != NULL)
 375       return(info_ptr->channels);
 376    else
 377       return (0);
 378 }
 379
 380 png_bytep PNGAPI
 381 png_get_signature(png_structp png_ptr, png_infop info_ptr)
 382 {
 383    if (png_ptr != NULL && info_ptr != NULL)
 384       return(info_ptr->signature);
 385    else
 386       return (NULL);
 387 }
 388
 389 #ifdef PNG_bKGD_SUPPORTED
 390 png_uint_32 PNGAPI
 391 png_get_bKGD(png_structp png_ptr, png_infop info_ptr,
 392    png_color_16p *background)
 393 {
 394    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)
 395       && background != NULL)
 396    {
 397       png_debug1(1, "in %s retrieval function", "bKGD");
 398
 399       *background = &(info_ptr->background);
 400       return (PNG_INFO_bKGD);
 401    }
 402    return (0);
 403 }
 404 #endif
 405
 406 #ifdef PNG_cHRM_SUPPORTED
 407 #ifdef PNG_FLOATING_POINT_SUPPORTED
 408 png_uint_32 PNGAPI
 409 png_get_cHRM(png_structp png_ptr, png_infop info_ptr,
 410    double *white_x, double *white_y, double *red_x, double *red_y,
 411    double *green_x, double *green_y, double *blue_x, double *blue_y)
 412 {
 413    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
 414    {
 415       png_debug1(1, "in %s retrieval function", "cHRM");
 416
 417       if (white_x != NULL)
 418          *white_x = (double)info_ptr->x_white;
 419       if (white_y != NULL)
 420          *white_y = (double)info_ptr->y_white;
 421       if (red_x != NULL)
 422          *red_x = (double)info_ptr->x_red;
 423       if (red_y != NULL)
 424          *red_y = (double)info_ptr->y_red;
 425       if (green_x != NULL)
 426          *green_x = (double)info_ptr->x_green;
 427       if (green_y != NULL)
 428          *green_y = (double)info_ptr->y_green;
 429       if (blue_x != NULL)
 430          *blue_x = (double)info_ptr->x_blue;
 431       if (blue_y != NULL)
 432          *blue_y = (double)info_ptr->y_blue;
 433       return (PNG_INFO_cHRM);
 434    }
 435    return (0);
 436 }
 437 #endif
 438 #ifdef PNG_FIXED_POINT_SUPPORTED
 439 png_uint_32 PNGAPI
 440 png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
 441    png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x,
 442    png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y,
 443    png_fixed_point *blue_x, png_fixed_point *blue_y)
 444 {
 445    png_debug1(1, "in %s retrieval function", "cHRM");
 446
 447    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
 448    {
 449       if (white_x != NULL)
 450          *white_x = info_ptr->int_x_white;
 451       if (white_y != NULL)
 452          *white_y = info_ptr->int_y_white;
 453       if (red_x != NULL)
 454          *red_x = info_ptr->int_x_red;
 455       if (red_y != NULL)
 456          *red_y = info_ptr->int_y_red;
 457       if (green_x != NULL)
 458          *green_x = info_ptr->int_x_green;
 459       if (green_y != NULL)
 460          *green_y = info_ptr->int_y_green;
 461       if (blue_x != NULL)
 462          *blue_x = info_ptr->int_x_blue;
 463       if (blue_y != NULL)
 464          *blue_y = info_ptr->int_y_blue;
 465       return (PNG_INFO_cHRM);
 466    }
 467    return (0);
 468 }
 469 #endif
 470 #endif
 471
 472 #ifdef PNG_gAMA_SUPPORTED
 473 #ifdef PNG_FLOATING_POINT_SUPPORTED
 474 png_uint_32 PNGAPI
 475 png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)
 476 {
 477    png_debug1(1, "in %s retrieval function", "gAMA");
 478
 479    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
 480       && file_gamma != NULL)
 481    {
 482       *file_gamma = (double)info_ptr->gamma;
 483       return (PNG_INFO_gAMA);
 484    }
 485    return (0);
 486 }
 487 #endif
 488 #ifdef PNG_FIXED_POINT_SUPPORTED
 489 png_uint_32 PNGAPI
 490 png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr,
 491     png_fixed_point *int_file_gamma)
 492 {
 493    png_debug1(1, "in %s retrieval function", "gAMA");
 494
 495    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
 496       && int_file_gamma != NULL)
 497    {
 498       *int_file_gamma = info_ptr->int_gamma;
 499       return (PNG_INFO_gAMA);
 500    }
 501    return (0);
 502 }
 503 #endif
 504 #endif
 505
 506 #ifdef PNG_sRGB_SUPPORTED
 507 png_uint_32 PNGAPI
 508 png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent)
 509 {
 510    png_debug1(1, "in %s retrieval function", "sRGB");
 511
 512    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)
 513       && file_srgb_intent != NULL)
 514    {
 515       *file_srgb_intent = (int)info_ptr->srgb_intent;
 516       return (PNG_INFO_sRGB);
 517    }
 518    return (0);
 519 }
 520 #endif
 521
 522 #ifdef PNG_iCCP_SUPPORTED
 523 png_uint_32 PNGAPI
 524 png_get_iCCP(png_structp png_ptr, png_infop info_ptr,
 525              png_charpp name, int *compression_type,
 526              png_charpp profile, png_uint_32 *proflen)
 527 {
 528    png_debug1(1, "in %s retrieval function", "iCCP");
 529
 530    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)
 531       && name != NULL && profile != NULL && proflen != NULL)
 532    {
 533       *name = info_ptr->iccp_name;
 534       *profile = info_ptr->iccp_profile;
 535       /* Compression_type is a dummy so the API won't have to change
 536        * if we introduce multiple compression types later.
 537        */
 538       *proflen = (int)info_ptr->iccp_proflen;
 539       *compression_type = (int)info_ptr->iccp_compression;
 540       return (PNG_INFO_iCCP);
 541    }
 542    return (0);
 543 }
 544 #endif
 545
 546 #ifdef PNG_sPLT_SUPPORTED
 547 png_uint_32 PNGAPI
 548 png_get_sPLT(png_structp png_ptr, png_infop info_ptr,
 549              png_sPLT_tpp spalettes)
 550 {
 551    if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)
 552    {
 553      *spalettes = info_ptr->splt_palettes;
 554      return ((png_uint_32)info_ptr->splt_palettes_num);
 555    }
 556    return (0);
 557 }
 558 #endif
 559
 560 #ifdef PNG_hIST_SUPPORTED
 561 png_uint_32 PNGAPI
 562 png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist)
 563 {
 564    png_debug1(1, "in %s retrieval function", "hIST");
 565
 566    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)
 567       && hist != NULL)
 568    {
 569       *hist = info_ptr->hist;
 570       return (PNG_INFO_hIST);
 571    }
 572    return (0);
 573 }
 574 #endif
 575
 576 png_uint_32 PNGAPI
 577 png_get_IHDR(png_structp png_ptr, png_infop info_ptr,
 578    png_uint_32 *width, png_uint_32 *height, int *bit_depth,
 579    int *color_type, int *interlace_type, int *compression_type,
 580    int *filter_type)
 581
 582 {
 583    png_debug1(1, "in %s retrieval function", "IHDR");
 584
 585    if (png_ptr == NULL || info_ptr == NULL || width == NULL ||
 586        height == NULL || bit_depth == NULL || color_type == NULL)
 587       return (0);
 588
 589    *width = info_ptr->width;
 590    *height = info_ptr->height;
 591    *bit_depth = info_ptr->bit_depth;
 592    *color_type = info_ptr->color_type;
 593
 594    if (compression_type != NULL)
 595       *compression_type = info_ptr->compression_type;
 596
 597    if (filter_type != NULL)
 598       *filter_type = info_ptr->filter_type;
 599
 600    if (interlace_type != NULL)
 601       *interlace_type = info_ptr->interlace_type;
 602
 603    /* This is redundant if we can be sure that the info_ptr values were all
 604     * assigned in png_set_IHDR().  We do the check anyhow in case an
 605     * application has ignored our advice not to mess with the members
 606     * of info_ptr directly.
 607     */
 608    png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height,
 609        info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,
 610        info_ptr->compression_type, info_ptr->filter_type);
 611
 612    return (1);
 613 }
 614
 615 #ifdef PNG_oFFs_SUPPORTED
 616 png_uint_32 PNGAPI
 617 png_get_oFFs(png_structp png_ptr, png_infop info_ptr,
 618    png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)
 619 {
 620    png_debug1(1, "in %s retrieval function", "oFFs");
 621
 622    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)
 623       && offset_x != NULL && offset_y != NULL && unit_type != NULL)
 624    {
 625       *offset_x = info_ptr->x_offset;
 626       *offset_y = info_ptr->y_offset;
 627       *unit_type = (int)info_ptr->offset_unit_type;
 628       return (PNG_INFO_oFFs);
 629    }
 630    return (0);
 631 }
 632 #endif
 633
 634 #ifdef PNG_pCAL_SUPPORTED
 635 png_uint_32 PNGAPI
 636 png_get_pCAL(png_structp png_ptr, png_infop info_ptr,
 637    png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,
 638    png_charp *units, png_charpp *params)
 639 {
 640    png_debug1(1, "in %s retrieval function", "pCAL");
 641
 642    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)
 643        && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
 644        nparams != NULL && units != NULL && params != NULL)
 645    {
 646       *purpose = info_ptr->pcal_purpose;
 647       *X0 = info_ptr->pcal_X0;
 648       *X1 = info_ptr->pcal_X1;
 649       *type = (int)info_ptr->pcal_type;
 650       *nparams = (int)info_ptr->pcal_nparams;
 651       *units = info_ptr->pcal_units;
 652       *params = info_ptr->pcal_params;
 653       return (PNG_INFO_pCAL);
 654    }
 655    return (0);
 656 }
 657 #endif
 658
 659 #ifdef PNG_sCAL_SUPPORTED
 660 #ifdef PNG_FLOATING_POINT_SUPPORTED
 661 png_uint_32 PNGAPI
 662 png_get_sCAL(png_structp png_ptr, png_infop info_ptr,
 663              int *unit, double *width, double *height)
 664 {
 665     if (png_ptr != NULL && info_ptr != NULL &&
 666         (info_ptr->valid & PNG_INFO_sCAL))
 667     {
 668         *unit = info_ptr->scal_unit;
 669         *width = info_ptr->scal_pixel_width;
 670         *height = info_ptr->scal_pixel_height;
 671         return (PNG_INFO_sCAL);
 672     }
 673     return(0);
 674 }
 675 #else
 676 #ifdef PNG_FIXED_POINT_SUPPORTED
 677 png_uint_32 PNGAPI
 678 png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr,
 679              int *unit, png_charpp width, png_charpp height)
 680 {
 681     if (png_ptr != NULL && info_ptr != NULL &&
 682         (info_ptr->valid & PNG_INFO_sCAL))
 683     {
 684         *unit = info_ptr->scal_unit;
 685         *width = info_ptr->scal_s_width;
 686         *height = info_ptr->scal_s_height;
 687         return (PNG_INFO_sCAL);
 688     }
 689     return(0);
 690 }
 691 #endif
 692 #endif
 693 #endif
 694
 695 #ifdef PNG_pHYs_SUPPORTED
 696 png_uint_32 PNGAPI
 697 png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
 698    png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
 699 {
 700    png_uint_32 retval = 0;
 701
 702    png_debug1(1, "in %s retrieval function", "pHYs");
 703
 704    if (png_ptr != NULL && info_ptr != NULL &&
 705       (info_ptr->valid & PNG_INFO_pHYs))
 706    {
 707       if (res_x != NULL)
 708       {
 709          *res_x = info_ptr->x_pixels_per_unit;
 710          retval |= PNG_INFO_pHYs;
 711       }
 712
 713       if (res_y != NULL)
 714       {
 715          *res_y = info_ptr->y_pixels_per_unit;
 716          retval |= PNG_INFO_pHYs;
 717       }
 718
 719       if (unit_type != NULL)
 720       {
 721          *unit_type = (int)info_ptr->phys_unit_type;
 722          retval |= PNG_INFO_pHYs;
 723       }
 724    }
 725    return (retval);
 726 }
 727 #endif
 728
 729 png_uint_32 PNGAPI
 730 png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette,
 731    int *num_palette)
 732 {
 733    png_debug1(1, "in %s retrieval function", "PLTE");
 734
 735    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)
 736        && palette != NULL)
 737    {
 738       *palette = info_ptr->palette;
 739       *num_palette = info_ptr->num_palette;
 740       png_debug1(3, "num_palette = %d", *num_palette);
 741       return (PNG_INFO_PLTE);
 742    }
 743    return (0);
 744 }
 745
 746 #ifdef PNG_sBIT_SUPPORTED
 747 png_uint_32 PNGAPI
 748 png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit)
 749 {
 750    png_debug1(1, "in %s retrieval function", "sBIT");
 751
 752    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)
 753       && sig_bit != NULL)
 754    {
 755       *sig_bit = &(info_ptr->sig_bit);
 756       return (PNG_INFO_sBIT);
 757    }
 758    return (0);
 759 }
 760 #endif
 761
 762 #ifdef PNG_TEXT_SUPPORTED
 763 png_uint_32 PNGAPI
 764 png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,
 765    int *num_text)
 766 {
 767    if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
 768    {
 769       png_debug1(1, "in %s retrieval function",
 770          (png_ptr->chunk_name[0] == '\0' ? "text"
 771              : (png_const_charp)png_ptr->chunk_name));
 772
 773       if (text_ptr != NULL)
 774          *text_ptr = info_ptr->text;
 775
 776       if (num_text != NULL)
 777          *num_text = info_ptr->num_text;
 778
 779       return ((png_uint_32)info_ptr->num_text);
 780    }
 781    if (num_text != NULL)
 782      *num_text = 0;
 783    return(0);
 784 }
 785 #endif
 786
 787 #ifdef PNG_tIME_SUPPORTED
 788 png_uint_32 PNGAPI
 789 png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time)
 790 {
 791    png_debug1(1, "in %s retrieval function", "tIME");
 792
 793    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)
 794        && mod_time != NULL)
 795    {
 796       *mod_time = &(info_ptr->mod_time);
 797       return (PNG_INFO_tIME);
 798    }
 799    return (0);
 800 }
 801 #endif
 802
 803 #ifdef PNG_tRNS_SUPPORTED
 804 png_uint_32 PNGAPI
 805 png_get_tRNS(png_structp png_ptr, png_infop info_ptr,
 806    png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)
 807 {
 808    png_uint_32 retval = 0;
 809    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
 810    {
 811       png_debug1(1, "in %s retrieval function", "tRNS");
 812
 813       if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
 814       {
 815           if (trans_alpha != NULL)
 816           {
 817              *trans_alpha = info_ptr->trans_alpha;
 818              retval |= PNG_INFO_tRNS;
 819           }
 820
 821           if (trans_color != NULL)
 822              *trans_color = &(info_ptr->trans_color);
 823       }
 824       else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */
 825       {
 826           if (trans_color != NULL)
 827           {
 828              *trans_color = &(info_ptr->trans_color);
 829              retval |= PNG_INFO_tRNS;
 830           }
 831
 832           if (trans_alpha != NULL)
 833              *trans_alpha = NULL;
 834       }
 835       if (num_trans != NULL)
 836       {
 837          *num_trans = info_ptr->num_trans;
 838          retval |= PNG_INFO_tRNS;
 839       }
 840    }
 841    return (retval);
 842 }
 843 #endif
 844
 845 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
 846 png_uint_32 PNGAPI
 847 png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr,
 848              png_unknown_chunkpp unknowns)
 849 {
 850    if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)
 851    {
 852      *unknowns = info_ptr->unknown_chunks;
 853      return ((png_uint_32)info_ptr->unknown_chunks_num);
 854    }
 855    return (0);
 856 }
 857 #endif
 858
 859 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
 860 png_byte PNGAPI
 861 png_get_rgb_to_gray_status (png_structp png_ptr)
 862 {
 863    return (png_byte)(png_ptr? png_ptr->rgb_to_gray_status : 0);
 864 }
 865 #endif
 866
 867 #ifdef PNG_USER_CHUNKS_SUPPORTED
 868 png_voidp PNGAPI
 869 png_get_user_chunk_ptr(png_structp png_ptr)
 870 {
 871    return (png_ptr? png_ptr->user_chunk_ptr : NULL);
 872 }
 873 #endif
 874
 875 png_size_t PNGAPI
 876 png_get_compression_buffer_size(png_structp png_ptr)
 877 {
 878    return (png_ptr ? png_ptr->zbuf_size : 0L);
 879 }
 880
 881
 882 #ifdef PNG_SET_USER_LIMITS_SUPPORTED
 883 /* These functions were added to libpng 1.2.6 and were enabled
 884  * by default in libpng-1.4.0 */
 885 png_uint_32 PNGAPI
 886 png_get_user_width_max (png_structp png_ptr)
 887 {
 888     return (png_ptr? png_ptr->user_width_max : 0);
 889 }
 890 png_uint_32 PNGAPI
 891 png_get_user_height_max (png_structp png_ptr)
 892 {
 893     return (png_ptr? png_ptr->user_height_max : 0);
 894 }
 895 /* This function was added to libpng 1.4.0 */
 896 png_uint_32 PNGAPI
 897 png_get_chunk_cache_max (png_structp png_ptr)
 898 {
 899     return (png_ptr? png_ptr->user_chunk_cache_max : 0);
 900 }
 901 /* This function was added to libpng 1.4.1 */
 902 png_alloc_size_t PNGAPI
 903 png_get_chunk_malloc_max (png_structp png_ptr)
 904 {
 905     return (png_ptr?
 906        png_ptr->user_chunk_malloc_max : 0);
 907 }
 908 #endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
 909
 910 /* These functions were added to libpng 1.4.0 */
 911 #ifdef PNG_IO_STATE_SUPPORTED
 912 png_uint_32 PNGAPI
 913 png_get_io_state (png_structp png_ptr)
 914 {
 915     return png_ptr->io_state;
 916 }
 917
 918 png_bytep PNGAPI
 919 png_get_io_chunk_name (png_structp png_ptr)
 920 {
 921    return png_ptr->chunk_name;
 922 }
 923 #endif /* ?PNG_IO_STATE_SUPPORTED */
 924
 925 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */