/* pngwutil.c - utilities to write a PNG file

 *

 * Last changed in libpng 1.6.21 [January 15, 2016]

 * Copyright (c) 1998-2002,2004,2006-2015 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);

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

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

   buf[3] = (png_byte)(i     );

}

/* 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);

   buf[1] = (png_byte)(i     );

}

#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_structrp 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 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().

 */

static void

png_write_chunk_header(png_structrp png_ptr, png_uint_32 chunk_name,

    png_uint_32 length)

{

   png_byte buf[8];

#if defined(PNG_DEBUG) && (PNG_DEBUG > 0)

   PNG_CSTRING_FROM_CHUNK(buf, chunk_name);

   png_debug2(0, "Writing %s chunk, length = %lu", buf, (unsigned long)length);

#endif

   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_save_uint_32(buf + 4, chunk_name);

   png_write_data(png_ptr, buf, 8);

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

   png_ptr->chunk_name = chunk_name;

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

   png_reset_crc(png_ptr);

   png_calculate_crc(png_ptr, buf + 4, 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

}

void PNGAPI

png_write_chunk_start(png_structrp png_ptr, png_const_bytep chunk_string,

    png_uint_32 length)

{

   png_write_chunk_header(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), length);

}

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

 * 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_header().

 */

void PNGAPI

png_write_chunk_data(png_structrp 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 the user I/O routine alters it.

       */

      png_calculate_crc(png_ptr, data, length);

   }

}

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

void PNGAPI

png_write_chunk_end(png_structrp 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);

}

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

 */

static void

png_write_complete_chunk(png_structrp png_ptr, png_uint_32 chunk_name,

   png_const_bytep data, png_size_t length)

{

   if (png_ptr == NULL)

      return;

   /* On 64-bit architectures 'length' may not fit in a png_uint_32. */

   if (length > PNG_UINT_31_MAX)

      png_error(png_ptr, "length exceeds PNG maximum");

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

   png_write_chunk_data(png_ptr, data, length);

   png_write_chunk_end(png_ptr);

}

/* This is the API that calls the internal function above. */

void PNGAPI

png_write_chunk(png_structrp png_ptr, png_const_bytep chunk_string,

   png_const_bytep data, png_size_t length)

{

   png_write_complete_chunk(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), data,

      length);

}

/* This is used below to find the size of an image to pass to png_deflate_claim,

 * so it only needs to be accurate if the size is less than 16384 bytes (the

 * point at which a lower LZ window size can be used.)

 */

static png_alloc_size_t

png_image_size(png_structrp png_ptr)

{

   /* Only return sizes up to the maximum of a png_uint_32; do this by limiting

    * the width and height used to 15 bits.

    */

   png_uint_32 h = png_ptr->height;

   if (png_ptr->rowbytes < 32768 && h < 32768)

   {

      if (png_ptr->interlaced != 0)

      {

         /* Interlacing makes the image larger because of the replication of

          * both the filter byte and the padding to a byte boundary.

          */

         png_uint_32 w = png_ptr->width;

         unsigned int pd = png_ptr->pixel_depth;

         png_alloc_size_t cb_base;

         int pass;

         for (cb_base=0, pass=0; pass<=6; ++pass)

         {

            png_uint_32 pw = PNG_PASS_COLS(w, pass);

            if (pw > 0)

               cb_base += (PNG_ROWBYTES(pd, pw)+1) * PNG_PASS_ROWS(h, pass);

         }

         return cb_base;

      }

      else

         return (png_ptr->rowbytes+1) * h;

   }

   else

      return 0xffffffffU;

}

#ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED

   /* This is the code to hack the first two bytes of the deflate stream (the

    * deflate header) to correct the windowBits value to match the actual data

    * size.  Note that the second argument is the *uncompressed* size but the

    * first argument is the *compressed* data (and it must be deflate

    * compressed.)

    */

static void

optimize_cmf(png_bytep data, png_alloc_size_t data_size)

{

   /* Optimize the CMF field in the zlib stream.  The resultant zlib stream is

    * still compliant to the stream specification.

    */

   if (data_size <= 16384) /* else windowBits must be 15 */

   {

      unsigned int z_cmf = data[0];  /* zlib compression method and flags */

      if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70)

      {

         unsigned int z_cinfo;

         unsigned int half_z_window_size;

         z_cinfo = z_cmf >> 4;

         half_z_window_size = 1U << (z_cinfo + 7);

         if (data_size <= half_z_window_size) /* else no change */

         {

            unsigned int tmp;

            do

            {

               half_z_window_size >>= 1;

               --z_cinfo;

            }

            while (z_cinfo > 0 && data_size <= half_z_window_size);

            z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4);

            data[0] = (png_byte)z_cmf;

            tmp = data[1] & 0xe0;

            tmp += 0x1f - ((z_cmf << 8) + tmp) % 0x1f;

            data[1] = (png_byte)tmp;

         }

      }

   }

}

#endif /* WRITE_OPTIMIZE_CMF */

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

static int

png_deflate_claim(png_structrp png_ptr, png_uint_32 owner,

   png_alloc_size_t data_size)

{

   if (png_ptr->zowner != 0)

   {

#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)

      char msg[64];

      PNG_STRING_FROM_CHUNK(msg, owner);

      msg[4] = ':';

      msg[5] = ' ';

      PNG_STRING_FROM_CHUNK(msg+6, png_ptr->zowner);

      /* So the message that results is "<chunk> using zstream"; this is an</chunk>

       * internal error, but is very useful for debugging.  i18n requirements

       * are minimal.

       */

      (void)png_safecat(msg, (sizeof msg), 10, " using zstream");

#endif

#if PNG_RELEASE_BUILD

         png_warning(png_ptr, msg);

         /* Attempt sane error recovery */

         if (png_ptr->zowner == png_IDAT) /* don't steal from IDAT */

         {

            png_ptr->zstream.msg = PNGZ_MSG_CAST("in use by IDAT");

            return Z_STREAM_ERROR;

         }

         png_ptr->zowner = 0;

#else

         png_error(png_ptr, msg);

#endif

   }

   {

      int level = png_ptr->zlib_level;

      int method = png_ptr->zlib_method;

      int windowBits = png_ptr->zlib_window_bits;

      int memLevel = png_ptr->zlib_mem_level;

      int strategy; /* set below */

      int ret; /* zlib return code */

      if (owner == png_IDAT)

      {

         if ((png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY) != 0)

            strategy = png_ptr->zlib_strategy;

         else if (png_ptr->do_filter != PNG_FILTER_NONE)

            strategy = PNG_Z_DEFAULT_STRATEGY;

         else

            strategy = PNG_Z_DEFAULT_NOFILTER_STRATEGY;

      }

      else

      {

#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED

            level = png_ptr->zlib_text_level;

            method = png_ptr->zlib_text_method;

            windowBits = png_ptr->zlib_text_window_bits;

            memLevel = png_ptr->zlib_text_mem_level;

            strategy = png_ptr->zlib_text_strategy;

#else

            /* If customization is not supported the values all come from the

             * IDAT values except for the strategy, which is fixed to the

             * default.  (This is the pre-1.6.0 behavior too, although it was

             * implemented in a very different way.)

             */

            strategy = Z_DEFAULT_STRATEGY;

#endif

      }

      /* Adjust 'windowBits' down if larger than 'data_size'; to stop this

       * happening just pass 32768 as the data_size parameter.  Notice that zlib

       * requires an extra 262 bytes in the window in addition to the data to be

       * able to see the whole of the data, so if data_size+262 takes us to the

       * next windowBits size we need to fix up the value later.  (Because even

       * though deflate needs the extra window, inflate does not!)

       */

      if (data_size <= 16384)

      {

         /* IMPLEMENTATION NOTE: this 'half_window_size' stuff is only here to

          * work round a Microsoft Visual C misbehavior which, contrary to C-90,

          * widens the result of the following shift to 64-bits if (and,

          * apparently, only if) it is used in a test.

          */

         unsigned int half_window_size = 1U << (windowBits-1);

         while (data_size + 262 <= half_window_size)

         {

            half_window_size >>= 1;

            --windowBits;

         }

      }

      /* Check against the previous initialized values, if any. */

      if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) != 0 &&

         (png_ptr->zlib_set_level != level ||

         png_ptr->zlib_set_method != method ||

         png_ptr->zlib_set_window_bits != windowBits ||

         png_ptr->zlib_set_mem_level != memLevel ||

         png_ptr->zlib_set_strategy != strategy))

      {

         if (deflateEnd(&png_ptr->zstream) != Z_OK)

            png_warning(png_ptr, "deflateEnd failed (ignored)");

         png_ptr->flags &= ~PNG_FLAG_ZSTREAM_INITIALIZED;

      }

      /* For safety clear out the input and output pointers (currently zlib

       * doesn't use them on Init, but it might in the future).

       */

      png_ptr->zstream.next_in = NULL;

      png_ptr->zstream.avail_in = 0;

      png_ptr->zstream.next_out = NULL;

      png_ptr->zstream.avail_out = 0;

      /* Now initialize if required, setting the new parameters, otherwise just

       * to a simple reset to the previous parameters.

       */

      if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) != 0)

         ret = deflateReset(&png_ptr->zstream);

      else

      {

         ret = deflateInit2(&png_ptr->zstream, level, method, windowBits,

            memLevel, strategy);

         if (ret == Z_OK)

            png_ptr->flags |= PNG_FLAG_ZSTREAM_INITIALIZED;

      }

      /* The return code is from either deflateReset or deflateInit2; they have

       * pretty much the same set of error codes.

       */

      if (ret == Z_OK)

         png_ptr->zowner = owner;

      else

         png_zstream_error(png_ptr, ret);

      return ret;

   }

}

/* Clean up (or trim) a linked list of compression buffers. */

void /* PRIVATE */

png_free_buffer_list(png_structrp png_ptr, png_compression_bufferp *listp)

{

   png_compression_bufferp list = *listp;

   if (list != NULL)

   {

      *listp = NULL;

      do

      {

         png_compression_bufferp next = list->next;

         png_free(png_ptr, list);

         list = next;

      }

      while (list != NULL);

   }

}

#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 to allow access to the relevant local variables.

 *

 * compression_buffer (new in 1.6.0) is just a linked list of zbuffer_size

 * temporary buffers.  From 1.6.0 it is retained in png_struct so that it will

 * be correctly freed in the event of a write error (previous implementations

 * just leaked memory.)

 */

typedef struct

{

   png_const_bytep      input;        /* The uncompressed input data */

   png_alloc_size_t     input_len;    /* Its length */

   png_uint_32          output_len;   /* Final compressed length */

   png_byte             output[1024]; /* First block of output */

} compression_state;

static void

png_text_compress_init(compression_state *comp, png_const_bytep input,

   png_alloc_size_t input_len)

{

   comp->input = input;

   comp->input_len = input_len;

   comp->output_len = 0;

}

/* Compress the data in the compression state input */

static int

png_text_compress(png_structrp png_ptr, png_uint_32 chunk_name,

   compression_state *comp, png_uint_32 prefix_len)

{

   int ret;

   /* To find the length of the output it is necessary to first compress the

    * input. The result is buffered rather than using the two-pass algorithm

    * that is used on the inflate side; deflate is assumed to be slower and a

    * PNG writer is assumed to have more memory available than a PNG reader.

    *

    * IMPLEMENTATION NOTE: the zlib API deflateBound() can be used to find an

    * upper limit on the output size, but it is always bigger than the input

    * size so it is likely to be more efficient to use this linked-list

    * approach.

    */

   ret = png_deflate_claim(png_ptr, chunk_name, comp->input_len);

   if (ret != Z_OK)

      return ret;

   /* Set up the compression buffers, we need a loop here to avoid overflowing a

    * uInt.  Use ZLIB_IO_MAX to limit the input.  The output is always limited

    * by the output buffer size, so there is no need to check that.  Since this

    * is ANSI-C we know that an 'int', hence a uInt, is always at least 16 bits

    * in size.

    */

   {

      png_compression_bufferp *end = &png_ptr->zbuffer_list;

      png_alloc_size_t input_len = comp->input_len; /* may be zero! */

      png_uint_32 output_len;

      /* zlib updates these for us: */

      png_ptr->zstream.next_in = PNGZ_INPUT_CAST(comp->input);

      png_ptr->zstream.avail_in = 0; /* Set below */

      png_ptr->zstream.next_out = comp->output;

      png_ptr->zstream.avail_out = (sizeof comp->output);

      output_len = png_ptr->zstream.avail_out;

      do

      {

         uInt avail_in = ZLIB_IO_MAX;

         if (avail_in > input_len)

            avail_in = (uInt)input_len;

         input_len -= avail_in;

         png_ptr->zstream.avail_in = avail_in;

         if (png_ptr->zstream.avail_out == 0)

         {

            png_compression_buffer *next;

            /* Chunk data is limited to 2^31 bytes in length, so the prefix

             * length must be counted here.

             */

            if (output_len + prefix_len > PNG_UINT_31_MAX)

            {

               ret = Z_MEM_ERROR;

               break;

            }

            /* Need a new (malloc'ed) buffer, but there may be one present

             * already.

             */

            next = *end;

            if (next == NULL)

            {

               next = png_voidcast(png_compression_bufferp, png_malloc_base

                  (png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr)));

               if (next == NULL)

               {

                  ret = Z_MEM_ERROR;

                  break;

               }

               /* Link in this buffer (so that it will be freed later) */

               next->next = NULL;

               *end = next;

            }

            png_ptr->zstream.next_out = next->output;

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

            output_len += png_ptr->zstream.avail_out;

            /* Move 'end' to the next buffer pointer. */

            end = &next->next;

         }

         /* Compress the data */

         ret = deflate(&png_ptr->zstream,

            input_len > 0 ? Z_NO_FLUSH : Z_FINISH);

         /* Claw back input data that was not consumed (because avail_in is

          * reset above every time round the loop).

          */

         input_len += png_ptr->zstream.avail_in;

         png_ptr->zstream.avail_in = 0; /* safety */

      }

      while (ret == Z_OK);

      /* There may be some space left in the last output buffer. This needs to

       * be subtracted from output_len.

       */

      output_len -= png_ptr->zstream.avail_out;

      png_ptr->zstream.avail_out = 0; /* safety */

      comp->output_len = output_len;

      /* Now double check the output length, put in a custom message if it is

       * too long.  Otherwise ensure the z_stream::msg pointer is set to

       * something.

       */

      if (output_len + prefix_len >= PNG_UINT_31_MAX)

      {

         png_ptr->zstream.msg = PNGZ_MSG_CAST("compressed data too long");

         ret = Z_MEM_ERROR;

      }

      else

         png_zstream_error(png_ptr, ret);

      /* Reset zlib for another zTXt/iTXt or image data */

      png_ptr->zowner = 0;

      /* The only success case is Z_STREAM_END, input_len must be 0; if not this

       * is an internal error.

       */

      if (ret == Z_STREAM_END && input_len == 0)

      {

#ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED

         /* Fix up the deflate header, if required */

         optimize_cmf(comp->output, comp->input_len);

#endif

         /* But Z_OK is returned, not Z_STREAM_END; this allows the claim

          * function above to return Z_STREAM_END on an error (though it never

          * does in the current versions of zlib.)

          */

         return Z_OK;

      }

      else

         return ret;

   }

}

/* Ship the compressed text out via chunk writes */

static void

png_write_compressed_data_out(png_structrp png_ptr, compression_state *comp)

{

   png_uint_32 output_len = comp->output_len;

   png_const_bytep output = comp->output;

   png_uint_32 avail = (sizeof comp->output);

   png_compression_buffer *next = png_ptr->zbuffer_list;

   for (;;)

   {

      if (avail > output_len)

         avail = output_len;

      png_write_chunk_data(png_ptr, output, avail);

      output_len -= avail;

      if (output_len == 0 || next == NULL)

         break;

      avail = png_ptr->zbuffer_size;

      output = next->output;

      next = next->next;

   }

   /* This is an internal error; 'next' must have been NULL! */

   if (output_len > 0)

      png_error(png_ptr, "error writing ancillary chunked compressed data");

}

#endif /* WRITE_COMPRESSED_TEXT */

/* Write the IHDR chunk, and update the png_struct with the necessary

 * information.  Note that the rest of this code depends upon this

 * information being correct.

 */

void /* PRIVATE */

png_write_IHDR(png_structrp png_ptr, png_uint_32 width, png_uint_32 height,

    int bit_depth, int color_type, int compression_type, int filter_type,

    int interlace_type)

{

   png_byte buf[13]; /* Buffer to store the IHDR info */

   png_debug(1, "in png_write_IHDR");

   /* Check that we have valid input data from the application info */

   switch (color_type)

   {

      case PNG_COLOR_TYPE_GRAY:

         switch (bit_depth)

         {

            case 1:

            case 2:

            case 4:

            case 8:

#ifdef PNG_WRITE_16BIT_SUPPORTED

            case 16:

#endif

               png_ptr->channels = 1; break;

            default:

               png_error(png_ptr,

                   "Invalid bit depth for grayscale image");

         }

         break;

      case PNG_COLOR_TYPE_RGB:

#ifdef PNG_WRITE_16BIT_SUPPORTED

         if (bit_depth != 8 && bit_depth != 16)

#else

         if (bit_depth != 8)

#endif

            png_error(png_ptr, "Invalid bit depth for RGB image");

         png_ptr->channels = 3;

         break;

      case PNG_COLOR_TYPE_PALETTE:

         switch (bit_depth)

         {

            case 1:

            case 2:

            case 4:

            case 8:

               png_ptr->channels = 1;

               break;

            default:

               png_error(png_ptr, "Invalid bit depth for paletted image");

         }

         break;

      case PNG_COLOR_TYPE_GRAY_ALPHA:

         if (bit_depth != 8 && bit_depth != 16)

            png_error(png_ptr, "Invalid bit depth for grayscale+alpha image");

         png_ptr->channels = 2;

         break;

      case PNG_COLOR_TYPE_RGB_ALPHA:

#ifdef PNG_WRITE_16BIT_SUPPORTED

         if (bit_depth != 8 && bit_depth != 16)

#else

         if (bit_depth != 8)

#endif

            png_error(png_ptr, "Invalid bit depth for RGBA image");

         png_ptr->channels = 4;

         break;

      default:

         png_error(png_ptr, "Invalid image color type specified");

   }

   if (compression_type != PNG_COMPRESSION_TYPE_BASE)

   {

      png_warning(png_ptr, "Invalid compression type specified");

      compression_type = PNG_COMPRESSION_TYPE_BASE;

   }

   /* Write filter_method 64 (intrapixel differencing) only if

    * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and

    * 2. Libpng did not write a PNG signature (this filter_method is only

    *    used in PNG datastreams that are embedded in MNG datastreams) and

    * 3. The application called png_permit_mng_features with a mask that

    *    included PNG_FLAG_MNG_FILTER_64 and

    * 4. The filter_method is 64 and

    * 5. The color_type is RGB or RGBA

    */

   if (

#ifdef PNG_MNG_FEATURES_SUPPORTED

       !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&

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

       (color_type == PNG_COLOR_TYPE_RGB ||

        color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&

       (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&

#endif

       filter_type != PNG_FILTER_TYPE_BASE)

   {

      png_warning(png_ptr, "Invalid filter type specified");

      filter_type = PNG_FILTER_TYPE_BASE;

   }

#ifdef PNG_WRITE_INTERLACING_SUPPORTED

   if (interlace_type != PNG_INTERLACE_NONE &&

       interlace_type != PNG_INTERLACE_ADAM7)

   {

      png_warning(png_ptr, "Invalid interlace type specified");

      interlace_type = PNG_INTERLACE_ADAM7;

   }

#else

   interlace_type=PNG_INTERLACE_NONE;

#endif

   /* Save the relevant information */

   png_ptr->bit_depth = (png_byte)bit_depth;

   png_ptr->color_type = (png_byte)color_type;

   png_ptr->interlaced = (png_byte)interlace_type;

#ifdef PNG_MNG_FEATURES_SUPPORTED

   png_ptr->filter_type = (png_byte)filter_type;

#endif

   png_ptr->compression_type = (png_byte)compression_type;

   png_ptr->width = width;

   png_ptr->height = height;

   png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);

   png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width);

   /* Set the usr info, so any transformations can modify it */

   png_ptr->usr_width = png_ptr->width;

   png_ptr->usr_bit_depth = png_ptr->bit_depth;

   png_ptr->usr_channels = png_ptr->channels;

   /* Pack the header information into the buffer */

   png_save_uint_32(buf, width);

   png_save_uint_32(buf + 4, height);

   buf[8] = (png_byte)bit_depth;

   buf[9] = (png_byte)color_type;

   buf[10] = (png_byte)compression_type;

   buf[11] = (png_byte)filter_type;

   buf[12] = (png_byte)interlace_type;

   /* Write the chunk */

   png_write_complete_chunk(png_ptr, png_IHDR, buf, (png_size_t)13);

   if ((png_ptr->do_filter) == PNG_NO_FILTERS)

   {

      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||

          png_ptr->bit_depth < 8)

         png_ptr->do_filter = PNG_FILTER_NONE;

      else

         png_ptr->do_filter = PNG_ALL_FILTERS;

   }

   png_ptr->mode = PNG_HAVE_IHDR; /* not READY_FOR_ZTXT */

}

/* Write the palette.  We are careful not to trust png_color to be in the

 * correct order for PNG, so people can redefine it to any convenient

 * structure.

 */

void /* PRIVATE */

png_write_PLTE(png_structrp png_ptr, png_const_colorp palette,

    png_uint_32 num_pal)

{

   png_uint_32 max_palette_length, i;

   png_const_colorp pal_ptr;

   png_byte buf[3];

   png_debug(1, "in png_write_PLTE");

   max_palette_length = (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ?

      (1 << png_ptr->bit_depth) : PNG_MAX_PALETTE_LENGTH;

   if ((

#ifdef PNG_MNG_FEATURES_SUPPORTED

       (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0 &&

#endif

       num_pal == 0) || num_pal > max_palette_length)

   {

      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

      {

         png_error(png_ptr, "Invalid number of colors in palette");

      }

      else

      {

         png_warning(png_ptr, "Invalid number of colors in palette");

         return;

      }

   }

   if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0)

   {

      png_warning(png_ptr,

          "Ignoring request to write a PLTE chunk in grayscale PNG");

      return;

   }

   png_ptr->num_palette = (png_uint_16)num_pal;

   png_debug1(3, "num_palette = %d", png_ptr->num_palette);

   png_write_chunk_header(png_ptr, png_PLTE, (png_uint_32)(num_pal * 3));