gtkmm-osx/trunk/libpng-1.2.5/pngget.c

   1
   2 /* pngget.c - retrieval of values from info struct
   3  *
   4  * libpng 1.2.5 - October 3, 2002
   5  * For conditions of distribution and use, see copyright notice in png.h
   6  * Copyright (c) 1998-2002 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       int pixel_depth, channels;
 544       png_uint_32 rowbytes_per_pixel;
 545
 546       png_debug1(1, "in %s retrieval function\n", "IHDR");
 547       *width = info_ptr->width;
 548       *height = info_ptr->height;
 549       *bit_depth = info_ptr->bit_depth;
 550       if (info_ptr->bit_depth < 1 || info_ptr->bit_depth > 16)
 551         png_error(png_ptr, "Invalid bit depth");
 552       *color_type = info_ptr->color_type;
 553       if (info_ptr->color_type > 6)
 554         png_error(png_ptr, "Invalid color type");
 555       if (compression_type != NULL)
 556          *compression_type = info_ptr->compression_type;
 557       if (filter_type != NULL)
 558          *filter_type = info_ptr->filter_type;
 559       if (interlace_type != NULL)
 560          *interlace_type = info_ptr->interlace_type;
 561
 562       /* check for potential overflow of rowbytes */
 563       if (*color_type == PNG_COLOR_TYPE_PALETTE)
 564          channels = 1;
 565       else if (*color_type & PNG_COLOR_MASK_COLOR)
 566          channels = 3;
 567       else
 568          channels = 1;
 569       if (*color_type & PNG_COLOR_MASK_ALPHA)
 570          channels++;
 571       pixel_depth = *bit_depth * channels;
 572       rowbytes_per_pixel = (pixel_depth + 7) >> 3;
 573       if (width == 0 || *width > PNG_MAX_UINT)
 574         png_error(png_ptr, "Invalid image width");
 575       if (height == 0 || *height > PNG_MAX_UINT)
 576         png_error(png_ptr, "Invalid image height");
 577       if (*width > PNG_MAX_UINT/rowbytes_per_pixel - 64)
 578       {
 579          png_error(png_ptr,
 580             "Width too large for libpng to process image data.");
 581       }
 582       return (1);
 583    }
 584    return (0);
 585 }
 586
 587 #if defined(PNG_oFFs_SUPPORTED)
 588 png_uint_32 PNGAPI
 589 png_get_oFFs(png_structp png_ptr, png_infop info_ptr,
 590    png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)
 591 {
 592    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)
 593       && offset_x != NULL && offset_y != NULL && unit_type != NULL)
 594    {
 595       png_debug1(1, "in %s retrieval function\n", "oFFs");
 596       *offset_x = info_ptr->x_offset;
 597       *offset_y = info_ptr->y_offset;
 598       *unit_type = (int)info_ptr->offset_unit_type;
 599       return (PNG_INFO_oFFs);
 600    }
 601    return (0);
 602 }
 603 #endif
 604
 605 #if defined(PNG_pCAL_SUPPORTED)
 606 png_uint_32 PNGAPI
 607 png_get_pCAL(png_structp png_ptr, png_infop info_ptr,
 608    png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,
 609    png_charp *units, png_charpp *params)
 610 {
 611    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)
 612       && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
 613       nparams != NULL && units != NULL && params != NULL)
 614    {
 615       png_debug1(1, "in %s retrieval function\n", "pCAL");
 616       *purpose = info_ptr->pcal_purpose;
 617       *X0 = info_ptr->pcal_X0;
 618       *X1 = info_ptr->pcal_X1;
 619       *type = (int)info_ptr->pcal_type;
 620       *nparams = (int)info_ptr->pcal_nparams;
 621       *units = info_ptr->pcal_units;
 622       *params = info_ptr->pcal_params;
 623       return (PNG_INFO_pCAL);
 624    }
 625    return (0);
 626 }
 627 #endif
 628
 629 #if defined(PNG_sCAL_SUPPORTED)
 630 #ifdef PNG_FLOATING_POINT_SUPPORTED
 631 png_uint_32 PNGAPI
 632 png_get_sCAL(png_structp png_ptr, png_infop info_ptr,
 633              int *unit, double *width, double *height)
 634 {
 635     if (png_ptr != NULL && info_ptr != NULL &&
 636        (info_ptr->valid & PNG_INFO_sCAL))
 637     {
 638         *unit = info_ptr->scal_unit;
 639         *width = info_ptr->scal_pixel_width;
 640         *height = info_ptr->scal_pixel_height;
 641         return (PNG_INFO_sCAL);
 642     }
 643     return(0);
 644 }
 645 #else
 646 #ifdef PNG_FIXED_POINT_SUPPORTED
 647 png_uint_32 PNGAPI
 648 png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr,
 649              int *unit, png_charpp width, png_charpp height)
 650 {
 651     if (png_ptr != NULL && info_ptr != NULL &&
 652        (info_ptr->valid & PNG_INFO_sCAL))
 653     {
 654         *unit = info_ptr->scal_unit;
 655         *width = info_ptr->scal_s_width;
 656         *height = info_ptr->scal_s_height;
 657         return (PNG_INFO_sCAL);
 658     }
 659     return(0);
 660 }
 661 #endif
 662 #endif
 663 #endif
 664
 665 #if defined(PNG_pHYs_SUPPORTED)
 666 png_uint_32 PNGAPI
 667 png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
 668    png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
 669 {
 670    png_uint_32 retval = 0;
 671
 672    if (png_ptr != NULL && info_ptr != NULL &&
 673       (info_ptr->valid & PNG_INFO_pHYs))
 674    {
 675       png_debug1(1, "in %s retrieval function\n", "pHYs");
 676       if (res_x != NULL)
 677       {
 678          *res_x = info_ptr->x_pixels_per_unit;
 679          retval |= PNG_INFO_pHYs;
 680       }
 681       if (res_y != NULL)
 682       {
 683          *res_y = info_ptr->y_pixels_per_unit;
 684          retval |= PNG_INFO_pHYs;
 685       }
 686       if (unit_type != NULL)
 687       {
 688          *unit_type = (int)info_ptr->phys_unit_type;
 689          retval |= PNG_INFO_pHYs;
 690       }
 691    }
 692    return (retval);
 693 }
 694 #endif
 695
 696 png_uint_32 PNGAPI
 697 png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette,
 698    int *num_palette)
 699 {
 700    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)
 701        && palette != NULL)
 702    {
 703       png_debug1(1, "in %s retrieval function\n", "PLTE");
 704       *palette = info_ptr->palette;
 705       *num_palette = info_ptr->num_palette;
 706       png_debug1(3, "num_palette = %d\n", *num_palette);
 707       return (PNG_INFO_PLTE);
 708    }
 709    return (0);
 710 }
 711
 712 #if defined(PNG_sBIT_SUPPORTED)
 713 png_uint_32 PNGAPI
 714 png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit)
 715 {
 716    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)
 717       && sig_bit != NULL)
 718    {
 719       png_debug1(1, "in %s retrieval function\n", "sBIT");
 720       *sig_bit = &(info_ptr->sig_bit);
 721       return (PNG_INFO_sBIT);
 722    }
 723    return (0);
 724 }
 725 #endif
 726
 727 #if defined(PNG_TEXT_SUPPORTED)
 728 png_uint_32 PNGAPI
 729 png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,
 730    int *num_text)
 731 {
 732    if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
 733    {
 734       png_debug1(1, "in %s retrieval function\n",
 735          (png_ptr->chunk_name[0] == '\0' ? "text"
 736              : (png_const_charp)png_ptr->chunk_name));
 737       if (text_ptr != NULL)
 738          *text_ptr = info_ptr->text;
 739       if (num_text != NULL)
 740          *num_text = info_ptr->num_text;
 741       return ((png_uint_32)info_ptr->num_text);
 742    }
 743    if (num_text != NULL)
 744      *num_text = 0;
 745    return(0);
 746 }
 747 #endif
 748
 749 #if defined(PNG_tIME_SUPPORTED)
 750 png_uint_32 PNGAPI
 751 png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time)
 752 {
 753    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)
 754        && mod_time != NULL)
 755    {
 756       png_debug1(1, "in %s retrieval function\n", "tIME");
 757       *mod_time = &(info_ptr->mod_time);
 758       return (PNG_INFO_tIME);
 759    }
 760    return (0);
 761 }
 762 #endif
 763
 764 #if defined(PNG_tRNS_SUPPORTED)
 765 png_uint_32 PNGAPI
 766 png_get_tRNS(png_structp png_ptr, png_infop info_ptr,
 767    png_bytep *trans, int *num_trans, png_color_16p *trans_values)
 768 {
 769    png_uint_32 retval = 0;
 770    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
 771    {
 772       png_debug1(1, "in %s retrieval function\n", "tRNS");
 773       if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
 774       {
 775           if (trans != NULL)
 776           {
 777              *trans = info_ptr->trans;
 778              retval |= PNG_INFO_tRNS;
 779           }
 780           if (trans_values != NULL)
 781              *trans_values = &(info_ptr->trans_values);
 782       }
 783       else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */
 784       {
 785           if (trans_values != NULL)
 786           {
 787              *trans_values = &(info_ptr->trans_values);
 788              retval |= PNG_INFO_tRNS;
 789           }
 790           if(trans != NULL)
 791              *trans = NULL;
 792       }
 793       if(num_trans != NULL)
 794       {
 795          *num_trans = info_ptr->num_trans;
 796          retval |= PNG_INFO_tRNS;
 797       }
 798    }
 799    return (retval);
 800 }
 801 #endif
 802
 803 #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
 804 png_uint_32 PNGAPI
 805 png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr,
 806              png_unknown_chunkpp unknowns)
 807 {
 808    if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)
 809      *unknowns = info_ptr->unknown_chunks;
 810    return ((png_uint_32)info_ptr->unknown_chunks_num);
 811 }
 812 #endif
 813
 814 #if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
 815 png_byte PNGAPI
 816 png_get_rgb_to_gray_status (png_structp png_ptr)
 817 {
 818    return (png_byte)(png_ptr? png_ptr->rgb_to_gray_status : 0);
 819 }
 820 #endif
 821
 822 #if defined(PNG_USER_CHUNKS_SUPPORTED)
 823 png_voidp PNGAPI
 824 png_get_user_chunk_ptr(png_structp png_ptr)
 825 {
 826    return (png_ptr? png_ptr->user_chunk_ptr : NULL);
 827 }
 828 #endif
 829
 830
 831 png_uint_32 PNGAPI
 832 png_get_compression_buffer_size(png_structp png_ptr)
 833 {
 834    return (png_uint_32)(png_ptr? png_ptr->zbuf_size : 0L);
 835 }
 836
 837
 838 #ifndef PNG_1_0_X
 839 #ifdef PNG_ASSEMBLER_CODE_SUPPORTED
 840 /* this function was added to libpng 1.2.0 and should exist by default */
 841 png_uint_32 PNGAPI
 842 png_get_asm_flags (png_structp png_ptr)
 843 {
 844     return (png_uint_32)(png_ptr? png_ptr->asm_flags : 0L);
 845 }
 846
 847 /* this function was added to libpng 1.2.0 and should exist by default */
 848 png_uint_32 PNGAPI
 849 png_get_asm_flagmask (int flag_select)
 850 {
 851     png_uint_32 settable_asm_flags = 0;
 852
 853     if (flag_select & PNG_SELECT_READ)
 854         settable_asm_flags |=
 855           PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  |
 856           PNG_ASM_FLAG_MMX_READ_INTERLACE    |
 857           PNG_ASM_FLAG_MMX_READ_FILTER_SUB   |
 858           PNG_ASM_FLAG_MMX_READ_FILTER_UP    |
 859           PNG_ASM_FLAG_MMX_READ_FILTER_AVG   |
 860           PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;
 861           /* no non-MMX flags yet */
 862
 863 #if 0
 864     /* GRR:  no write-flags yet, either, but someday... */
 865     if (flag_select & PNG_SELECT_WRITE)
 866         settable_asm_flags |=
 867           PNG_ASM_FLAG_MMX_WRITE_ [whatever] ;
 868 #endif /* 0 */
 869
 870     return settable_asm_flags;  /* _theoretically_ settable capabilities only */
 871 }
 872 #endif /* PNG_ASSEMBLER_CODE_SUPPORTED */
 873
 874
 875 #if defined(PNG_ASSEMBLER_CODE_SUPPORTED)
 876     /* GRR:  could add this:   && defined(PNG_MMX_CODE_SUPPORTED) */
 877 /* this function was added to libpng 1.2.0 */
 878 png_uint_32 PNGAPI
 879 png_get_mmx_flagmask (int flag_select, int *compilerID)
 880 {
 881     png_uint_32 settable_mmx_flags = 0;
 882
 883     if (flag_select & PNG_SELECT_READ)
 884         settable_mmx_flags |=
 885           PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  |
 886           PNG_ASM_FLAG_MMX_READ_INTERLACE    |
 887           PNG_ASM_FLAG_MMX_READ_FILTER_SUB   |
 888           PNG_ASM_FLAG_MMX_READ_FILTER_UP    |
 889           PNG_ASM_FLAG_MMX_READ_FILTER_AVG   |
 890           PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ;
 891 #if 0
 892     /* GRR:  no MMX write support yet, but someday... */
 893     if (flag_select & PNG_SELECT_WRITE)
 894         settable_mmx_flags |=
 895           PNG_ASM_FLAG_MMX_WRITE_ [whatever] ;
 896 #endif /* 0 */
 897
 898     if (compilerID != NULL) {
 899 #ifdef PNG_USE_PNGVCRD
 900         *compilerID = 1;    /* MSVC */
 901 #else
 902 #ifdef PNG_USE_PNGGCCRD
 903         *compilerID = 2;    /* gcc/gas */
 904 #else
 905         *compilerID = -1;   /* unknown (i.e., no asm/MMX code compiled) */
 906 #endif
 907 #endif
 908     }
 909
 910     return settable_mmx_flags;  /* _theoretically_ settable capabilities only */
 911 }
 912
 913 /* this function was added to libpng 1.2.0 */
 914 png_byte PNGAPI
 915 png_get_mmx_bitdepth_threshold (png_structp png_ptr)
 916 {
 917     return (png_byte)(png_ptr? png_ptr->mmx_bitdepth_threshold : 0);
 918 }
 919
 920 /* this function was added to libpng 1.2.0 */
 921 png_uint_32 PNGAPI
 922 png_get_mmx_rowbytes_threshold (png_structp png_ptr)
 923 {
 924     return (png_uint_32)(png_ptr? png_ptr->mmx_rowbytes_threshold : 0L);
 925 }
 926 #endif /* PNG_ASSEMBLER_CODE_SUPPORTED */
 927 #endif /* PNG_1_0_X */