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