git.mutantstargoat.com Git - dosrtxon/blob - libs/imago/libpng/pngget.c

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