/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/* pngget.c - retrieval of values from info struct

 *

 * This file is available under and governed by the GNU General Public

 * License version 2 only, as published by the Free Software Foundation.

 * However, the following notice accompanied the original version of this

 * file and, per its terms, should not be removed:

 *

 * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson

 *

 * This code is released under the libpng license.

 * For conditions of distribution and use, see the disclaimer

 * and license in png.h

 *

 */

#include "pngpriv.h"

#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)

png_uint_32 PNGAPI

png_get_valid(png_const_structrp png_ptr, png_const_inforp info_ptr,

    png_uint_32 flag)

{

   if (png_ptr != NULL && info_ptr != NULL)

      return(info_ptr->valid & flag);

   return(0);

}

size_t PNGAPI

png_get_rowbytes(png_const_structrp png_ptr, png_const_inforp info_ptr)

{

   if (png_ptr != NULL && info_ptr != NULL)

      return(info_ptr->rowbytes);

   return(0);

}

#ifdef PNG_INFO_IMAGE_SUPPORTED

png_bytepp PNGAPI

png_get_rows(png_const_structrp png_ptr, png_const_inforp info_ptr)

{

   if (png_ptr != NULL && info_ptr != NULL)

      return(info_ptr->row_pointers);

   return(0);

}

#endif

#ifdef PNG_EASY_ACCESS_SUPPORTED

/* Easy access to info, added in libpng-0.99 */

png_uint_32 PNGAPI

png_get_image_width(png_const_structrp png_ptr, png_const_inforp info_ptr)

{

   if (png_ptr != NULL && info_ptr != NULL)

      return info_ptr->width;

   return (0);

}

png_uint_32 PNGAPI

png_get_image_height(png_const_structrp png_ptr, png_const_inforp info_ptr)

{

   if (png_ptr != NULL && info_ptr != NULL)

      return info_ptr->height;

   return (0);

}

png_byte PNGAPI

png_get_bit_depth(png_const_structrp png_ptr, png_const_inforp info_ptr)

{

   if (png_ptr != NULL && info_ptr != NULL)

      return info_ptr->bit_depth;

   return (0);

}

png_byte PNGAPI

png_get_color_type(png_const_structrp png_ptr, png_const_inforp info_ptr)

{

   if (png_ptr != NULL && info_ptr != NULL)

      return info_ptr->color_type;

   return (0);

}

png_byte PNGAPI

png_get_filter_type(png_const_structrp png_ptr, png_const_inforp info_ptr)

{

   if (png_ptr != NULL && info_ptr != NULL)

      return info_ptr->filter_type;

   return (0);

}

png_byte PNGAPI

png_get_interlace_type(png_const_structrp png_ptr, png_const_inforp info_ptr)

{

   if (png_ptr != NULL && info_ptr != NULL)

      return info_ptr->interlace_type;

   return (0);

}

png_byte PNGAPI

png_get_compression_type(png_const_structrp png_ptr, png_const_inforp info_ptr)

{

   if (png_ptr != NULL && info_ptr != NULL)

      return info_ptr->compression_type;

   return (0);

}

png_uint_32 PNGAPI

png_get_x_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp

   info_ptr)

{

#ifdef PNG_pHYs_SUPPORTED

   if (png_ptr != NULL && info_ptr != NULL &&

       (info_ptr->valid & PNG_INFO_pHYs) != 0)

      {

         png_debug1(1, "in %s retrieval function",

             "png_get_x_pixels_per_meter");

         if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)

            return (info_ptr->x_pixels_per_unit);

      }

#else

   PNG_UNUSED(png_ptr)

   PNG_UNUSED(info_ptr)

#endif

   return (0);

}

png_uint_32 PNGAPI

png_get_y_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp

    info_ptr)

{

#ifdef PNG_pHYs_SUPPORTED

   if (png_ptr != NULL && info_ptr != NULL &&

       (info_ptr->valid & PNG_INFO_pHYs) != 0)

   {

      png_debug1(1, "in %s retrieval function",

          "png_get_y_pixels_per_meter");

      if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)

         return (info_ptr->y_pixels_per_unit);

   }

#else

   PNG_UNUSED(png_ptr)

   PNG_UNUSED(info_ptr)

#endif

   return (0);

}

png_uint_32 PNGAPI

png_get_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp info_ptr)

{

#ifdef PNG_pHYs_SUPPORTED

   if (png_ptr != NULL && info_ptr != NULL &&

       (info_ptr->valid & PNG_INFO_pHYs) != 0)

   {

      png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");

      if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER &&

          info_ptr->x_pixels_per_unit == info_ptr->y_pixels_per_unit)

         return (info_ptr->x_pixels_per_unit);

   }

#else

   PNG_UNUSED(png_ptr)

   PNG_UNUSED(info_ptr)

#endif

   return (0);

}

#ifdef PNG_FLOATING_POINT_SUPPORTED

float PNGAPI

png_get_pixel_aspect_ratio(png_const_structrp png_ptr, png_const_inforp

   info_ptr)

{

#ifdef PNG_READ_pHYs_SUPPORTED

   if (png_ptr != NULL && info_ptr != NULL &&

       (info_ptr->valid & PNG_INFO_pHYs) != 0)

   {

      png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");

      if (info_ptr->x_pixels_per_unit != 0)

         return ((float)((float)info_ptr->y_pixels_per_unit

             /(float)info_ptr->x_pixels_per_unit));

   }

#else

   PNG_UNUSED(png_ptr)

   PNG_UNUSED(info_ptr)

#endif

   return ((float)0.0);

}

#endif

#ifdef PNG_FIXED_POINT_SUPPORTED

png_fixed_point PNGAPI

png_get_pixel_aspect_ratio_fixed(png_const_structrp png_ptr,

    png_const_inforp info_ptr)

{

#ifdef PNG_READ_pHYs_SUPPORTED

   if (png_ptr != NULL && info_ptr != NULL &&

       (info_ptr->valid & PNG_INFO_pHYs) != 0 &&

       info_ptr->x_pixels_per_unit > 0 && info_ptr->y_pixels_per_unit > 0 &&

       info_ptr->x_pixels_per_unit <= PNG_UINT_31_MAX &&

       info_ptr->y_pixels_per_unit <= PNG_UINT_31_MAX)

   {

      png_fixed_point res;

      png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio_fixed");

      /* The following casts work because a PNG 4 byte integer only has a valid

       * range of 0..2^31-1; otherwise the cast might overflow.

       */

      if (png_muldiv(&res, (png_int_32)info_ptr->y_pixels_per_unit, PNG_FP_1,

          (png_int_32)info_ptr->x_pixels_per_unit) != 0)

         return res;

   }

#else

   PNG_UNUSED(png_ptr)

   PNG_UNUSED(info_ptr)

#endif

   return 0;

}

#endif

png_int_32 PNGAPI

png_get_x_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr)

{

#ifdef PNG_oFFs_SUPPORTED

   if (png_ptr != NULL && info_ptr != NULL &&

       (info_ptr->valid & PNG_INFO_oFFs) != 0)

   {

      png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");

      if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)

         return (info_ptr->x_offset);

   }

#else

   PNG_UNUSED(png_ptr)

   PNG_UNUSED(info_ptr)

#endif

   return (0);

}

png_int_32 PNGAPI

png_get_y_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr)

{

#ifdef PNG_oFFs_SUPPORTED

   if (png_ptr != NULL && info_ptr != NULL &&

       (info_ptr->valid & PNG_INFO_oFFs) != 0)

   {

      png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");

      if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)

         return (info_ptr->y_offset);

   }

#else

   PNG_UNUSED(png_ptr)

   PNG_UNUSED(info_ptr)

#endif

   return (0);

}

png_int_32 PNGAPI

png_get_x_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr)

{

#ifdef PNG_oFFs_SUPPORTED

   if (png_ptr != NULL && info_ptr != NULL &&

       (info_ptr->valid & PNG_INFO_oFFs) != 0)

   {

      png_debug1(1, "in %s retrieval function", "png_get_x_offset_pixels");

      if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)

         return (info_ptr->x_offset);

   }

#else

   PNG_UNUSED(png_ptr)

   PNG_UNUSED(info_ptr)

#endif

   return (0);

}

png_int_32 PNGAPI

png_get_y_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr)

{

#ifdef PNG_oFFs_SUPPORTED

   if (png_ptr != NULL && info_ptr != NULL &&

       (info_ptr->valid & PNG_INFO_oFFs) != 0)

   {

      png_debug1(1, "in %s retrieval function", "png_get_y_offset_pixels");

      if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)

         return (info_ptr->y_offset);

   }

#else

   PNG_UNUSED(png_ptr)

   PNG_UNUSED(info_ptr)

#endif

   return (0);

}

#ifdef PNG_INCH_CONVERSIONS_SUPPORTED

static png_uint_32

ppi_from_ppm(png_uint_32 ppm)

{

#if 0

   /* The conversion is *(2.54/100), in binary (32 digits):

    * .00000110100000001001110101001001

    */

   png_uint_32 t1001, t1101;

   ppm >>= 1;                  /* .1 */

   t1001 = ppm + (ppm >> 3);   /* .1001 */

   t1101 = t1001 + (ppm >> 1); /* .1101 */

   ppm >>= 20;                 /* .000000000000000000001 */

   t1101 += t1101 >> 15;       /* .1101000000000001101 */

   t1001 >>= 11;               /* .000000000001001 */

   t1001 += t1001 >> 12;       /* .000000000001001000000001001 */

   ppm += t1001;               /* .000000000001001000001001001 */

   ppm += t1101;               /* .110100000001001110101001001 */

   return (ppm + 16) >> 5;/* .00000110100000001001110101001001 */

#else

   /* The argument is a PNG unsigned integer, so it is not permitted

    * to be bigger than 2^31.

    */

   png_fixed_point result;

   if (ppm <= PNG_UINT_31_MAX && png_muldiv(&result, (png_int_32)ppm, 127,

       5000) != 0)

      return (png_uint_32)result;

   /* Overflow. */

   return 0;

#endif

}

png_uint_32 PNGAPI

png_get_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)

{

   return ppi_from_ppm(png_get_pixels_per_meter(png_ptr, info_ptr));

}

png_uint_32 PNGAPI

png_get_x_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)

{

   return ppi_from_ppm(png_get_x_pixels_per_meter(png_ptr, info_ptr));

}

png_uint_32 PNGAPI

png_get_y_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)

{

   return ppi_from_ppm(png_get_y_pixels_per_meter(png_ptr, info_ptr));

}

#ifdef PNG_FIXED_POINT_SUPPORTED

static png_fixed_point

png_fixed_inches_from_microns(png_const_structrp png_ptr, png_int_32 microns)

{

   /* Convert from meters * 1,000,000 to inches * 100,000, meters to

    * inches is simply *(100/2.54), so we want *(10/2.54) == 500/127.

    * Notice that this can overflow - a warning is output and 0 is

    * returned.

    */

   return png_muldiv_warn(png_ptr, microns, 500, 127);

}

png_fixed_point PNGAPI

png_get_x_offset_inches_fixed(png_const_structrp png_ptr,

    png_const_inforp info_ptr)

{

   return png_fixed_inches_from_microns(png_ptr,

       png_get_x_offset_microns(png_ptr, info_ptr));

}

#endif

#ifdef PNG_FIXED_POINT_SUPPORTED

png_fixed_point PNGAPI

png_get_y_offset_inches_fixed(png_const_structrp png_ptr,

    png_const_inforp info_ptr)

{

   return png_fixed_inches_from_microns(png_ptr,

       png_get_y_offset_microns(png_ptr, info_ptr));

}

#endif

#ifdef PNG_FLOATING_POINT_SUPPORTED

float PNGAPI

png_get_x_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr)

{

   /* To avoid the overflow do the conversion directly in floating

    * point.

    */

   return (float)(png_get_x_offset_microns(png_ptr, info_ptr) * .00003937);

}

#endif

#ifdef PNG_FLOATING_POINT_SUPPORTED

float PNGAPI

png_get_y_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr)

{

   /* To avoid the overflow do the conversion directly in floating

    * point.

    */

   return (float)(png_get_y_offset_microns(png_ptr, info_ptr) * .00003937);

}

#endif

#ifdef PNG_pHYs_SUPPORTED

png_uint_32 PNGAPI

png_get_pHYs_dpi(png_const_structrp png_ptr, png_const_inforp info_ptr,

    png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)

{

   png_uint_32 retval = 0;

   if (png_ptr != NULL && info_ptr != NULL &&

       (info_ptr->valid & PNG_INFO_pHYs) != 0)

   {

      png_debug1(1, "in %s retrieval function", "pHYs");

      if (res_x != NULL)

      {

         *res_x = info_ptr->x_pixels_per_unit;

         retval |= PNG_INFO_pHYs;

      }

      if (res_y != NULL)

      {

         *res_y = info_ptr->y_pixels_per_unit;

         retval |= PNG_INFO_pHYs;

      }

      if (unit_type != NULL)

      {

         *unit_type = (int)info_ptr->phys_unit_type;

         retval |= PNG_INFO_pHYs;

         if (*unit_type == 1)

         {

            if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);

            if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);

         }

      }

   }

   return (retval);

}

#endif /* pHYs */

#endif /* INCH_CONVERSIONS */

/* png_get_channels really belongs in here, too, but it's been around longer */

#endif /* EASY_ACCESS */

png_byte PNGAPI

png_get_channels(png_const_structrp png_ptr, png_const_inforp info_ptr)