src/png/pngget.c

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