LCOV - code coverage report
Current view: directory - media/libpng - pngget.c (source / functions) Found Hit Coverage
Test: app.info Lines: 260 37 14.2 %
Date: 2012-06-02 Functions: 30 6 20.0 %

       1                 : 
       2                 : /* pngget.c - retrieval of values from info struct
       3                 :  *
       4                 :  * Last changed in libpng 1.5.7 [December 15, 2011]
       5                 :  * Copyright (c) 1998-2011 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                 : #include "pngpriv.h"
      16                 : 
      17                 : #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
      18                 : 
      19                 : png_uint_32 PNGAPI
      20              29 : png_get_valid(png_const_structp png_ptr, png_const_infop info_ptr,
      21                 :     png_uint_32 flag)
      22                 : {
      23              29 :    if (png_ptr != NULL && info_ptr != NULL)
      24              29 :       return(info_ptr->valid & flag);
      25                 : 
      26               0 :    return(0);
      27                 : }
      28                 : 
      29                 : png_size_t PNGAPI
      30               0 : png_get_rowbytes(png_const_structp png_ptr, png_const_infop info_ptr)
      31                 : {
      32               0 :    if (png_ptr != NULL && info_ptr != NULL)
      33               0 :       return(info_ptr->rowbytes);
      34                 : 
      35               0 :    return(0);
      36                 : }
      37                 : 
      38                 : #ifdef PNG_INFO_IMAGE_SUPPORTED
      39                 : png_bytepp PNGAPI
      40                 : png_get_rows(png_const_structp png_ptr, png_const_infop info_ptr)
      41                 : {
      42                 :    if (png_ptr != NULL && info_ptr != NULL)
      43                 :       return(info_ptr->row_pointers);
      44                 : 
      45                 :    return(0);
      46                 : }
      47                 : #endif
      48                 : 
      49                 : #ifdef PNG_EASY_ACCESS_SUPPORTED
      50                 : /* Easy access to info, added in libpng-0.99 */
      51                 : png_uint_32 PNGAPI
      52                 : png_get_image_width(png_const_structp png_ptr, png_const_infop info_ptr)
      53                 : {
      54                 :    if (png_ptr != NULL && info_ptr != NULL)
      55                 :       return info_ptr->width;
      56                 : 
      57                 :    return (0);
      58                 : }
      59                 : 
      60                 : png_uint_32 PNGAPI
      61                 : png_get_image_height(png_const_structp png_ptr, png_const_infop info_ptr)
      62                 : {
      63                 :    if (png_ptr != NULL && info_ptr != NULL)
      64                 :       return info_ptr->height;
      65                 : 
      66                 :    return (0);
      67                 : }
      68                 : 
      69                 : png_byte PNGAPI
      70                 : png_get_bit_depth(png_const_structp png_ptr, png_const_infop info_ptr)
      71                 : {
      72                 :    if (png_ptr != NULL && info_ptr != NULL)
      73                 :       return info_ptr->bit_depth;
      74                 : 
      75                 :    return (0);
      76                 : }
      77                 : 
      78                 : png_byte PNGAPI
      79                 : png_get_color_type(png_const_structp png_ptr, png_const_infop info_ptr)
      80                 : {
      81                 :    if (png_ptr != NULL && info_ptr != NULL)
      82                 :       return info_ptr->color_type;
      83                 : 
      84                 :    return (0);
      85                 : }
      86                 : 
      87                 : png_byte PNGAPI
      88                 : png_get_filter_type(png_const_structp png_ptr, png_const_infop info_ptr)
      89                 : {
      90                 :    if (png_ptr != NULL && info_ptr != NULL)
      91                 :       return info_ptr->filter_type;
      92                 : 
      93                 :    return (0);
      94                 : }
      95                 : 
      96                 : png_byte PNGAPI
      97                 : png_get_interlace_type(png_const_structp png_ptr, png_const_infop info_ptr)
      98                 : {
      99                 :    if (png_ptr != NULL && info_ptr != NULL)
     100                 :       return info_ptr->interlace_type;
     101                 : 
     102                 :    return (0);
     103                 : }
     104                 : 
     105                 : png_byte PNGAPI
     106                 : png_get_compression_type(png_const_structp png_ptr, png_const_infop info_ptr)
     107                 : {
     108                 :    if (png_ptr != NULL && info_ptr != NULL)
     109                 :       return info_ptr->compression_type;
     110                 : 
     111                 :    return (0);
     112                 : }
     113                 : 
     114                 : png_uint_32 PNGAPI
     115                 : png_get_x_pixels_per_meter(png_const_structp png_ptr, png_const_infop info_ptr)
     116                 : {
     117                 : #ifdef PNG_pHYs_SUPPORTED
     118                 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
     119                 :       {
     120                 :          png_debug1(1, "in %s retrieval function",
     121                 :              "png_get_x_pixels_per_meter");
     122                 : 
     123                 :          if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)
     124                 :             return (info_ptr->x_pixels_per_unit);
     125                 :       }
     126                 : #endif
     127                 : 
     128                 :    return (0);
     129                 : }
     130                 : 
     131                 : png_uint_32 PNGAPI
     132                 : png_get_y_pixels_per_meter(png_const_structp png_ptr, png_const_infop info_ptr)
     133                 : {
     134                 : #ifdef PNG_pHYs_SUPPORTED
     135                 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
     136                 :    {
     137                 :       png_debug1(1, "in %s retrieval function",
     138                 :           "png_get_y_pixels_per_meter");
     139                 : 
     140                 :       if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)
     141                 :          return (info_ptr->y_pixels_per_unit);
     142                 :    }
     143                 : #endif
     144                 : 
     145                 :    return (0);
     146                 : }
     147                 : 
     148                 : png_uint_32 PNGAPI
     149                 : png_get_pixels_per_meter(png_const_structp png_ptr, png_const_infop info_ptr)
     150                 : {
     151                 : #ifdef PNG_pHYs_SUPPORTED
     152                 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
     153                 :    {
     154                 :       png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");
     155                 : 
     156                 :       if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER &&
     157                 :           info_ptr->x_pixels_per_unit == info_ptr->y_pixels_per_unit)
     158                 :          return (info_ptr->x_pixels_per_unit);
     159                 :    }
     160                 : #endif
     161                 : 
     162                 :    return (0);
     163                 : }
     164                 : 
     165                 : #ifdef PNG_FLOATING_POINT_SUPPORTED
     166                 : float PNGAPI
     167                 : png_get_pixel_aspect_ratio(png_const_structp png_ptr, png_const_infop info_ptr)
     168                 : {
     169                 : #ifdef PNG_READ_pHYs_SUPPORTED
     170                 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
     171                 :    {
     172                 :       png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");
     173                 : 
     174                 :       if (info_ptr->x_pixels_per_unit != 0)
     175                 :          return ((float)((float)info_ptr->y_pixels_per_unit
     176                 :              /(float)info_ptr->x_pixels_per_unit));
     177                 :    }
     178                 : #endif
     179                 : 
     180                 :    return ((float)0.0);
     181                 : }
     182                 : #endif
     183                 : 
     184                 : #ifdef PNG_FIXED_POINT_SUPPORTED
     185                 : png_fixed_point PNGAPI
     186                 : png_get_pixel_aspect_ratio_fixed(png_const_structp png_ptr,
     187                 :     png_const_infop info_ptr)
     188                 : {
     189                 : #ifdef PNG_READ_pHYs_SUPPORTED
     190                 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)
     191                 :        && info_ptr->x_pixels_per_unit > 0 && info_ptr->y_pixels_per_unit > 0
     192                 :        && info_ptr->x_pixels_per_unit <= PNG_UINT_31_MAX
     193                 :        && info_ptr->y_pixels_per_unit <= PNG_UINT_31_MAX)
     194                 :    {
     195                 :       png_fixed_point res;
     196                 : 
     197                 :       png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio_fixed");
     198                 : 
     199                 :       /* The following casts work because a PNG 4 byte integer only has a valid
     200                 :        * range of 0..2^31-1; otherwise the cast might overflow.
     201                 :        */
     202                 :       if (png_muldiv(&res, (png_int_32)info_ptr->y_pixels_per_unit, PNG_FP_1,
     203                 :           (png_int_32)info_ptr->x_pixels_per_unit))
     204                 :          return res;
     205                 :    }
     206                 : #endif
     207                 : 
     208                 :    return 0;
     209                 : }
     210                 : #endif
     211                 : 
     212                 : png_int_32 PNGAPI
     213                 : png_get_x_offset_microns(png_const_structp png_ptr, png_const_infop info_ptr)
     214                 : {
     215                 : #ifdef PNG_oFFs_SUPPORTED
     216                 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
     217                 :    {
     218                 :       png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
     219                 : 
     220                 :       if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)
     221                 :          return (info_ptr->x_offset);
     222                 :    }
     223                 : #endif
     224                 : 
     225                 :    return (0);
     226                 : }
     227                 : 
     228                 : png_int_32 PNGAPI
     229                 : png_get_y_offset_microns(png_const_structp png_ptr, png_const_infop info_ptr)
     230                 : {
     231                 : #ifdef PNG_oFFs_SUPPORTED
     232                 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
     233                 :    {
     234                 :       png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
     235                 : 
     236                 :       if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)
     237                 :          return (info_ptr->y_offset);
     238                 :    }
     239                 : #endif
     240                 : 
     241                 :    return (0);
     242                 : }
     243                 : 
     244                 : png_int_32 PNGAPI
     245                 : png_get_x_offset_pixels(png_const_structp png_ptr, png_const_infop info_ptr)
     246                 : {
     247                 : #ifdef PNG_oFFs_SUPPORTED
     248                 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
     249                 :    {
     250                 :       png_debug1(1, "in %s retrieval function", "png_get_x_offset_pixels");
     251                 : 
     252                 :       if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)
     253                 :          return (info_ptr->x_offset);
     254                 :    }
     255                 : #endif
     256                 : 
     257                 :    return (0);
     258                 : }
     259                 : 
     260                 : png_int_32 PNGAPI
     261                 : png_get_y_offset_pixels(png_const_structp png_ptr, png_const_infop info_ptr)
     262                 : {
     263                 : #ifdef PNG_oFFs_SUPPORTED
     264                 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
     265                 :    {
     266                 :       png_debug1(1, "in %s retrieval function", "png_get_y_offset_pixels");
     267                 : 
     268                 :       if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)
     269                 :          return (info_ptr->y_offset);
     270                 :    }
     271                 : #endif
     272                 : 
     273                 :    return (0);
     274                 : }
     275                 : 
     276                 : #ifdef PNG_INCH_CONVERSIONS_SUPPORTED
     277                 : static png_uint_32
     278                 : ppi_from_ppm(png_uint_32 ppm)
     279                 : {
     280                 : #if 0
     281                 :    /* The conversion is *(2.54/100), in binary (32 digits):
     282                 :     * .00000110100000001001110101001001
     283                 :     */
     284                 :    png_uint_32 t1001, t1101;
     285                 :    ppm >>= 1;                  /* .1 */
     286                 :    t1001 = ppm + (ppm >> 3);   /* .1001 */
     287                 :    t1101 = t1001 + (ppm >> 1); /* .1101 */
     288                 :    ppm >>= 20;                 /* .000000000000000000001 */
     289                 :    t1101 += t1101 >> 15;       /* .1101000000000001101 */
     290                 :    t1001 >>= 11;               /* .000000000001001 */
     291                 :    t1001 += t1001 >> 12;       /* .000000000001001000000001001 */
     292                 :    ppm += t1001;               /* .000000000001001000001001001 */
     293                 :    ppm += t1101;               /* .110100000001001110101001001 */
     294                 :    return (ppm + 16) >> 5;/* .00000110100000001001110101001001 */
     295                 : #else
     296                 :    /* The argument is a PNG unsigned integer, so it is not permitted
     297                 :     * to be bigger than 2^31.
     298                 :     */
     299                 :    png_fixed_point result;
     300                 :    if (ppm <= PNG_UINT_31_MAX && png_muldiv(&result, (png_int_32)ppm, 127,
     301                 :        5000))
     302                 :       return result;
     303                 : 
     304                 :    /* Overflow. */
     305                 :    return 0;
     306                 : #endif
     307                 : }
     308                 : 
     309                 : png_uint_32 PNGAPI
     310                 : png_get_pixels_per_inch(png_const_structp png_ptr, png_const_infop info_ptr)
     311                 : {
     312                 :    return ppi_from_ppm(png_get_pixels_per_meter(png_ptr, info_ptr));
     313                 : }
     314                 : 
     315                 : png_uint_32 PNGAPI
     316                 : png_get_x_pixels_per_inch(png_const_structp png_ptr, png_const_infop info_ptr)
     317                 : {
     318                 :    return ppi_from_ppm(png_get_x_pixels_per_meter(png_ptr, info_ptr));
     319                 : }
     320                 : 
     321                 : png_uint_32 PNGAPI
     322                 : png_get_y_pixels_per_inch(png_const_structp png_ptr, png_const_infop info_ptr)
     323                 : {
     324                 :    return ppi_from_ppm(png_get_y_pixels_per_meter(png_ptr, info_ptr));
     325                 : }
     326                 : 
     327                 : #ifdef PNG_FIXED_POINT_SUPPORTED
     328                 : static png_fixed_point
     329                 : png_fixed_inches_from_microns(png_structp png_ptr, png_int_32 microns)
     330                 : {
     331                 :    /* Convert from metres * 1,000,000 to inches * 100,000, meters to
     332                 :     * inches is simply *(100/2.54), so we want *(10/2.54) == 500/127.
     333                 :     * Notice that this can overflow - a warning is output and 0 is
     334                 :     * returned.
     335                 :     */
     336                 :    return png_muldiv_warn(png_ptr, microns, 500, 127);
     337                 : }
     338                 : 
     339                 : png_fixed_point PNGAPI
     340                 : png_get_x_offset_inches_fixed(png_structp png_ptr,
     341                 :     png_const_infop info_ptr)
     342                 : {
     343                 :    return png_fixed_inches_from_microns(png_ptr,
     344                 :        png_get_x_offset_microns(png_ptr, info_ptr));
     345                 : }
     346                 : #endif
     347                 : 
     348                 : #ifdef PNG_FIXED_POINT_SUPPORTED
     349                 : png_fixed_point PNGAPI
     350                 : png_get_y_offset_inches_fixed(png_structp png_ptr,
     351                 :     png_const_infop info_ptr)
     352                 : {
     353                 :    return png_fixed_inches_from_microns(png_ptr,
     354                 :        png_get_y_offset_microns(png_ptr, info_ptr));
     355                 : }
     356                 : #endif
     357                 : 
     358                 : #ifdef PNG_FLOATING_POINT_SUPPORTED
     359                 : float PNGAPI
     360                 : png_get_x_offset_inches(png_const_structp png_ptr, png_const_infop info_ptr)
     361                 : {
     362                 :    /* To avoid the overflow do the conversion directly in floating
     363                 :     * point.
     364                 :     */
     365                 :    return (float)(png_get_x_offset_microns(png_ptr, info_ptr) * .00003937);
     366                 : }
     367                 : #endif
     368                 : 
     369                 : #ifdef PNG_FLOATING_POINT_SUPPORTED
     370                 : float PNGAPI
     371                 : png_get_y_offset_inches(png_const_structp png_ptr, png_const_infop info_ptr)
     372                 : {
     373                 :    /* To avoid the overflow do the conversion directly in floating
     374                 :     * point.
     375                 :     */
     376                 :    return (float)(png_get_y_offset_microns(png_ptr, info_ptr) * .00003937);
     377                 : }
     378                 : #endif
     379                 : 
     380                 : #ifdef PNG_pHYs_SUPPORTED
     381                 : png_uint_32 PNGAPI
     382                 : png_get_pHYs_dpi(png_const_structp png_ptr, png_const_infop info_ptr,
     383                 :     png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
     384                 : {
     385                 :    png_uint_32 retval = 0;
     386                 : 
     387                 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
     388                 :    {
     389                 :       png_debug1(1, "in %s retrieval function", "pHYs");
     390                 : 
     391                 :       if (res_x != NULL)
     392                 :       {
     393                 :          *res_x = info_ptr->x_pixels_per_unit;
     394                 :          retval |= PNG_INFO_pHYs;
     395                 :       }
     396                 : 
     397                 :       if (res_y != NULL)
     398                 :       {
     399                 :          *res_y = info_ptr->y_pixels_per_unit;
     400                 :          retval |= PNG_INFO_pHYs;
     401                 :       }
     402                 : 
     403                 :       if (unit_type != NULL)
     404                 :       {
     405                 :          *unit_type = (int)info_ptr->phys_unit_type;
     406                 :          retval |= PNG_INFO_pHYs;
     407                 : 
     408                 :          if (*unit_type == 1)
     409                 :          {
     410                 :             if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);
     411                 :             if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);
     412                 :          }
     413                 :       }
     414                 :    }
     415                 : 
     416                 :    return (retval);
     417                 : }
     418                 : #endif /* PNG_pHYs_SUPPORTED */
     419                 : #endif  /* PNG_INCH_CONVERSIONS_SUPPORTED */
     420                 : 
     421                 : /* png_get_channels really belongs in here, too, but it's been around longer */
     422                 : 
     423                 : #endif  /* PNG_EASY_ACCESS_SUPPORTED */
     424                 : 
     425                 : png_byte PNGAPI
     426               4 : png_get_channels(png_const_structp png_ptr, png_const_infop info_ptr)
     427                 : {
     428               4 :    if (png_ptr != NULL && info_ptr != NULL)
     429               4 :       return(info_ptr->channels);
     430                 : 
     431               0 :    return (0);
     432                 : }
     433                 : 
     434                 : png_const_bytep PNGAPI
     435               0 : png_get_signature(png_const_structp png_ptr, png_infop info_ptr)
     436                 : {
     437               0 :    if (png_ptr != NULL && info_ptr != NULL)
     438               0 :       return(info_ptr->signature);
     439                 : 
     440               0 :    return (NULL);
     441                 : }
     442                 : 
     443                 : #ifdef PNG_bKGD_SUPPORTED
     444                 : png_uint_32 PNGAPI
     445                 : png_get_bKGD(png_const_structp png_ptr, png_infop info_ptr,
     446                 :    png_color_16p *background)
     447                 : {
     448                 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)
     449                 :        && background != NULL)
     450                 :    {
     451                 :       png_debug1(1, "in %s retrieval function", "bKGD");
     452                 : 
     453                 :       *background = &(info_ptr->background);
     454                 :       return (PNG_INFO_bKGD);
     455                 :    }
     456                 : 
     457                 :    return (0);
     458                 : }
     459                 : #endif
     460                 : 
     461                 : #ifdef PNG_cHRM_SUPPORTED
     462                 : /* The XYZ APIs were added in 1.5.5 to take advantage of the code added at the
     463                 :  * same time to correct the rgb grayscale coefficient defaults obtained from the
     464                 :  * cHRM chunk in 1.5.4
     465                 :  */
     466                 : png_uint_32 PNGFAPI
     467               0 : png_get_cHRM_XYZ_fixed(png_structp png_ptr, png_const_infop info_ptr,
     468                 :     png_fixed_point *int_red_X, png_fixed_point *int_red_Y,
     469                 :     png_fixed_point *int_red_Z, png_fixed_point *int_green_X,
     470                 :     png_fixed_point *int_green_Y, png_fixed_point *int_green_Z,
     471                 :     png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y,
     472                 :     png_fixed_point *int_blue_Z)
     473                 : {
     474               0 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
     475                 :    {
     476                 :       png_xy xy;
     477                 :       png_XYZ XYZ;
     478                 : 
     479                 :       png_debug1(1, "in %s retrieval function", "cHRM_XYZ");
     480                 : 
     481               0 :       xy.whitex = info_ptr->x_white;
     482               0 :       xy.whitey = info_ptr->y_white;
     483               0 :       xy.redx = info_ptr->x_red;
     484               0 :       xy.redy = info_ptr->y_red;
     485               0 :       xy.greenx = info_ptr->x_green;
     486               0 :       xy.greeny = info_ptr->y_green;
     487               0 :       xy.bluex = info_ptr->x_blue;
     488               0 :       xy.bluey = info_ptr->y_blue;
     489                 : 
     490                 :       /* The *_checked function handles error reporting, so just return 0 if
     491                 :        * there is a failure here.
     492                 :        */
     493               0 :       if (png_XYZ_from_xy_checked(png_ptr, &XYZ, xy))
     494                 :       {
     495               0 :          if (int_red_X != NULL)
     496               0 :             *int_red_X = XYZ.redX;
     497               0 :          if (int_red_Y != NULL)
     498               0 :             *int_red_Y = XYZ.redY;
     499               0 :          if (int_red_Z != NULL)
     500               0 :             *int_red_Z = XYZ.redZ;
     501               0 :          if (int_green_X != NULL)
     502               0 :             *int_green_X = XYZ.greenX;
     503               0 :          if (int_green_Y != NULL)
     504               0 :             *int_green_Y = XYZ.greenY;
     505               0 :          if (int_green_Z != NULL)
     506               0 :             *int_green_Z = XYZ.greenZ;
     507               0 :          if (int_blue_X != NULL)
     508               0 :             *int_blue_X = XYZ.blueX;
     509               0 :          if (int_blue_Y != NULL)
     510               0 :             *int_blue_Y = XYZ.blueY;
     511               0 :          if (int_blue_Z != NULL)
     512               0 :             *int_blue_Z = XYZ.blueZ;
     513                 : 
     514               0 :          return (PNG_INFO_cHRM);
     515                 :       }
     516                 :    }
     517                 : 
     518               0 :    return (0);
     519                 : }
     520                 : 
     521                 : #  ifdef PNG_FLOATING_POINT_SUPPORTED
     522                 : png_uint_32 PNGAPI
     523               0 : png_get_cHRM(png_const_structp png_ptr, png_const_infop info_ptr,
     524                 :     double *white_x, double *white_y, double *red_x, double *red_y,
     525                 :     double *green_x, double *green_y, double *blue_x, double *blue_y)
     526                 : {
     527               0 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
     528                 :    {
     529                 :       png_debug1(1, "in %s retrieval function", "cHRM");
     530                 : 
     531               0 :       if (white_x != NULL)
     532               0 :          *white_x = png_float(png_ptr, info_ptr->x_white, "cHRM white X");
     533               0 :       if (white_y != NULL)
     534               0 :          *white_y = png_float(png_ptr, info_ptr->y_white, "cHRM white Y");
     535               0 :       if (red_x != NULL)
     536               0 :          *red_x = png_float(png_ptr, info_ptr->x_red, "cHRM red X");
     537               0 :       if (red_y != NULL)
     538               0 :          *red_y = png_float(png_ptr, info_ptr->y_red, "cHRM red Y");
     539               0 :       if (green_x != NULL)
     540               0 :          *green_x = png_float(png_ptr, info_ptr->x_green, "cHRM green X");
     541               0 :       if (green_y != NULL)
     542               0 :          *green_y = png_float(png_ptr, info_ptr->y_green, "cHRM green Y");
     543               0 :       if (blue_x != NULL)
     544               0 :          *blue_x = png_float(png_ptr, info_ptr->x_blue, "cHRM blue X");
     545               0 :       if (blue_y != NULL)
     546               0 :          *blue_y = png_float(png_ptr, info_ptr->y_blue, "cHRM blue Y");
     547               0 :       return (PNG_INFO_cHRM);
     548                 :    }
     549                 : 
     550               0 :    return (0);
     551                 : }
     552                 : 
     553                 : png_uint_32 PNGAPI
     554               0 : png_get_cHRM_XYZ(png_structp png_ptr, png_const_infop info_ptr,
     555                 :    double *red_X, double *red_Y, double *red_Z, double *green_X,
     556                 :    double *green_Y, double *green_Z, double *blue_X, double *blue_Y,
     557                 :    double *blue_Z)
     558                 : {
     559                 :    png_XYZ XYZ;
     560                 : 
     561               0 :    if (png_get_cHRM_XYZ_fixed(png_ptr, info_ptr,
     562                 :       &XYZ.redX, &XYZ.redY, &XYZ.redZ, &XYZ.greenX, &XYZ.greenY, &XYZ.greenZ,
     563               0 :       &XYZ.blueX, &XYZ.blueY, &XYZ.blueZ) & PNG_INFO_cHRM)
     564                 :    {
     565               0 :       if (red_X != NULL)
     566               0 :          *red_X = png_float(png_ptr, XYZ.redX, "cHRM red X");
     567               0 :       if (red_Y != NULL)
     568               0 :          *red_Y = png_float(png_ptr, XYZ.redY, "cHRM red Y");
     569               0 :       if (red_Z != NULL)
     570               0 :          *red_Z = png_float(png_ptr, XYZ.redZ, "cHRM red Z");
     571               0 :       if (green_X != NULL)
     572               0 :          *green_X = png_float(png_ptr, XYZ.greenX, "cHRM green X");
     573               0 :       if (green_Y != NULL)
     574               0 :          *green_Y = png_float(png_ptr, XYZ.greenY, "cHRM green Y");
     575               0 :       if (green_Z != NULL)
     576               0 :          *green_Z = png_float(png_ptr, XYZ.greenZ, "cHRM green Z");
     577               0 :       if (blue_X != NULL)
     578               0 :          *blue_X = png_float(png_ptr, XYZ.blueX, "cHRM blue X");
     579               0 :       if (blue_Y != NULL)
     580               0 :          *blue_Y = png_float(png_ptr, XYZ.blueY, "cHRM blue Y");
     581               0 :       if (blue_Z != NULL)
     582               0 :          *blue_Z = png_float(png_ptr, XYZ.blueZ, "cHRM blue Z");
     583               0 :       return (PNG_INFO_cHRM);
     584                 :    }
     585                 : 
     586               0 :    return (0);
     587                 : }
     588                 : #  endif
     589                 : 
     590                 : #  ifdef PNG_FIXED_POINT_SUPPORTED
     591                 : png_uint_32 PNGAPI
     592               0 : png_get_cHRM_fixed(png_const_structp png_ptr, png_const_infop info_ptr,
     593                 :     png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x,
     594                 :     png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y,
     595                 :     png_fixed_point *blue_x, png_fixed_point *blue_y)
     596                 : {
     597                 :    png_debug1(1, "in %s retrieval function", "cHRM");
     598                 : 
     599               0 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
     600                 :    {
     601               0 :       if (white_x != NULL)
     602               0 :          *white_x = info_ptr->x_white;
     603               0 :       if (white_y != NULL)
     604               0 :          *white_y = info_ptr->y_white;
     605               0 :       if (red_x != NULL)
     606               0 :          *red_x = info_ptr->x_red;
     607               0 :       if (red_y != NULL)
     608               0 :          *red_y = info_ptr->y_red;
     609               0 :       if (green_x != NULL)
     610               0 :          *green_x = info_ptr->x_green;
     611               0 :       if (green_y != NULL)
     612               0 :          *green_y = info_ptr->y_green;
     613               0 :       if (blue_x != NULL)
     614               0 :          *blue_x = info_ptr->x_blue;
     615               0 :       if (blue_y != NULL)
     616               0 :          *blue_y = info_ptr->y_blue;
     617               0 :       return (PNG_INFO_cHRM);
     618                 :    }
     619                 : 
     620               0 :    return (0);
     621                 : }
     622                 : #  endif
     623                 : #endif
     624                 : 
     625                 : #ifdef PNG_gAMA_SUPPORTED
     626                 : png_uint_32 PNGFAPI
     627               4 : png_get_gAMA_fixed(png_const_structp png_ptr, png_const_infop info_ptr,
     628                 :     png_fixed_point *file_gamma)
     629                 : {
     630                 :    png_debug1(1, "in %s retrieval function", "gAMA");
     631                 : 
     632               4 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
     633               1 :        && file_gamma != NULL)
     634                 :    {
     635               1 :       *file_gamma = info_ptr->gamma;
     636               1 :       return (PNG_INFO_gAMA);
     637                 :    }
     638                 : 
     639               3 :    return (0);
     640                 : }
     641                 : #  ifdef PNG_FLOATING_POINT_SUPPORTED
     642                 : png_uint_32 PNGAPI
     643               4 : png_get_gAMA(png_const_structp png_ptr, png_const_infop info_ptr,
     644                 :     double *file_gamma)
     645                 : {
     646                 :    png_fixed_point igamma;
     647               4 :    png_uint_32 ok = png_get_gAMA_fixed(png_ptr, info_ptr, &igamma);
     648                 : 
     649               4 :    if (ok)
     650               1 :       *file_gamma = png_float(png_ptr, igamma, "png_get_gAMA");
     651                 : 
     652               4 :    return ok;
     653                 : }
     654                 : 
     655                 : #  endif
     656                 : #endif
     657                 : 
     658                 : #ifdef PNG_sRGB_SUPPORTED
     659                 : png_uint_32 PNGAPI
     660               0 : png_get_sRGB(png_const_structp png_ptr, png_const_infop info_ptr,
     661                 :     int *file_srgb_intent)
     662                 : {
     663                 :    png_debug1(1, "in %s retrieval function", "sRGB");
     664                 : 
     665               0 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)
     666               0 :        && file_srgb_intent != NULL)
     667                 :    {
     668               0 :       *file_srgb_intent = (int)info_ptr->srgb_intent;
     669               0 :       return (PNG_INFO_sRGB);
     670                 :    }
     671                 : 
     672               0 :    return (0);
     673                 : }
     674                 : #endif
     675                 : 
     676                 : #ifdef PNG_iCCP_SUPPORTED
     677                 : png_uint_32 PNGAPI
     678               0 : png_get_iCCP(png_const_structp png_ptr, png_const_infop info_ptr,
     679                 :     png_charpp name, int *compression_type,
     680                 :     png_bytepp profile, png_uint_32 *proflen)
     681                 : {
     682                 :    png_debug1(1, "in %s retrieval function", "iCCP");
     683                 : 
     684               0 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)
     685               0 :        && name != NULL && compression_type != NULL && profile != NULL &&
     686                 :                  proflen != NULL)
     687                 :    {
     688               0 :       *name = info_ptr->iccp_name;
     689               0 :       *profile = info_ptr->iccp_profile;
     690                 :       /* Compression_type is a dummy so the API won't have to change
     691                 :        * if we introduce multiple compression types later.
     692                 :        */
     693               0 :       *proflen = info_ptr->iccp_proflen;
     694               0 :       *compression_type = info_ptr->iccp_compression;
     695               0 :       return (PNG_INFO_iCCP);
     696                 :    }
     697                 : 
     698               0 :    return (0);
     699                 : }
     700                 : #endif
     701                 : 
     702                 : #ifdef PNG_sPLT_SUPPORTED
     703                 : png_uint_32 PNGAPI
     704                 : png_get_sPLT(png_const_structp png_ptr, png_const_infop info_ptr,
     705                 :     png_sPLT_tpp spalettes)
     706                 : {
     707                 :    if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)
     708                 :    {
     709                 :       *spalettes = info_ptr->splt_palettes;
     710                 :       return ((png_uint_32)info_ptr->splt_palettes_num);
     711                 :    }
     712                 : 
     713                 :    return (0);
     714                 : }
     715                 : #endif
     716                 : 
     717                 : #ifdef PNG_hIST_SUPPORTED
     718                 : png_uint_32 PNGAPI
     719                 : png_get_hIST(png_const_structp png_ptr, png_const_infop info_ptr,
     720                 :     png_uint_16p *hist)
     721                 : {
     722                 :    png_debug1(1, "in %s retrieval function", "hIST");
     723                 : 
     724                 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)
     725                 :        && hist != NULL)
     726                 :    {
     727                 :       *hist = info_ptr->hist;
     728                 :       return (PNG_INFO_hIST);
     729                 :    }
     730                 : 
     731                 :    return (0);
     732                 : }
     733                 : #endif
     734                 : 
     735                 : png_uint_32 PNGAPI
     736               4 : png_get_IHDR(png_structp png_ptr, png_infop info_ptr,
     737                 :     png_uint_32 *width, png_uint_32 *height, int *bit_depth,
     738                 :     int *color_type, int *interlace_type, int *compression_type,
     739                 :     int *filter_type)
     740                 : 
     741                 : {
     742                 :    png_debug1(1, "in %s retrieval function", "IHDR");
     743                 : 
     744               4 :    if (png_ptr == NULL || info_ptr == NULL || width == NULL ||
     745               4 :        height == NULL || bit_depth == NULL || color_type == NULL)
     746               0 :       return (0);
     747                 : 
     748               4 :    *width = info_ptr->width;
     749               4 :    *height = info_ptr->height;
     750               4 :    *bit_depth = info_ptr->bit_depth;
     751               4 :    *color_type = info_ptr->color_type;
     752                 : 
     753               4 :    if (compression_type != NULL)
     754               4 :       *compression_type = info_ptr->compression_type;
     755                 : 
     756               4 :    if (filter_type != NULL)
     757               4 :       *filter_type = info_ptr->filter_type;
     758                 : 
     759               4 :    if (interlace_type != NULL)
     760               4 :       *interlace_type = info_ptr->interlace_type;
     761                 : 
     762                 :    /* This is redundant if we can be sure that the info_ptr values were all
     763                 :     * assigned in png_set_IHDR().  We do the check anyhow in case an
     764                 :     * application has ignored our advice not to mess with the members
     765                 :     * of info_ptr directly.
     766                 :     */
     767              20 :    png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height,
     768              12 :        info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,
     769               8 :        info_ptr->compression_type, info_ptr->filter_type);
     770                 : 
     771               4 :    return (1);
     772                 : }
     773                 : 
     774                 : #ifdef PNG_oFFs_SUPPORTED
     775                 : png_uint_32 PNGAPI
     776                 : png_get_oFFs(png_const_structp png_ptr, png_const_infop info_ptr,
     777                 :     png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)
     778                 : {
     779                 :    png_debug1(1, "in %s retrieval function", "oFFs");
     780                 : 
     781                 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)
     782                 :        && offset_x != NULL && offset_y != NULL && unit_type != NULL)
     783                 :    {
     784                 :       *offset_x = info_ptr->x_offset;
     785                 :       *offset_y = info_ptr->y_offset;
     786                 :       *unit_type = (int)info_ptr->offset_unit_type;
     787                 :       return (PNG_INFO_oFFs);
     788                 :    }
     789                 : 
     790                 :    return (0);
     791                 : }
     792                 : #endif
     793                 : 
     794                 : #ifdef PNG_pCAL_SUPPORTED
     795                 : png_uint_32 PNGAPI
     796                 : png_get_pCAL(png_const_structp png_ptr, png_const_infop info_ptr,
     797                 :     png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,
     798                 :     png_charp *units, png_charpp *params)
     799                 : {
     800                 :    png_debug1(1, "in %s retrieval function", "pCAL");
     801                 : 
     802                 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)
     803                 :        && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
     804                 :        nparams != NULL && units != NULL && params != NULL)
     805                 :    {
     806                 :       *purpose = info_ptr->pcal_purpose;
     807                 :       *X0 = info_ptr->pcal_X0;
     808                 :       *X1 = info_ptr->pcal_X1;
     809                 :       *type = (int)info_ptr->pcal_type;
     810                 :       *nparams = (int)info_ptr->pcal_nparams;
     811                 :       *units = info_ptr->pcal_units;
     812                 :       *params = info_ptr->pcal_params;
     813                 :       return (PNG_INFO_pCAL);
     814                 :    }
     815                 : 
     816                 :    return (0);
     817                 : }
     818                 : #endif
     819                 : 
     820                 : #ifdef PNG_sCAL_SUPPORTED
     821                 : #  ifdef PNG_FIXED_POINT_SUPPORTED
     822                 : #    ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
     823                 : png_uint_32 PNGAPI
     824                 : png_get_sCAL_fixed(png_structp png_ptr, png_const_infop info_ptr,
     825                 :     int *unit, png_fixed_point *width, png_fixed_point *height)
     826                 : {
     827                 :    if (png_ptr != NULL && info_ptr != NULL &&
     828                 :        (info_ptr->valid & PNG_INFO_sCAL))
     829                 :    {
     830                 :       *unit = info_ptr->scal_unit;
     831                 :       /*TODO: make this work without FP support */
     832                 :       *width = png_fixed(png_ptr, atof(info_ptr->scal_s_width), "sCAL width");
     833                 :       *height = png_fixed(png_ptr, atof(info_ptr->scal_s_height),
     834                 :          "sCAL height");
     835                 :       return (PNG_INFO_sCAL);
     836                 :    }
     837                 : 
     838                 :    return(0);
     839                 : }
     840                 : #    endif /* FLOATING_ARITHMETIC */
     841                 : #  endif /* FIXED_POINT */
     842                 : #  ifdef PNG_FLOATING_POINT_SUPPORTED
     843                 : png_uint_32 PNGAPI
     844                 : png_get_sCAL(png_const_structp png_ptr, png_const_infop info_ptr,
     845                 :     int *unit, double *width, double *height)
     846                 : {
     847                 :    if (png_ptr != NULL && info_ptr != NULL &&
     848                 :        (info_ptr->valid & PNG_INFO_sCAL))
     849                 :    {
     850                 :       *unit = info_ptr->scal_unit;
     851                 :       *width = atof(info_ptr->scal_s_width);
     852                 :       *height = atof(info_ptr->scal_s_height);
     853                 :       return (PNG_INFO_sCAL);
     854                 :    }
     855                 : 
     856                 :    return(0);
     857                 : }
     858                 : #  endif /* FLOATING POINT */
     859                 : png_uint_32 PNGAPI
     860                 : png_get_sCAL_s(png_const_structp png_ptr, png_const_infop info_ptr,
     861                 :     int *unit, png_charpp width, png_charpp height)
     862                 : {
     863                 :    if (png_ptr != NULL && info_ptr != NULL &&
     864                 :        (info_ptr->valid & PNG_INFO_sCAL))
     865                 :    {
     866                 :       *unit = info_ptr->scal_unit;
     867                 :       *width = info_ptr->scal_s_width;
     868                 :       *height = info_ptr->scal_s_height;
     869                 :       return (PNG_INFO_sCAL);
     870                 :    }
     871                 : 
     872                 :    return(0);
     873                 : }
     874                 : #endif /* sCAL */
     875                 : 
     876                 : #ifdef PNG_pHYs_SUPPORTED
     877                 : png_uint_32 PNGAPI
     878                 : png_get_pHYs(png_const_structp png_ptr, png_const_infop info_ptr,
     879                 :     png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
     880                 : {
     881                 :    png_uint_32 retval = 0;
     882                 : 
     883                 :    png_debug1(1, "in %s retrieval function", "pHYs");
     884                 : 
     885                 :    if (png_ptr != NULL && info_ptr != NULL &&
     886                 :        (info_ptr->valid & PNG_INFO_pHYs))
     887                 :    {
     888                 :       if (res_x != NULL)
     889                 :       {
     890                 :          *res_x = info_ptr->x_pixels_per_unit;
     891                 :          retval |= PNG_INFO_pHYs;
     892                 :       }
     893                 : 
     894                 :       if (res_y != NULL)
     895                 :       {
     896                 :          *res_y = info_ptr->y_pixels_per_unit;
     897                 :          retval |= PNG_INFO_pHYs;
     898                 :       }
     899                 : 
     900                 :       if (unit_type != NULL)
     901                 :       {
     902                 :          *unit_type = (int)info_ptr->phys_unit_type;
     903                 :          retval |= PNG_INFO_pHYs;
     904                 :       }
     905                 :    }
     906                 : 
     907                 :    return (retval);
     908                 : }
     909                 : #endif /* pHYs */
     910                 : 
     911                 : png_uint_32 PNGAPI
     912               0 : png_get_PLTE(png_const_structp png_ptr, png_const_infop info_ptr,
     913                 :     png_colorp *palette, int *num_palette)
     914                 : {
     915                 :    png_debug1(1, "in %s retrieval function", "PLTE");
     916                 : 
     917               0 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)
     918               0 :        && palette != NULL)
     919                 :    {
     920               0 :       *palette = info_ptr->palette;
     921               0 :       *num_palette = info_ptr->num_palette;
     922                 :       png_debug1(3, "num_palette = %d", *num_palette);
     923               0 :       return (PNG_INFO_PLTE);
     924                 :    }
     925                 : 
     926               0 :    return (0);
     927                 : }
     928                 : 
     929                 : #ifdef PNG_sBIT_SUPPORTED
     930                 : png_uint_32 PNGAPI
     931                 : png_get_sBIT(png_const_structp png_ptr, png_infop info_ptr,
     932                 :     png_color_8p *sig_bit)
     933                 : {
     934                 :    png_debug1(1, "in %s retrieval function", "sBIT");
     935                 : 
     936                 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)
     937                 :        && sig_bit != NULL)
     938                 :    {
     939                 :       *sig_bit = &(info_ptr->sig_bit);
     940                 :       return (PNG_INFO_sBIT);
     941                 :    }
     942                 : 
     943                 :    return (0);
     944                 : }
     945                 : #endif
     946                 : 
     947                 : #ifdef PNG_TEXT_SUPPORTED
     948                 : png_uint_32 PNGAPI
     949               0 : png_get_text(png_const_structp png_ptr, png_const_infop info_ptr,
     950                 :     png_textp *text_ptr, int *num_text)
     951                 : {
     952               0 :    if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
     953                 :    {
     954                 :       png_debug1(1, "in 0x%lx retrieval function",
     955                 :          (unsigned long)png_ptr->chunk_name);
     956                 : 
     957               0 :       if (text_ptr != NULL)
     958               0 :          *text_ptr = info_ptr->text;
     959                 : 
     960               0 :       if (num_text != NULL)
     961               0 :          *num_text = info_ptr->num_text;
     962                 : 
     963               0 :       return ((png_uint_32)info_ptr->num_text);
     964                 :    }
     965                 : 
     966               0 :    if (num_text != NULL)
     967               0 :       *num_text = 0;
     968                 : 
     969               0 :    return(0);
     970                 : }
     971                 : #endif
     972                 : 
     973                 : #ifdef PNG_tIME_SUPPORTED
     974                 : png_uint_32 PNGAPI
     975                 : png_get_tIME(png_const_structp png_ptr, png_infop info_ptr, png_timep *mod_time)
     976                 : {
     977                 :    png_debug1(1, "in %s retrieval function", "tIME");
     978                 : 
     979                 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)
     980                 :        && mod_time != NULL)
     981                 :    {
     982                 :       *mod_time = &(info_ptr->mod_time);
     983                 :       return (PNG_INFO_tIME);
     984                 :    }
     985                 : 
     986                 :    return (0);
     987                 : }
     988                 : #endif
     989                 : 
     990                 : #ifdef PNG_tRNS_SUPPORTED
     991                 : png_uint_32 PNGAPI
     992               0 : png_get_tRNS(png_const_structp png_ptr, png_infop info_ptr,
     993                 :     png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)
     994                 : {
     995               0 :    png_uint_32 retval = 0;
     996               0 :    if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
     997                 :    {
     998                 :       png_debug1(1, "in %s retrieval function", "tRNS");
     999                 : 
    1000               0 :       if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
    1001                 :       {
    1002               0 :          if (trans_alpha != NULL)
    1003                 :          {
    1004               0 :             *trans_alpha = info_ptr->trans_alpha;
    1005               0 :             retval |= PNG_INFO_tRNS;
    1006                 :          }
    1007                 : 
    1008               0 :          if (trans_color != NULL)
    1009               0 :             *trans_color = &(info_ptr->trans_color);
    1010                 :       }
    1011                 : 
    1012                 :       else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */
    1013                 :       {
    1014               0 :          if (trans_color != NULL)
    1015                 :          {
    1016               0 :             *trans_color = &(info_ptr->trans_color);
    1017               0 :             retval |= PNG_INFO_tRNS;
    1018                 :          }
    1019                 : 
    1020               0 :          if (trans_alpha != NULL)
    1021               0 :             *trans_alpha = NULL;
    1022                 :       }
    1023                 : 
    1024               0 :       if (num_trans != NULL)
    1025                 :       {
    1026               0 :          *num_trans = info_ptr->num_trans;
    1027               0 :          retval |= PNG_INFO_tRNS;
    1028                 :       }
    1029                 :    }
    1030                 : 
    1031               0 :    return (retval);
    1032                 : }
    1033                 : #endif
    1034                 : 
    1035                 : #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
    1036                 : int PNGAPI
    1037                 : png_get_unknown_chunks(png_const_structp png_ptr, png_const_infop info_ptr,
    1038                 :     png_unknown_chunkpp unknowns)
    1039                 : {
    1040                 :    if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)
    1041                 :    {
    1042                 :       *unknowns = info_ptr->unknown_chunks;
    1043                 :       return info_ptr->unknown_chunks_num;
    1044                 :    }
    1045                 : 
    1046                 :    return (0);
    1047                 : }
    1048                 : #endif
    1049                 : 
    1050                 : #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
    1051                 : png_byte PNGAPI
    1052                 : png_get_rgb_to_gray_status (png_const_structp png_ptr)
    1053                 : {
    1054                 :    return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0);
    1055                 : }
    1056                 : #endif
    1057                 : 
    1058                 : #ifdef PNG_USER_CHUNKS_SUPPORTED
    1059                 : png_voidp PNGAPI
    1060                 : png_get_user_chunk_ptr(png_const_structp png_ptr)
    1061                 : {
    1062                 :    return (png_ptr ? png_ptr->user_chunk_ptr : NULL);
    1063                 : }
    1064                 : #endif
    1065                 : 
    1066                 : png_size_t PNGAPI
    1067               0 : png_get_compression_buffer_size(png_const_structp png_ptr)
    1068                 : {
    1069               0 :    return (png_ptr ? png_ptr->zbuf_size : 0);
    1070                 : }
    1071                 : 
    1072                 : #ifdef PNG_SET_USER_LIMITS_SUPPORTED
    1073                 : /* These functions were added to libpng 1.2.6 and were enabled
    1074                 :  * by default in libpng-1.4.0 */
    1075                 : png_uint_32 PNGAPI
    1076                 : png_get_user_width_max (png_const_structp png_ptr)
    1077                 : {
    1078                 :    return (png_ptr ? png_ptr->user_width_max : 0);
    1079                 : }
    1080                 : 
    1081                 : png_uint_32 PNGAPI
    1082                 : png_get_user_height_max (png_const_structp png_ptr)
    1083                 : {
    1084                 :    return (png_ptr ? png_ptr->user_height_max : 0);
    1085                 : }
    1086                 : 
    1087                 : /* This function was added to libpng 1.4.0 */
    1088                 : png_uint_32 PNGAPI
    1089                 : png_get_chunk_cache_max (png_const_structp png_ptr)
    1090                 : {
    1091                 :    return (png_ptr ? png_ptr->user_chunk_cache_max : 0);
    1092                 : }
    1093                 : 
    1094                 : /* This function was added to libpng 1.4.1 */
    1095                 : png_alloc_size_t PNGAPI
    1096                 : png_get_chunk_malloc_max (png_const_structp png_ptr)
    1097                 : {
    1098                 :    return (png_ptr ? png_ptr->user_chunk_malloc_max : 0);
    1099                 : }
    1100                 : #endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
    1101                 : 
    1102                 : /* These functions were added to libpng 1.4.0 */
    1103                 : #ifdef PNG_IO_STATE_SUPPORTED
    1104                 : png_uint_32 PNGAPI
    1105                 : png_get_io_state (png_structp png_ptr)
    1106                 : {
    1107                 :    return png_ptr->io_state;
    1108                 : }
    1109                 : 
    1110                 : png_uint_32 PNGAPI
    1111                 : png_get_io_chunk_type (png_const_structp png_ptr)
    1112                 : {
    1113                 :    return png_ptr->chunk_name;
    1114                 : }
    1115                 : 
    1116                 : png_const_bytep PNGAPI
    1117                 : png_get_io_chunk_name (png_structp png_ptr)
    1118                 : {
    1119                 :    PNG_CSTRING_FROM_CHUNK(png_ptr->io_chunk_string, png_ptr->chunk_name);
    1120                 :    return png_ptr->io_chunk_string;
    1121                 : }
    1122                 : #endif /* ?PNG_IO_STATE_SUPPORTED */
    1123                 : 
    1124                 : #ifdef PNG_APNG_SUPPORTED
    1125                 : png_uint_32 PNGAPI
    1126               0 : png_get_acTL(png_structp png_ptr, png_infop info_ptr,
    1127                 :              png_uint_32 *num_frames, png_uint_32 *num_plays)
    1128                 : {
    1129                 :     png_debug1(1, "in %s retrieval function", "acTL");
    1130                 : 
    1131               0 :     if (png_ptr != NULL && info_ptr != NULL &&
    1132               0 :         (info_ptr->valid & PNG_INFO_acTL) &&
    1133               0 :         num_frames != NULL && num_plays != NULL)
    1134                 :     {
    1135               0 :         *num_frames = info_ptr->num_frames;
    1136               0 :         *num_plays = info_ptr->num_plays;
    1137               0 :         return (1);
    1138                 :     }
    1139                 : 
    1140               0 :     return (0);
    1141                 : }
    1142                 : 
    1143                 : png_uint_32 PNGAPI
    1144               0 : png_get_num_frames(png_structp png_ptr, png_infop info_ptr)
    1145                 : {
    1146                 :     png_debug(1, "in png_get_num_frames()");
    1147                 : 
    1148               0 :     if (png_ptr != NULL && info_ptr != NULL)
    1149               0 :         return (info_ptr->num_frames);
    1150               0 :     return (0);
    1151                 : }
    1152                 : 
    1153                 : png_uint_32 PNGAPI
    1154               0 : png_get_num_plays(png_structp png_ptr, png_infop info_ptr)
    1155                 : {
    1156                 :     png_debug(1, "in png_get_num_plays()");
    1157                 : 
    1158               0 :     if (png_ptr != NULL && info_ptr != NULL)
    1159               0 :         return (info_ptr->num_plays);
    1160               0 :     return (0);
    1161                 : }
    1162                 : 
    1163                 : png_uint_32 PNGAPI
    1164               0 : png_get_next_frame_fcTL(png_structp png_ptr, png_infop info_ptr,
    1165                 :              png_uint_32 *width, png_uint_32 *height,
    1166                 :              png_uint_32 *x_offset, png_uint_32 *y_offset,
    1167                 :              png_uint_16 *delay_num, png_uint_16 *delay_den,
    1168                 :              png_byte *dispose_op, png_byte *blend_op)
    1169                 : {
    1170                 :     png_debug1(1, "in %s retrieval function", "fcTL");
    1171                 : 
    1172               0 :     if (png_ptr != NULL && info_ptr != NULL &&
    1173               0 :         (info_ptr->valid & PNG_INFO_fcTL) &&
    1174               0 :         width != NULL && height != NULL &&
    1175               0 :         x_offset != NULL && x_offset != NULL &&
    1176               0 :         delay_num != NULL && delay_den != NULL &&
    1177               0 :         dispose_op != NULL && blend_op != NULL)
    1178                 :     {
    1179               0 :         *width = info_ptr->next_frame_width;
    1180               0 :         *height = info_ptr->next_frame_height;
    1181               0 :         *x_offset = info_ptr->next_frame_x_offset;
    1182               0 :         *y_offset = info_ptr->next_frame_y_offset;
    1183               0 :         *delay_num = info_ptr->next_frame_delay_num;
    1184               0 :         *delay_den = info_ptr->next_frame_delay_den;
    1185               0 :         *dispose_op = info_ptr->next_frame_dispose_op;
    1186               0 :         *blend_op = info_ptr->next_frame_blend_op;
    1187               0 :         return (1);
    1188                 :     }
    1189                 : 
    1190               0 :     return (0);
    1191                 : }
    1192                 : 
    1193                 : png_uint_32 PNGAPI
    1194               0 : png_get_next_frame_width(png_structp png_ptr, png_infop info_ptr)
    1195                 : {
    1196                 :     png_debug(1, "in png_get_next_frame_width()");
    1197                 : 
    1198               0 :     if (png_ptr != NULL && info_ptr != NULL)
    1199               0 :         return (info_ptr->next_frame_width);
    1200               0 :     return (0);
    1201                 : }
    1202                 : 
    1203                 : png_uint_32 PNGAPI
    1204               0 : png_get_next_frame_height(png_structp png_ptr, png_infop info_ptr)
    1205                 : {
    1206                 :     png_debug(1, "in png_get_next_frame_height()");
    1207                 : 
    1208               0 :     if (png_ptr != NULL && info_ptr != NULL)
    1209               0 :         return (info_ptr->next_frame_height);
    1210               0 :     return (0);
    1211                 : }
    1212                 : 
    1213                 : png_uint_32 PNGAPI
    1214               0 : png_get_next_frame_x_offset(png_structp png_ptr, png_infop info_ptr)
    1215                 : {
    1216                 :     png_debug(1, "in png_get_next_frame_x_offset()");
    1217                 : 
    1218               0 :     if (png_ptr != NULL && info_ptr != NULL)
    1219               0 :         return (info_ptr->next_frame_x_offset);
    1220               0 :     return (0);
    1221                 : }
    1222                 : 
    1223                 : png_uint_32 PNGAPI
    1224               0 : png_get_next_frame_y_offset(png_structp png_ptr, png_infop info_ptr)
    1225                 : {
    1226                 :     png_debug(1, "in png_get_next_frame_y_offset()");
    1227                 : 
    1228               0 :     if (png_ptr != NULL && info_ptr != NULL)
    1229               0 :         return (info_ptr->next_frame_y_offset);
    1230               0 :     return (0);
    1231                 : }
    1232                 : 
    1233                 : png_uint_16 PNGAPI
    1234               0 : png_get_next_frame_delay_num(png_structp png_ptr, png_infop info_ptr)
    1235                 : {
    1236                 :     png_debug(1, "in png_get_next_frame_delay_num()");
    1237                 : 
    1238               0 :     if (png_ptr != NULL && info_ptr != NULL)
    1239               0 :         return (info_ptr->next_frame_delay_num);
    1240               0 :     return (0);
    1241                 : }
    1242                 : 
    1243                 : png_uint_16 PNGAPI
    1244               0 : png_get_next_frame_delay_den(png_structp png_ptr, png_infop info_ptr)
    1245                 : {
    1246                 :     png_debug(1, "in png_get_next_frame_delay_den()");
    1247                 : 
    1248               0 :     if (png_ptr != NULL && info_ptr != NULL)
    1249               0 :         return (info_ptr->next_frame_delay_den);
    1250               0 :     return (0);
    1251                 : }
    1252                 : 
    1253                 : png_byte PNGAPI
    1254               0 : png_get_next_frame_dispose_op(png_structp png_ptr, png_infop info_ptr)
    1255                 : {
    1256                 :     png_debug(1, "in png_get_next_frame_dispose_op()");
    1257                 : 
    1258               0 :     if (png_ptr != NULL && info_ptr != NULL)
    1259               0 :         return (info_ptr->next_frame_dispose_op);
    1260               0 :     return (0);
    1261                 : }
    1262                 : 
    1263                 : png_byte PNGAPI
    1264               0 : png_get_next_frame_blend_op(png_structp png_ptr, png_infop info_ptr)
    1265                 : {
    1266                 :     png_debug(1, "in png_get_next_frame_blend_op()");
    1267                 : 
    1268               0 :     if (png_ptr != NULL && info_ptr != NULL)
    1269               0 :         return (info_ptr->next_frame_blend_op);
    1270               0 :     return (0);
    1271                 : }
    1272                 : 
    1273                 : png_byte PNGAPI
    1274               4 : png_get_first_frame_is_hidden(png_structp png_ptr, png_infop info_ptr)
    1275                 : {
    1276                 :     png_debug(1, "in png_first_frame_is_hidden()");
    1277                 : 
    1278               4 :     if (png_ptr != NULL)
    1279               4 :        return (png_byte)(png_ptr->apng_flags & PNG_FIRST_FRAME_HIDDEN);
    1280                 : 
    1281                 :     PNG_UNUSED(info_ptr)
    1282                 : 
    1283               0 :     return 0;
    1284                 : }
    1285                 : #endif /* PNG_APNG_SUPPORTED */
    1286                 : #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

Generated by: LCOV version 1.7