/*

 * 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.

 */

/* pngread.c - read a PNG file

 *

 * 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:

 *

 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

 *

 * This code is released under the libpng license.

 * For conditions of distribution and use, see the disclaimer

 * and license in png.h

 *

 * This file contains routines that an application calls directly to

 * read a PNG file or stream.

 */

#include "pngpriv.h"

#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) && defined(PNG_STDIO_SUPPORTED)

#  include <errno.h>

#endif

#ifdef PNG_READ_SUPPORTED

/* Create a PNG structure for reading, and allocate any memory needed. */

PNG_FUNCTION(png_structp,PNGAPI

png_create_read_struct,(png_const_charp user_png_ver, png_voidp error_ptr,

    png_error_ptr error_fn, png_error_ptr warn_fn),PNG_ALLOCATED)

{

#ifndef PNG_USER_MEM_SUPPORTED

   png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,

        error_fn, warn_fn, NULL, NULL, NULL);

#else

   return png_create_read_struct_2(user_png_ver, error_ptr, error_fn,

        warn_fn, NULL, NULL, NULL);

}

/* Alternate create PNG structure for reading, and allocate any memory

 * needed.

 */

PNG_FUNCTION(png_structp,PNGAPI

png_create_read_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr,

    png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

    png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)

{

   png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,

       error_fn, warn_fn, mem_ptr, malloc_fn, free_fn);

#endif /* USER_MEM */

   if (png_ptr != NULL)

   {

      png_ptr->mode = PNG_IS_READ_STRUCT;

      /* Added in libpng-1.6.0; this can be used to detect a read structure if

       * required (it will be zero in a write structure.)

       */

#     ifdef PNG_SEQUENTIAL_READ_SUPPORTED

         png_ptr->IDAT_read_size = PNG_IDAT_READ_SIZE;

#     endif

#     ifdef PNG_BENIGN_READ_ERRORS_SUPPORTED

         png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;

         /* In stable builds only warn if an application error can be completely

          * handled.

          */

#        if PNG_RELEASE_BUILD

            png_ptr->flags |= PNG_FLAG_APP_WARNINGS_WARN;

#        endif

#     endif

      /* TODO: delay this, it can be done in png_init_io (if the app doesn't

       * do it itself) avoiding setting the default function if it is not

       * required.

       */

      png_set_read_fn(png_ptr, NULL, NULL);

   }

   return png_ptr;

}

#ifdef PNG_SEQUENTIAL_READ_SUPPORTED

/* Read the information before the actual image data.  This has been

 * changed in v0.90 to allow reading a file that already has the magic

 * bytes read from the stream.  You can tell libpng how many bytes have

 * been read from the beginning of the stream (up to the maximum of 8)

 * via png_set_sig_bytes(), and we will only check the remaining bytes

 * here.  The application can then have access to the signature bytes we

 * read if it is determined that this isn't a valid PNG file.

 */

void PNGAPI

png_read_info(png_structrp png_ptr, png_inforp info_ptr)

{

#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

   int keep;

#endif

   png_debug(1, "in png_read_info");

   if (png_ptr == NULL || info_ptr == NULL)

      return;

   /* Read and check the PNG file signature. */

   png_read_sig(png_ptr, info_ptr);

   for (;;)

   {

      png_uint_32 length = png_read_chunk_header(png_ptr);

      png_uint_32 chunk_name = png_ptr->chunk_name;

      /* IDAT logic needs to happen here to simplify getting the two flags

       * right.

       */

      if (chunk_name == png_IDAT)

      {

         if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)

            png_chunk_error(png_ptr, "Missing IHDR before IDAT");

         else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&

             (png_ptr->mode & PNG_HAVE_PLTE) == 0)

            png_chunk_error(png_ptr, "Missing PLTE before IDAT");

         else if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)

            png_chunk_benign_error(png_ptr, "Too many IDATs found");

         png_ptr->mode |= PNG_HAVE_IDAT;

      }

      else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)

      {

         png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;

         png_ptr->mode |= PNG_AFTER_IDAT;

      }

      /* This should be a binary subdivision search or a hash for

       * matching the chunk name rather than a linear search.

       */

      if (chunk_name == png_IHDR)

         png_handle_IHDR(png_ptr, info_ptr, length);

      else if (chunk_name == png_IEND)

         png_handle_IEND(png_ptr, info_ptr, length);

#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

      else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)

      {

         png_handle_unknown(png_ptr, info_ptr, length, keep);

         if (chunk_name == png_PLTE)

            png_ptr->mode |= PNG_HAVE_PLTE;

         else if (chunk_name == png_IDAT)

         {

            png_ptr->idat_size = 0; /* It has been consumed */

            break;

         }

      }

#endif

      else if (chunk_name == png_PLTE)

         png_handle_PLTE(png_ptr, info_ptr, length);

      else if (chunk_name == png_IDAT)

      {

         png_ptr->idat_size = length;

         break;

      }

#ifdef PNG_READ_bKGD_SUPPORTED

      else if (chunk_name == png_bKGD)

         png_handle_bKGD(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_cHRM_SUPPORTED

      else if (chunk_name == png_cHRM)

         png_handle_cHRM(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_eXIf_SUPPORTED

      else if (chunk_name == png_eXIf)

         png_handle_eXIf(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_gAMA_SUPPORTED

      else if (chunk_name == png_gAMA)

         png_handle_gAMA(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_hIST_SUPPORTED

      else if (chunk_name == png_hIST)

         png_handle_hIST(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_oFFs_SUPPORTED

      else if (chunk_name == png_oFFs)

         png_handle_oFFs(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_pCAL_SUPPORTED

      else if (chunk_name == png_pCAL)

         png_handle_pCAL(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_sCAL_SUPPORTED

      else if (chunk_name == png_sCAL)

         png_handle_sCAL(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_pHYs_SUPPORTED

      else if (chunk_name == png_pHYs)

         png_handle_pHYs(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_sBIT_SUPPORTED

      else if (chunk_name == png_sBIT)

         png_handle_sBIT(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_sRGB_SUPPORTED

      else if (chunk_name == png_sRGB)

         png_handle_sRGB(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_iCCP_SUPPORTED

      else if (chunk_name == png_iCCP)

         png_handle_iCCP(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_sPLT_SUPPORTED

      else if (chunk_name == png_sPLT)

         png_handle_sPLT(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_tEXt_SUPPORTED

      else if (chunk_name == png_tEXt)

         png_handle_tEXt(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_tIME_SUPPORTED

      else if (chunk_name == png_tIME)

         png_handle_tIME(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_tRNS_SUPPORTED

      else if (chunk_name == png_tRNS)

         png_handle_tRNS(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_zTXt_SUPPORTED

      else if (chunk_name == png_zTXt)

         png_handle_zTXt(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_iTXt_SUPPORTED

      else if (chunk_name == png_iTXt)

         png_handle_iTXt(png_ptr, info_ptr, length);

#endif

      else

         png_handle_unknown(png_ptr, info_ptr, length,

             PNG_HANDLE_CHUNK_AS_DEFAULT);

   }

}

#endif /* SEQUENTIAL_READ */

/* Optional call to update the users info_ptr structure */

void PNGAPI

png_read_update_info(png_structrp png_ptr, png_inforp info_ptr)

{

   png_debug(1, "in png_read_update_info");

   if (png_ptr != NULL)

   {

      if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)

      {

         png_read_start_row(png_ptr);

#        ifdef PNG_READ_TRANSFORMS_SUPPORTED

            png_read_transform_info(png_ptr, info_ptr);

#        else

            PNG_UNUSED(info_ptr)

#        endif

      }

      /* New in 1.6.0 this avoids the bug of doing the initializations twice */

      else

         png_app_error(png_ptr,

             "png_read_update_info/png_start_read_image: duplicate call");

   }

}

#ifdef PNG_SEQUENTIAL_READ_SUPPORTED

/* Initialize palette, background, etc, after transformations

 * are set, but before any reading takes place.  This allows

 * the user to obtain a gamma-corrected palette, for example.

 * If the user doesn't call this, we will do it ourselves.

 */

void PNGAPI

png_start_read_image(png_structrp png_ptr)

{

   png_debug(1, "in png_start_read_image");

   if (png_ptr != NULL)

   {

      if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)

         png_read_start_row(png_ptr);

      /* New in 1.6.0 this avoids the bug of doing the initializations twice */

      else

         png_app_error(png_ptr,

             "png_start_read_image/png_read_update_info: duplicate call");

   }

}

#endif /* SEQUENTIAL_READ */

#ifdef PNG_SEQUENTIAL_READ_SUPPORTED

#ifdef PNG_MNG_FEATURES_SUPPORTED

/* Undoes intrapixel differencing,

 * NOTE: this is apparently only supported in the 'sequential' reader.

 */

static void

png_do_read_intrapixel(png_row_infop row_info, png_bytep row)

{

   png_debug(1, "in png_do_read_intrapixel");

   if (

       (row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)

   {

      int bytes_per_pixel;

      png_uint_32 row_width = row_info->width;

      if (row_info->bit_depth == 8)

      {

         png_bytep rp;

         png_uint_32 i;

         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

            bytes_per_pixel = 3;

         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

            bytes_per_pixel = 4;

         else

            return;

         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

         {

            *(rp) = (png_byte)((256 + *rp + *(rp + 1)) & 0xff);

            *(rp+2) = (png_byte)((256 + *(rp + 2) + *(rp + 1)) & 0xff);

         }

      }

      else if (row_info->bit_depth == 16)

      {

         png_bytep rp;

         png_uint_32 i;

         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

            bytes_per_pixel = 6;

         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

            bytes_per_pixel = 8;

         else

            return;

         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

         {

            png_uint_32 s0   = (png_uint_32)(*(rp    ) << 8) | *(rp + 1);

            png_uint_32 s1   = (png_uint_32)(*(rp + 2) << 8) | *(rp + 3);

            png_uint_32 s2   = (png_uint_32)(*(rp + 4) << 8) | *(rp + 5);

            png_uint_32 red  = (s0 + s1 + 65536) & 0xffff;

            png_uint_32 blue = (s2 + s1 + 65536) & 0xffff;

            *(rp    ) = (png_byte)((red >> 8) & 0xff);

            *(rp + 1) = (png_byte)(red & 0xff);

            *(rp + 4) = (png_byte)((blue >> 8) & 0xff);

            *(rp + 5) = (png_byte)(blue & 0xff);

         }

      }

   }

}

#endif /* MNG_FEATURES */

void PNGAPI

png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)

{

   png_row_info row_info;

   if (png_ptr == NULL)

      return;

   png_debug2(1, "in png_read_row (row %lu, pass %d)",

       (unsigned long)png_ptr->row_number, png_ptr->pass);

   /* png_read_start_row sets the information (in particular iwidth) for this

    * interlace pass.

    */

   if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)

      png_read_start_row(png_ptr);

   /* 1.5.6: row_info moved out of png_struct to a local here. */

   row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */

   row_info.color_type = png_ptr->color_type;

   row_info.bit_depth = png_ptr->bit_depth;

   row_info.channels = png_ptr->channels;

   row_info.pixel_depth = png_ptr->pixel_depth;

   row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width);

#ifdef PNG_WARNINGS_SUPPORTED

   if (png_ptr->row_number == 0 && png_ptr->pass == 0)

   {

   /* Check for transforms that have been set but were defined out */

#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)

   if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)

      png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined");

#endif

#if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED)

   if ((png_ptr->transformations & PNG_FILLER) != 0)

      png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined");

#endif

#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \

    !defined(PNG_READ_PACKSWAP_SUPPORTED)

   if ((png_ptr->transformations & PNG_PACKSWAP) != 0)

      png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined");

#endif

#if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED)

   if ((png_ptr->transformations & PNG_PACK) != 0)

      png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined");

#endif

#if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED)

   if ((png_ptr->transformations & PNG_SHIFT) != 0)

      png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined");

#endif

#if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED)

   if ((png_ptr->transformations & PNG_BGR) != 0)

      png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined");

#endif

#if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED)

   if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)

      png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined");

#endif

   }

#endif /* WARNINGS */

#ifdef PNG_READ_INTERLACING_SUPPORTED

   /* If interlaced and we do not need a new row, combine row and return.

    * Notice that the pixels we have from previous rows have been transformed

    * already; we can only combine like with like (transformed or

    * untransformed) and, because of the libpng API for interlaced images, this

    * means we must transform before de-interlacing.

    */

   if (png_ptr->interlaced != 0 &&

       (png_ptr->transformations & PNG_INTERLACE) != 0)

   {

      switch (png_ptr->pass)

      {

         case 0:

            if (png_ptr->row_number & 0x07)

            {

               if (dsp_row != NULL)