/*

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

 */

/* pngwutil.c - utilities to write 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:

 *

 * Last changed in libpng 1.5.4 [July 7, 2011]

 * Copyright (c) 1998-2011 Glenn Randers-Pehrson

 * (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_WRITE_SUPPORTED

#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED

/* Place a 32-bit number into a buffer in PNG byte order.  We work

 * with unsigned numbers for convenience, although one supported

 * ancillary chunk uses signed (two's complement) numbers.

 */

void PNGAPI

png_save_uint_32(png_bytep buf, png_uint_32 i)

{

   buf[0] = (png_byte)((i >> 24) & 0xff);

   buf[1] = (png_byte)((i >> 16) & 0xff);

   buf[2] = (png_byte)((i >> 8) & 0xff);

   buf[3] = (png_byte)(i & 0xff);

}

#ifdef PNG_SAVE_INT_32_SUPPORTED

/* The png_save_int_32 function assumes integers are stored in two's

 * complement format.  If this isn't the case, then this routine needs to

 * be modified to write data in two's complement format.  Note that,

 * the following works correctly even if png_int_32 has more than 32 bits

 * (compare the more complex code required on read for sign extention.)

 */

void PNGAPI

png_save_int_32(png_bytep buf, png_int_32 i)

{

   buf[0] = (png_byte)((i >> 24) & 0xff);

   buf[1] = (png_byte)((i >> 16) & 0xff);

   buf[2] = (png_byte)((i >> 8) & 0xff);

   buf[3] = (png_byte)(i & 0xff);

}

#endif

/* Place a 16-bit number into a buffer in PNG byte order.

 * The parameter is declared unsigned int, not png_uint_16,

 * just to avoid potential problems on pre-ANSI C compilers.

 */

void PNGAPI

png_save_uint_16(png_bytep buf, unsigned int i)

{

   buf[0] = (png_byte)((i >> 8) & 0xff);

   buf[1] = (png_byte)(i & 0xff);

}

#endif

/* Simple function to write the signature.  If we have already written

 * the magic bytes of the signature, or more likely, the PNG stream is

 * being embedded into another stream and doesn't need its own signature,

 * we should call png_set_sig_bytes() to tell libpng how many of the

 * bytes have already been written.

 */

void PNGAPI

png_write_sig(png_structp png_ptr)

{

   png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};

#ifdef PNG_IO_STATE_SUPPORTED

   /* Inform the I/O callback that the signature is being written */

   png_ptr->io_state = PNG_IO_WRITING | PNG_IO_SIGNATURE;

#endif

   /* Write the rest of the 8 byte signature */

   png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],

      (png_size_t)(8 - png_ptr->sig_bytes));

   if (png_ptr->sig_bytes < 3)

      png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;

}

/* Write a PNG chunk all at once.  The type is an array of ASCII characters

 * representing the chunk name.  The array must be at least 4 bytes in

 * length, and does not need to be null terminated.  To be safe, pass the

 * pre-defined chunk names here, and if you need a new one, define it

 * where the others are defined.  The length is the length of the data.

 * All the data must be present.  If that is not possible, use the

 * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end()

 * functions instead.

 */

void PNGAPI

png_write_chunk(png_structp png_ptr, png_const_bytep chunk_name,

   png_const_bytep data, png_size_t length)

{

   if (png_ptr == NULL)

      return;

   png_write_chunk_start(png_ptr, chunk_name, (png_uint_32)length);

   png_write_chunk_data(png_ptr, data, (png_size_t)length);

   png_write_chunk_end(png_ptr);

}

/* Write the start of a PNG chunk.  The type is the chunk type.

 * The total_length is the sum of the lengths of all the data you will be

 * passing in png_write_chunk_data().

 */

void PNGAPI

png_write_chunk_start(png_structp png_ptr, png_const_bytep chunk_name,

    png_uint_32 length)

{

   png_byte buf[8];

   png_debug2(0, "Writing %s chunk, length = %lu", chunk_name,

      (unsigned long)length);

   if (png_ptr == NULL)

      return;

#ifdef PNG_IO_STATE_SUPPORTED

   /* Inform the I/O callback that the chunk header is being written.

    * PNG_IO_CHUNK_HDR requires a single I/O call.

    */

   png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_HDR;

#endif

   /* Write the length and the chunk name */

   png_save_uint_32(buf, length);

   png_memcpy(buf + 4, chunk_name, 4);

   png_write_data(png_ptr, buf, (png_size_t)8);

   /* Put the chunk name into png_ptr->chunk_name */

   png_memcpy(png_ptr->chunk_name, chunk_name, 4);

   /* Reset the crc and run it over the chunk name */

   png_reset_crc(png_ptr);

   png_calculate_crc(png_ptr, chunk_name, 4);

#ifdef PNG_IO_STATE_SUPPORTED

   /* Inform the I/O callback that chunk data will (possibly) be written.

    * PNG_IO_CHUNK_DATA does NOT require a specific number of I/O calls.

    */

   png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_DATA;

#endif

}

/* Write the data of a PNG chunk started with png_write_chunk_start().

 * Note that multiple calls to this function are allowed, and that the

 * sum of the lengths from these calls *must* add up to the total_length

 * given to png_write_chunk_start().

 */

void PNGAPI

png_write_chunk_data(png_structp png_ptr, png_const_bytep data,

    png_size_t length)

{

   /* Write the data, and run the CRC over it */

   if (png_ptr == NULL)

      return;

   if (data != NULL && length > 0)

   {

      png_write_data(png_ptr, data, length);

      /* Update the CRC after writing the data,

       * in case that the user I/O routine alters it.

       */

      png_calculate_crc(png_ptr, data, length);

   }

}

/* Finish a chunk started with png_write_chunk_start(). */

void PNGAPI

png_write_chunk_end(png_structp png_ptr)

{

   png_byte buf[4];

   if (png_ptr == NULL) return;

#ifdef PNG_IO_STATE_SUPPORTED

   /* Inform the I/O callback that the chunk CRC is being written.

    * PNG_IO_CHUNK_CRC requires a single I/O function call.

    */

   png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_CRC;

#endif

   /* Write the crc in a single operation */

   png_save_uint_32(buf, png_ptr->crc);

   png_write_data(png_ptr, buf, (png_size_t)4);

}

/* Initialize the compressor for the appropriate type of compression. */

static void

png_zlib_claim(png_structp png_ptr, png_uint_32 state)

{

   if (!(png_ptr->zlib_state & PNG_ZLIB_IN_USE))

   {

      /* If already initialized for 'state' do not re-init. */

      if (png_ptr->zlib_state != state)

      {

         int ret = Z_OK;

         png_const_charp who = "-";

         /* If actually initialized for another state do a deflateEnd. */

         if (png_ptr->zlib_state != PNG_ZLIB_UNINITIALIZED)

         {

            ret = deflateEnd(&png_ptr->zstream);

            who = "end";

            png_ptr->zlib_state = PNG_ZLIB_UNINITIALIZED;

         }

         /* zlib itself detects an incomplete state on deflateEnd */

         if (ret == Z_OK) switch (state)

         {

#           ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED

               case PNG_ZLIB_FOR_TEXT:

                  ret = deflateInit2(&png_ptr->zstream,

                     png_ptr->zlib_text_level, png_ptr->zlib_text_method,

                     png_ptr->zlib_text_window_bits,

                     png_ptr->zlib_text_mem_level, png_ptr->zlib_text_strategy);

                  who = "text";

                  break;

#           endif

            case PNG_ZLIB_FOR_IDAT:

               ret = deflateInit2(&png_ptr->zstream, png_ptr->zlib_level,

                   png_ptr->zlib_method, png_ptr->zlib_window_bits,

                   png_ptr->zlib_mem_level, png_ptr->zlib_strategy);

               who = "IDAT";

               break;

            default:

               png_error(png_ptr, "invalid zlib state");

         }

         if (ret == Z_OK)

            png_ptr->zlib_state = state;

         else /* an error in deflateEnd or deflateInit2 */

         {

            size_t pos = 0;

            char msg[64];

            pos = png_safecat(msg, sizeof msg, pos,

               "zlib failed to initialize compressor (");

            pos = png_safecat(msg, sizeof msg, pos, who);

            switch (ret)

            {

               case Z_VERSION_ERROR:

                  pos = png_safecat(msg, sizeof msg, pos, ") version error");

                  break;

               case Z_STREAM_ERROR:

                  pos = png_safecat(msg, sizeof msg, pos, ") stream error");

                  break;

               case Z_MEM_ERROR:

                  pos = png_safecat(msg, sizeof msg, pos, ") memory error");

                  break;

               default:

                  pos = png_safecat(msg, sizeof msg, pos, ") unknown error");

                  break;

            }

            png_error(png_ptr, msg);

         }

      }

      /* Here on success, claim the zstream: */

      png_ptr->zlib_state |= PNG_ZLIB_IN_USE;

   }

   else

      png_error(png_ptr, "zstream already in use (internal error)");

}

/* The opposite: release the stream.  It is also reset, this API will warn on

 * error but will not fail.

 */

static void

png_zlib_release(png_structp png_ptr)

{

   if (png_ptr->zlib_state & PNG_ZLIB_IN_USE)

   {

      int ret = deflateReset(&png_ptr->zstream);

      png_ptr->zlib_state &= ~PNG_ZLIB_IN_USE;

      if (ret != Z_OK)

      {

         png_const_charp err;

         PNG_WARNING_PARAMETERS(p)

         switch (ret)

         {

            case Z_VERSION_ERROR:

               err = "version";

               break;

            case Z_STREAM_ERROR:

               err = "stream";

               break;

            case Z_MEM_ERROR:

               err = "memory";

               break;

            default:

               err = "unknown";

               break;

         }

         png_warning_parameter_signed(p, 1, PNG_NUMBER_FORMAT_d, ret);

         png_warning_parameter(p, 2, err);

         if (png_ptr->zstream.msg)

            err = png_ptr->zstream.msg;

         else

            err = "[no zlib message]";

         png_warning_parameter(p, 3, err);

         png_formatted_warning(png_ptr, p,

            "zlib failed to reset compressor: @1(@2): @3");

      }

   }

   else

      png_warning(png_ptr, "zstream not in use (internal error)");

}

#ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED

/* This pair of functions encapsulates the operation of (a) compressing a

 * text string, and (b) issuing it later as a series of chunk data writes.

 * The compression_state structure is shared context for these functions

 * set up by the caller in order to make the whole mess thread-safe.

 */

typedef struct

{

   png_const_bytep input;   /* The uncompressed input data */

   png_size_t input_len;    /* Its length */

   int num_output_ptr;      /* Number of output pointers used */

   int max_output_ptr;      /* Size of output_ptr */

   png_bytep *output_ptr;   /* Array of pointers to output */

} compression_state;

/* Compress given text into storage in the png_ptr structure */

static int /* PRIVATE */

png_text_compress(png_structp png_ptr,

    png_const_charp text, png_size_t text_len, int compression,

    compression_state *comp)

{

   int ret;

   comp->num_output_ptr = 0;

   comp->max_output_ptr = 0;

   comp->output_ptr = NULL;

   comp->input = NULL;

   comp->input_len = text_len;

   /* We may just want to pass the text right through */

   if (compression == PNG_TEXT_COMPRESSION_NONE)

   {

      comp->input = (png_const_bytep)text;

      return((int)text_len);

   }

   if (compression >= PNG_TEXT_COMPRESSION_LAST)

   {

      PNG_WARNING_PARAMETERS(p)

      png_warning_parameter_signed(p, 1, PNG_NUMBER_FORMAT_d,

         compression);

      png_formatted_warning(png_ptr, p, "Unknown compression type @1");

   }

   /* We can't write the chunk until we find out how much data we have,

    * which means we need to run the compressor first and save the

    * output.  This shouldn't be a problem, as the vast majority of

    * comments should be reasonable, but we will set up an array of

    * malloc'd pointers to be sure.

    *

    * If we knew the application was well behaved, we could simplify this

    * greatly by assuming we can always malloc an output buffer large

    * enough to hold the compressed text ((1001 * text_len / 1000) + 12)

    * and malloc this directly.  The only time this would be a bad idea is

    * if we can't malloc more than 64K and we have 64K of random input

    * data, or if the input string is incredibly large (although this

    * wouldn't cause a failure, just a slowdown due to swapping).

    */

   png_zlib_claim(png_ptr, PNG_ZLIB_FOR_TEXT);

   /* Set up the compression buffers */

   /* TODO: the following cast hides a potential overflow problem. */

   png_ptr->zstream.avail_in = (uInt)text_len;

   /* NOTE: assume zlib doesn't overwrite the input */

   png_ptr->zstream.next_in = (Bytef *)text;

   png_ptr->zstream.avail_out = png_ptr->zbuf_size;

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

   /* This is the same compression loop as in png_write_row() */

   do

   {

      /* Compress the data */

      ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);

      if (ret != Z_OK)

      {

         /* Error */

         if (png_ptr->zstream.msg != NULL)

            png_error(png_ptr, png_ptr->zstream.msg);

         else

            png_error(png_ptr, "zlib error");

      }

      /* Check to see if we need more room */

      if (!(png_ptr->zstream.avail_out))

      {

         /* Make sure the output array has room */

         if (comp->num_output_ptr >= comp->max_output_ptr)

         {

            int old_max;

            old_max = comp->max_output_ptr;

            comp->max_output_ptr = comp->num_output_ptr + 4;

            if (comp->output_ptr != NULL)

            {

               png_bytepp old_ptr;

               old_ptr = comp->output_ptr;

               comp->output_ptr = (png_bytepp)png_malloc(png_ptr,

                   (png_alloc_size_t)

                   (comp->max_output_ptr * png_sizeof(png_charpp)));

               png_memcpy(comp->output_ptr, old_ptr, old_max

                   * png_sizeof(png_charp));

               png_free(png_ptr, old_ptr);

            }

            else

               comp->output_ptr = (png_bytepp)png_malloc(png_ptr,

                   (png_alloc_size_t)

                   (comp->max_output_ptr * png_sizeof(png_charp)));

         }

         /* Save the data */

         comp->output_ptr[comp->num_output_ptr] =

             (png_bytep)png_malloc(png_ptr,

             (png_alloc_size_t)png_ptr->zbuf_size);

         png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,

             png_ptr->zbuf_size);

         comp->num_output_ptr++;

         /* and reset the buffer */

         png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;

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

      }

   /* Continue until we don't have any more to compress */

   } while (png_ptr->zstream.avail_in);

   /* Finish the compression */

   do

   {