Subversion Repositories Kolibri OS

 *

 * Last changed in libpng 1.6.2 [April 25, 2013]

 * Copyright (c) 1998-2013 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

 */

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

}

 * 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

 * 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};

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

   png_ptr->io_state = PNG_IO_WRITING | PNG_IO_SIGNATURE;

#endif

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

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

      png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;

}

 * 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];

   PNG_CSTRING_FROM_CHUNK(buf, chunk_name);

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

#endif

      return;

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

   png_save_uint_32(buf, length);

   png_save_uint_32(buf + 4, chunk_name);

   png_write_data(png_ptr, buf, 8);

   png_ptr->chunk_name = chunk_name;

   png_reset_crc(png_ptr);

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

}

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

}

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

   {

      png_write_data(png_ptr, data, length);

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

       */

      png_calculate_crc(png_ptr, data, length);

   }

}

void PNGAPI

png_write_chunk_end(png_structrp png_ptr)

{

   png_byte buf[4];

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

   png_save_uint_32(buf, png_ptr->crc);

}

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

   if (length > PNG_UINT_31_MAX)

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

   png_write_chunk_data(png_ptr, data, length);

   png_write_chunk_end(png_ptr);

}

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

}

 * 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->interlaced)

      {

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

         {

            png_uint_32 pw = PNG_PASS_COLS(w, pass);

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

         }

      }

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

   }

      return 0xffffffffU;

}

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

      {

         unsigned int z_cinfo;

         unsigned int half_z_window_size;

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

         {

            unsigned int tmp;

            {

               half_z_window_size >>= 1;

               --z_cinfo;

            }

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

            tmp = data[1] & 0xe0;

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

            data[1] = (png_byte)tmp;

         }

      }

   }

}

#else

#  define optimize_cmf(dp,dl) ((void)0)

#endif /* PNG_WRITE_OPTIMIZE_CMF_SUPPORTED */

static int

png_deflate_claim(png_structrp png_ptr, png_uint_32 owner,

   png_alloc_size_t data_size)

{

   if (png_ptr->zowner != 0)

   {

      char msg[64];

      msg[4] = ':';

      msg[5] = ' ';

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

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

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

       * are minimal.

       */

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

#     if PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC

         png_warning(png_ptr, msg);

         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;

         }

#     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 (png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY)

            strategy = png_ptr->zlib_strategy;

            strategy = PNG_Z_DEFAULT_STRATEGY;

            strategy = PNG_Z_DEFAULT_NOFILTER_STRATEGY;

      }

      {

#        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

      }

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

         {

            half_window_size >>= 1;

            --windowBits;

         }

      }

      if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) &&

         (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)");

      }

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

       * to a simple reset to the previous parameters.

       */

      if (png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED)

         ret = deflateReset(&png_ptr->zstream);

      {

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

            memLevel, strategy);

            png_ptr->flags |= PNG_FLAG_ZSTREAM_INITIALIZED;

      }

       * pretty much the same set of error codes.

       */

      if (ret == Z_OK)

         png_ptr->zowner = owner;

         png_zstream_error(png_ptr, ret);

   }

}

void /* PRIVATE */

png_free_buffer_list(png_structrp png_ptr, png_compression_bufferp *listp)

{

   png_compression_bufferp list = *listp;

   {

      *listp = NULL;

      {

         png_compression_bufferp next = list->next;

         list = next;

      }

      while (list != NULL);

   }

}

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

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;

}

static int

png_text_compress(png_structrp png_ptr, png_uint_32 chunk_name,

   compression_state *comp, png_uint_32 prefix_len)

{

   int ret;

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

      return ret;

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

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

      {

         uInt avail_in = ZLIB_IO_MAX;

            avail_in = (uInt)input_len;

         {

            png_compression_buffer *next;

             * length must be counted here.

             */

            if (output_len + prefix_len > PNG_UINT_31_MAX)

            {

               ret = Z_MEM_ERROR;

               break;

            }

             * already.

             */

            next = *end;

            if (next == NULL)

            {

               next = png_voidcast(png_compression_bufferp, png_malloc_base

                  (png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr)));

               {

                  ret = Z_MEM_ERROR;

                  break;

               }

               next->next = NULL;

               *end = next;

            }

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

            output_len += png_ptr->zstream.avail_out;

            end = &next->next;

         }

         ret = deflate(&png_ptr->zstream,

            input_len > 0 ? Z_NO_FLUSH : Z_FINISH);

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

       * be subtracted from output_len.

       */

      output_len -= png_ptr->zstream.avail_out;

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

      comp->output_len = output_len;

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

      }

         png_zstream_error(png_ptr, ret);

      png_ptr->zowner = 0;

       * is an internal error.

       */

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

      {

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

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

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

          * does in the current versions of zlib.)

          */

         return Z_OK;

      }

         return ret;

   }

}

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;

   {

      if (avail > output_len)

         avail = output_len;

         break;

      output = next->output;

      next = next->next;

   }

   if (output_len > 0)

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

}

#endif /* PNG_WRITE_COMPRESSED_TEXT_SUPPORTED */

    defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)

/* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification,

 * and if invalid, correct the keyword rather than discarding the entire

 * chunk.  The PNG 1.0 specification requires keywords 1-79 characters in

 * length, forbids leading or trailing whitespace, multiple internal spaces,

 * and the non-break space (0x80) from ISO 8859-1.  Returns keyword length.

 *

 * The 'new_key' buffer must be 80 characters in size (for the keyword plus a

 * trailing '\0').  If this routine returns 0 then there was no keyword, or a

 * valid one could not be generated, and the caller must png_error.

 */

static png_uint_32

png_check_keyword(png_structrp png_ptr, png_const_charp key, png_bytep new_key)

{

   png_const_charp orig_key = key;

   png_uint_32 key_len = 0;

   int bad_character = 0;

   int space = 1;

   {

      *new_key = 0;

      return 0;

   }

   {

      png_byte ch = (png_byte)(0xff & *key++);

         *new_key++ = ch, ++key_len, space = 0;

      {

         /* A space or an invalid character when one wasn't seen immediately

          * before; output just a space.

          */

         *new_key++ = 32, ++key_len, space = 1;

         if (ch != 32)

            bad_character = ch;

      }

         bad_character = ch; /* just skip it, record the first error */

   }

   {

      --key_len, --new_key;

      if (!bad_character)

         bad_character = 32;

   }

   *new_key = 0;

      return 0;

   if (*key) /* keyword too long */

      png_warning(png_ptr, "keyword truncated");

   {

      PNG_WARNING_PARAMETERS(p)

      png_warning_parameter_signed(p, 2, PNG_NUMBER_FORMAT_02x, bad_character);

   }

}

#endif

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

   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;

               png_error(png_ptr,

                   "Invalid bit depth for grayscale image");

         }

         break;

#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");

         break;

         switch (bit_depth)

         {

            case 1:

            case 2:

            case 4:

            case 8:

               png_ptr->channels = 1;

               break;

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

         }

         break;

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

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

         break;

#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");

         break;

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

   }

   {

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

      compression_type = PNG_COMPRESSION_TYPE_BASE;

   }

    * 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) &&

       ((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;

   }

   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

   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->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;

   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;

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

   {

      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||

          png_ptr->bit_depth < 8)

         png_ptr->do_filter = PNG_FILTER_NONE;

         png_ptr->do_filter = PNG_ALL_FILTERS;

   }

}

 * 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 i;

   png_const_colorp pal_ptr;

   png_byte buf[3];

#ifdef PNG_MNG_FEATURES_SUPPORTED

       !(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) &&

#endif

       num_pal == 0) || num_pal > 256)

   {

      if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

      {

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

      }

      {

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

         return;

      }

   }

   {

      png_warning(png_ptr,

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

   }

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

#ifdef PNG_POINTER_INDEXING_SUPPORTED

   {

      buf[0] = pal_ptr->red;

      buf[1] = pal_ptr->green;

      buf[2] = pal_ptr->blue;

      png_write_chunk_data(png_ptr, buf, (png_size_t)3);

   }

   /* This is a little slower but some buggy compilers need to do this

    * instead

    */

   pal_ptr=palette;

   {

      buf[0] = pal_ptr[i].red;

      buf[1] = pal_ptr[i].green;

      buf[2] = pal_ptr[i].blue;

      png_write_chunk_data(png_ptr, buf, (png_size_t)3);

   }

   png_write_chunk_end(png_ptr);

   png_ptr->mode |= PNG_HAVE_PLTE;

}

 * all of the data at once and, instead of buffering the compressed result,

 * writes it as IDAT chunks.  Unlike png_text_compress it *can* png_error out

 * because it calls the write interface.  As a result it does its own error

 * reporting and does not return an error code.  In the event of error it will

 * just call png_error.  The input data length may exceed 32-bits.  The 'flush'

 * parameter is exactly the same as that to deflate, with the following

 * meanings:

 *

 * Z_NO_FLUSH: normal incremental output of compressed data

 * Z_SYNC_FLUSH: do a SYNC_FLUSH, used by png_write_flush

 * Z_FINISH: this is the end of the input, do a Z_FINISH and clean up

 *

 * The routine manages the acquire and release of the png_ptr->zstream by

 * checking and (at the end) clearing png_ptr->zowner, it does some sanity

 * checks on the 'mode' flags while doing this.

 */

void /* PRIVATE */

png_compress_IDAT(png_structrp png_ptr, png_const_bytep input,

   png_alloc_size_t input_len, int flush)

{

   if (png_ptr->zowner != png_IDAT)

   {

      /* First time.   Ensure we have a temporary buffer for compression and

       * trim the buffer list if it has more than one entry to free memory.

       * If 'WRITE_COMPRESSED_TEXT' is not set the list will never have been

       * created at this point, but the check here is quick and safe.

       */

      if (png_ptr->zbuffer_list == NULL)

      {

         png_ptr->zbuffer_list = png_voidcast(png_compression_bufferp,

            png_malloc(png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr)));

         png_ptr->zbuffer_list->next = NULL;

      }

         png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list->next);

      if (png_deflate_claim(png_ptr, png_IDAT, png_image_size(png_ptr)) != Z_OK)

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

       * initialized here after the claim.

       */

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

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

   }

    * terminates the operation.  The _out values are maintained across calls to

    * this function, but the input must be reset each time.

    */

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

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

   for (;;)

   {

      int ret;

      uInt avail = ZLIB_IO_MAX;

         avail = (uInt)input_len; /* safe because of the check */

      input_len -= avail;

      input_len += png_ptr->zstream.avail_in;

      png_ptr->zstream.avail_in = 0;

       * that these two zstream fields are preserved across the calls, therefore

       * there is no need to set these up on entry to the loop.

       */

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

      {

         png_bytep data = png_ptr->zbuffer_list->output;

         uInt size = png_ptr->zbuffer_size;

          * first IDAT may need deflate header optimization.

          */

#        ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED

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

               png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)

               optimize_cmf(data, png_image_size(png_ptr));

#        endif

         png_ptr->mode |= PNG_HAVE_IDAT;

         png_ptr->zstream.avail_out = size;

          * the same flush parameter until it has finished output, for NO_FLUSH

          * it doesn't matter.

          */

         if (ret == Z_OK && flush != Z_NO_FLUSH)

            continue;

      }

       * possible error might be detected if multiple things go wrong at once.

       */

      if (ret == Z_OK) /* most likely return code! */

      {

         /* If all the input has been consumed then just return.  If Z_FINISH

          * was used as the flush parameter something has gone wrong if we get

          * here.

          */

         if (input_len == 0)

         {

            if (flush == Z_FINISH)

               png_error(png_ptr, "Z_OK on Z_FINISH with output space");