/*

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

 */

/* pngpread.c - read a png file in push mode

 *

 * 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

 */

#include "pngpriv.h"

#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

/* Push model modes */

#define PNG_READ_SIG_MODE   0

#define PNG_READ_CHUNK_MODE 1

#define PNG_READ_IDAT_MODE  2

#define PNG_READ_tEXt_MODE  4

#define PNG_READ_zTXt_MODE  5

#define PNG_READ_DONE_MODE  6

#define PNG_READ_iTXt_MODE  7

#define PNG_ERROR_MODE      8

#define PNG_PUSH_SAVE_BUFFER_IF_FULL \

if (png_ptr->push_length + 4 > png_ptr->buffer_size) \

   { png_push_save_buffer(png_ptr); return; }

#define PNG_PUSH_SAVE_BUFFER_IF_LT(N) \

if (png_ptr->buffer_size < N) \

   { png_push_save_buffer(png_ptr); return; }

void PNGAPI

png_process_data(png_structrp png_ptr, png_inforp info_ptr,

    png_bytep buffer, png_size_t buffer_size)

{

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

      return;

   png_push_restore_buffer(png_ptr, buffer, buffer_size);

   while (png_ptr->buffer_size)

   {

      png_process_some_data(png_ptr, info_ptr);

   }

}

png_size_t PNGAPI

png_process_data_pause(png_structrp png_ptr, int save)

{

   if (png_ptr != NULL)

   {

      /* It's easiest for the caller if we do the save; then the caller doesn't

       * have to supply the same data again:

       */

      if (save != 0)

         png_push_save_buffer(png_ptr);

      else

      {

         /* This includes any pending saved bytes: */

         png_size_t remaining = png_ptr->buffer_size;

         png_ptr->buffer_size = 0;

         /* So subtract the saved buffer size, unless all the data

          * is actually 'saved', in which case we just return 0

          */

         if (png_ptr->save_buffer_size < remaining)

            return remaining - png_ptr->save_buffer_size;

      }

   }

   return 0;

}

png_uint_32 PNGAPI

png_process_data_skip(png_structrp png_ptr)

{

/* TODO: Deprecate and remove this API.

 * Somewhere the implementation of this seems to have been lost,

 * or abandoned.  It was only to support some internal back-door access

 * to png_struct) in libpng-1.4.x.

 */

   png_app_warning(png_ptr,

"png_process_data_skip is not implemented in any current version of libpng");

   return 0;

}

/* What we do with the incoming data depends on what we were previously

 * doing before we ran out of data...

 */

void /* PRIVATE */

png_process_some_data(png_structrp png_ptr, png_inforp info_ptr)

{

   if (png_ptr == NULL)

      return;

   switch (png_ptr->process_mode)

   {

      case PNG_READ_SIG_MODE:

      {

         png_push_read_sig(png_ptr, info_ptr);

         break;

      }

      case PNG_READ_CHUNK_MODE:

      {

         png_push_read_chunk(png_ptr, info_ptr);

         break;

      }

      case PNG_READ_IDAT_MODE:

      {

         png_push_read_IDAT(png_ptr);

         break;

      }

      default:

      {

         png_ptr->buffer_size = 0;

         break;

      }

   }

}

/* Read any remaining signature bytes from the stream and compare them with

 * the correct PNG signature.  It is possible that this routine is called

 * with bytes already read from the signature, either because they have been

 * checked by the calling application, or because of multiple calls to this

 * routine.

 */

void /* PRIVATE */

png_push_read_sig(png_structrp png_ptr, png_inforp info_ptr)

{

   png_size_t num_checked = png_ptr->sig_bytes, /* SAFE, does not exceed 8 */

       num_to_check = 8 - num_checked;

   if (png_ptr->buffer_size < num_to_check)

   {

      num_to_check = png_ptr->buffer_size;

   }

   png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),

       num_to_check);

   png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check);

   if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))

   {

      if (num_checked < 4 &&

          png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))

         png_error(png_ptr, "Not a PNG file");

      else

         png_error(png_ptr, "PNG file corrupted by ASCII conversion");

   }

   else

   {

      if (png_ptr->sig_bytes >= 8)

      {

         png_ptr->process_mode = PNG_READ_CHUNK_MODE;

      }

   }

}

void /* PRIVATE */

png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)

{

   png_uint_32 chunk_name;

#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

   int keep; /* unknown handling method */

#endif

   /* First we make sure we have enough data for the 4-byte chunk name

    * and the 4-byte chunk length before proceeding with decoding the

    * chunk data.  To fully decode each of these chunks, we also make

    * sure we have enough data in the buffer for the 4-byte CRC at the

    * end of every chunk (except IDAT, which is handled separately).

    */

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

   {

      png_byte chunk_length[4];

      png_byte chunk_tag[4];

      PNG_PUSH_SAVE_BUFFER_IF_LT(8)

      png_push_fill_buffer(png_ptr, chunk_length, 4);

      png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);

      png_reset_crc(png_ptr);

      png_crc_read(png_ptr, chunk_tag, 4);

      png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(chunk_tag);

      png_check_chunk_name(png_ptr, png_ptr->chunk_name);

      png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;

   }

   chunk_name = png_ptr->chunk_name;

   if (chunk_name == png_IDAT)

   {

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

         png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;

      /* If we reach an IDAT chunk, this means we have read all of the

       * header chunks, and we can start reading the image (or if this

       * is called after the image has been read - we have an error).

       */

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

         png_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_error(png_ptr, "Missing PLTE before IDAT");

      png_ptr->process_mode = PNG_READ_IDAT_MODE;

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

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

            if (png_ptr->push_length == 0)

               return;

      png_ptr->mode |= PNG_HAVE_IDAT;

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

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

   }

   if (chunk_name == png_IHDR)

   {

      if (png_ptr->push_length != 13)

         png_error(png_ptr, "Invalid IHDR length");

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);

   }

   else if (chunk_name == png_IEND)

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);

      png_ptr->process_mode = PNG_READ_DONE_MODE;

      png_push_have_end(png_ptr, info_ptr);

   }

#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

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

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length, keep);

      if (chunk_name == png_PLTE)

         png_ptr->mode |= PNG_HAVE_PLTE;

   }

#endif

   else if (chunk_name == png_PLTE)

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);

   }

   else if (chunk_name == png_IDAT)

   {

      png_ptr->idat_size = png_ptr->push_length;

      png_ptr->process_mode = PNG_READ_IDAT_MODE;

      png_push_have_info(png_ptr, info_ptr);

      png_ptr->zstream.avail_out =

          (uInt) PNG_ROWBYTES(png_ptr->pixel_depth,

          png_ptr->iwidth) + 1;

      png_ptr->zstream.next_out = png_ptr->row_buf;

      return;

   }

#ifdef PNG_READ_gAMA_SUPPORTED

   else if (png_ptr->chunk_name == png_gAMA)

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);

   }

#endif

#ifdef PNG_READ_sBIT_SUPPORTED

   else if (png_ptr->chunk_name == png_sBIT)

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);

   }

#endif

#ifdef PNG_READ_cHRM_SUPPORTED

   else if (png_ptr->chunk_name == png_cHRM)

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);

   }

#endif

#ifdef PNG_READ_sRGB_SUPPORTED

   else if (chunk_name == png_sRGB)

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);

   }

#endif

#ifdef PNG_READ_iCCP_SUPPORTED

   else if (png_ptr->chunk_name == png_iCCP)

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);

   }

#endif

#ifdef PNG_READ_sPLT_SUPPORTED

   else if (chunk_name == png_sPLT)

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);

   }

#endif

#ifdef PNG_READ_tRNS_SUPPORTED

   else if (chunk_name == png_tRNS)

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);

   }

#endif

#ifdef PNG_READ_bKGD_SUPPORTED

   else if (chunk_name == png_bKGD)

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);

   }

#endif

#ifdef PNG_READ_hIST_SUPPORTED

   else if (chunk_name == png_hIST)

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);

   }

#endif

#ifdef PNG_READ_pHYs_SUPPORTED

   else if (chunk_name == png_pHYs)

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);

   }

#endif

#ifdef PNG_READ_oFFs_SUPPORTED

   else if (chunk_name == png_oFFs)

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);

   }

#endif

#ifdef PNG_READ_pCAL_SUPPORTED

   else if (chunk_name == png_pCAL)

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);

   }

#endif

#ifdef PNG_READ_sCAL_SUPPORTED

   else if (chunk_name == png_sCAL)

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);

   }

#endif

#ifdef PNG_READ_tIME_SUPPORTED

   else if (chunk_name == png_tIME)

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);

   }

#endif

#ifdef PNG_READ_tEXt_SUPPORTED

   else if (chunk_name == png_tEXt)

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);

   }

#endif

#ifdef PNG_READ_zTXt_SUPPORTED

   else if (chunk_name == png_zTXt)

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);

   }

#endif

#ifdef PNG_READ_iTXt_SUPPORTED

   else if (chunk_name == png_iTXt)

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);

   }

#endif

   else

   {

      PNG_PUSH_SAVE_BUFFER_IF_FULL

      png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length,

          PNG_HANDLE_CHUNK_AS_DEFAULT);

   }

   png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;

}

void PNGCBAPI

png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)

{

   png_bytep ptr;

   if (png_ptr == NULL)

      return;

   ptr = buffer;

   if (png_ptr->save_buffer_size != 0)

   {

      png_size_t save_size;

      if (length < png_ptr->save_buffer_size)

         save_size = length;

      else

         save_size = png_ptr->save_buffer_size;

      memcpy(ptr, png_ptr->save_buffer_ptr, save_size);

      length -= save_size;

      ptr += save_size;

      png_ptr->buffer_size -= save_size;

      png_ptr->save_buffer_size -= save_size;

      png_ptr->save_buffer_ptr += save_size;

   }

   if (length != 0 && png_ptr->current_buffer_size != 0)

   {

      png_size_t save_size;

      if (length < png_ptr->current_buffer_size)

         save_size = length;

      else

         save_size = png_ptr->current_buffer_size;

      memcpy(ptr, png_ptr->current_buffer_ptr, save_size);

      png_ptr->buffer_size -= save_size;

      png_ptr->current_buffer_size -= save_size;

      png_ptr->current_buffer_ptr += save_size;

   }

}

void /* PRIVATE */

png_push_save_buffer(png_structrp png_ptr)

{

   if (png_ptr->save_buffer_size != 0)

   {

      if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)