Subversion Repositories Kolibri OS

 *

 * Last changed in libpng 1.5.0 [January 6, 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

 */

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

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

}

 * 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_data(png_ptr, data, (png_size_t)length);

   png_write_chunk_end(png_ptr);

}

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

      (unsigned long)length);

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

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

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

   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

}

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

   {

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

}

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

 */

{

   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;

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->max_output_ptr = 0;

   comp->output_ptr = NULL;

   comp->input = NULL;

   comp->input_len = 0;

   if (compression == PNG_TEXT_COMPRESSION_NONE)

   {

      comp->input = (png_const_bytep)text;

      comp->input_len = text_len;

      return((int)text_len);

   }

   {

#ifdef PNG_CONSOLE_IO_SUPPORTED

      char msg[50];

      png_snprintf(msg, 50, "Unknown compression type %d", compression);

      png_warning(png_ptr, msg);

#else

      png_warning(png_ptr, "Unknown compression type");

#endif

   }

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

    */

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

   do

   {

      /* Compress the data */

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

      {

         /* Error */

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

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

            png_error(png_ptr, "zlib error");

      }

      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;

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

            if (comp->output_ptr != NULL)

            {

               png_bytepp old_ptr;

                   (png_alloc_size_t)

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

                   * png_sizeof(png_charp));

            }

            else

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

                   (png_alloc_size_t)

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

         }

         comp->output_ptr[comp->num_output_ptr] =

             (png_bytep)png_malloc(png_ptr,

             (png_alloc_size_t)png_ptr->zbuf_size);

             png_ptr->zbuf_size);

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

   do

   {

      /* Tell zlib we are finished */

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

      {

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

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

         {

            /* Check to make sure our output array has room */

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

            {

               int old_max;

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

               if (comp->output_ptr != NULL)

               {

                  png_bytepp old_ptr;

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

                      (png_alloc_size_t)(comp->max_output_ptr *

                      png_sizeof(png_charp)));

                      old_max * png_sizeof(png_charp));

               }

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

                      (png_alloc_size_t)(comp->max_output_ptr *

                      png_sizeof(png_charp)));

            }

            comp->output_ptr[comp->num_output_ptr] =

                (png_bytep)png_malloc(png_ptr,

                (png_alloc_size_t)png_ptr->zbuf_size);

                png_ptr->zbuf_size);

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

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

         }

      }

      else if (ret != Z_STREAM_END)

      {

         /* We got an error */

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

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

            png_error(png_ptr, "zlib error");

      }

   } while (ret != Z_STREAM_END);

   text_len = png_ptr->zbuf_size * comp->num_output_ptr;

      text_len += png_ptr->zbuf_size - (png_size_t)png_ptr->zstream.avail_out;

}

static void /* PRIVATE */

png_write_compressed_data_out(png_structp png_ptr, compression_state *comp)

{

   int i;

   if (comp->input)

   {

      png_write_chunk_data(png_ptr, comp->input, comp->input_len);

   }

   for (i = 0; i < comp->num_output_ptr; i++)

   {

      png_write_chunk_data(png_ptr, comp->output_ptr[i],

          (png_size_t)png_ptr->zbuf_size);

   }

      png_free(png_ptr, comp->output_ptr);

   if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size)

      png_write_chunk_data(png_ptr, png_ptr->zbuf,

          (png_size_t)(png_ptr->zbuf_size - png_ptr->zstream.avail_out));

   deflateReset(&png_ptr->zstream);

   png_ptr->zstream.data_type = Z_BINARY;

}

#endif

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

 * information being correct.

 */

void /* PRIVATE */

png_write_IHDR(png_structp 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_IHDR;

   int ret;

   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_chunk(png_ptr, png_IHDR, buf, (png_size_t)13);

   png_ptr->zstream.zalloc = png_zalloc;

   png_ptr->zstream.zfree = png_zfree;

   png_ptr->zstream.opaque = (voidpf)png_ptr;

   {

      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;

   }

   {

      if (png_ptr->do_filter != PNG_FILTER_NONE)

         png_ptr->zlib_strategy = Z_FILTERED;

         png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY;

   }

      png_ptr->zlib_level = Z_DEFAULT_COMPRESSION;

      png_ptr->zlib_mem_level = 8;

      png_ptr->zlib_window_bits = 15;

      png_ptr->zlib_method = 8;

       png_ptr->zlib_method, png_ptr->zlib_window_bits,

       png_ptr->zlib_mem_level, png_ptr->zlib_strategy);

   {

      if (ret == Z_VERSION_ERROR)

         png_error(png_ptr,

            "zlib failed to initialize compressor -- version error");

         png_error(png_ptr,

             "zlib failed to initialize compressor -- stream error");

         png_error(png_ptr,

             "zlib failed to initialize compressor -- mem error");

   }

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

   /* libpng is not interested in zstream.data_type, so set it

    * to a predefined value, to avoid its evaluation inside zlib

    */

   png_ptr->zstream.data_type = Z_BINARY;

}

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

 * structure.

 */

void /* PRIVATE */

png_write_PLTE(png_structp png_ptr, png_const_colorp palette,

    png_uint_32 num_pal)

{

   PNG_PLTE;

   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;

}

void /* PRIVATE */

png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)

{

   PNG_IDAT;

   /* This hack of the zlib stream is compliant to the stream specification. */

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

       png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)

   {

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

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

      {

         /* Avoid memory underflows and multiplication overflows.

          *

          * The conditions below are practically always satisfied;

          * however, they still must be checked.

          */

         if (length >= 2 &&

             png_ptr->height < 16384 && png_ptr->width < 16384)

         {

            png_uint_32 uncompressed_idat_size = png_ptr->height *

                ((png_ptr->width *

                png_ptr->channels * png_ptr->bit_depth + 15) >> 3);

            unsigned int z_cinfo = z_cmf >> 4;

            unsigned int half_z_window_size = 1 << (z_cinfo + 7);

            while (uncompressed_idat_size <= half_z_window_size &&

                half_z_window_size >= 256)

            {

               z_cinfo--;

               half_z_window_size >>= 1;

            }

            {

               int tmp;

               data[0] = (png_byte)z_cmf;

               tmp = data[1] & 0xe0;

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

               data[1] = (png_byte)tmp;

            }

         }

      }

         png_error(png_ptr,

             "Invalid zlib compression method or flags in IDAT");

   }

   png_ptr->mode |= PNG_HAVE_IDAT;

}

void /* PRIVATE */

png_write_IEND(png_structp png_ptr)

{

   PNG_IEND;

   png_ptr->mode |= PNG_HAVE_IEND;

}

/* Write a gAMA chunk */

void /* PRIVATE */

png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma)

{

   PNG_gAMA;

   png_byte buf[4];

   png_save_uint_32(buf, (png_uint_32)file_gamma);

   png_write_chunk(png_ptr, png_gAMA, buf, (png_size_t)4);

}

#endif

/* Write a sRGB chunk */

void /* PRIVATE */

png_write_sRGB(png_structp png_ptr, int srgb_intent)

{

   PNG_sRGB;

   png_byte buf[1];

      png_warning(png_ptr,

          "Invalid sRGB rendering intent specified");

   png_write_chunk(png_ptr, png_sRGB, buf, (png_size_t)1);

}

#endif

/* Write an iCCP chunk */

void /* PRIVATE */

png_write_iCCP(png_structp png_ptr, png_const_charp name, int compression_type,

    png_const_charp profile, int profile_len)

{

   PNG_iCCP;

   png_size_t name_len;

   png_charp new_name;

   compression_state comp;

   int embedded_profile_len = 0;

   comp.max_output_ptr = 0;

   comp.output_ptr = NULL;

   comp.input = NULL;

   comp.input_len = 0;

      return;

      png_warning(png_ptr, "Unknown compression type in iCCP chunk");

      profile_len = 0;

      embedded_profile_len =

          ((*( (png_const_bytep)profile    ))<<24) |

          ((*( (png_const_bytep)profile + 1))<<16) |

          ((*( (png_const_bytep)profile + 2))<< 8) |

          ((*( (png_const_bytep)profile + 3))    );

   {

      png_warning(png_ptr,

          "Embedded profile length in iCCP chunk is negative");

      return;

   }

   {

      png_warning(png_ptr,

          "Embedded profile length too large in iCCP chunk");

      return;

   }

   {

      png_warning(png_ptr,

          "Truncating profile to actual length in iCCP chunk");

   }

      profile_len = png_text_compress(png_ptr, profile,

          (png_size_t)profile_len, PNG_COMPRESSION_TYPE_BASE, &comp);

   png_write_chunk_start(png_ptr, png_iCCP,

       (png_uint_32)(name_len + profile_len + 2));

       (png_size_t)(name_len + 2));

      png_write_compressed_data_out(png_ptr, &comp);

   png_free(png_ptr, new_name);

}

#endif

/* Write a sPLT chunk */

void /* PRIVATE */

png_write_sPLT(png_structp png_ptr, png_const_sPLT_tp spalette)

{

   PNG_sPLT;

   png_size_t name_len;

   png_charp new_name;

   png_byte entrybuf[10];

   png_size_t entry_size = (spalette->depth == 8 ? 6 : 10);

   png_size_t palette_size = entry_size * spalette->nentries;

   png_sPLT_entryp ep;

#ifndef PNG_POINTER_INDEXING_SUPPORTED

   int i;

#endif

      return;

   png_write_chunk_start(png_ptr, png_sPLT,

       (png_uint_32)(name_len + 2 + palette_size));

       (png_size_t)(name_len + 1));

#ifdef PNG_POINTER_INDEXING_SUPPORTED

   for (ep = spalette->entries; epentries + spalette->nentries; ep++)

   {

      if (spalette->depth == 8)

      {

         entrybuf[0] = (png_byte)ep->red;

         entrybuf[1] = (png_byte)ep->green;

         entrybuf[2] = (png_byte)ep->blue;

         entrybuf[3] = (png_byte)ep->alpha;

         png_save_uint_16(entrybuf + 4, ep->frequency);

      }

      {

         png_save_uint_16(entrybuf + 0, ep->red);

         png_save_uint_16(entrybuf + 2, ep->green);

         png_save_uint_16(entrybuf + 4, ep->blue);

         png_save_uint_16(entrybuf + 6, ep->alpha);

         png_save_uint_16(entrybuf + 8, ep->frequency);

      }

   }

#else

   ep=spalette->entries;

   for (i = 0; i>spalette->nentries; i++)

   {

      if (spalette->depth == 8)

      {

         entrybuf[0] = (png_byte)ep[i].red;

         entrybuf[1] = (png_byte)ep[i].green;

         entrybuf[2] = (png_byte)ep[i].blue;

         entrybuf[3] = (png_byte)ep[i].alpha;

         png_save_uint_16(entrybuf + 4, ep[i].frequency);

      }

      {

         png_save_uint_16(entrybuf + 0, ep[i].red);

         png_save_uint_16(entrybuf + 2, ep[i].green);

         png_save_uint_16(entrybuf + 4, ep[i].blue);

         png_save_uint_16(entrybuf + 6, ep[i].alpha);

         png_save_uint_16(entrybuf + 8, ep[i].frequency);

      }

   }

#endif

   png_free(png_ptr, new_name);

}

#endif

/* Write the sBIT chunk */

void /* PRIVATE */

png_write_sBIT(png_structp png_ptr, png_const_color_8p sbit, int color_type)

{

   PNG_sBIT;

   png_byte buf[4];

   png_size_t size;

   if (color_type & PNG_COLOR_MASK_COLOR)

   {

      png_byte maxbits;

          png_ptr->usr_bit_depth);

          sbit->green == 0 || sbit->green > maxbits ||

          sbit->blue == 0 || sbit->blue > maxbits)

      {

         png_warning(png_ptr, "Invalid sBIT depth specified");

         return;

      }

      buf[1] = sbit->green;

      buf[2] = sbit->blue;

      size = 3;

   }

   {

      if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth)

      {

         png_warning(png_ptr, "Invalid sBIT depth specified");

         return;

      }

      size = 1;

   }

   {

      if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth)

      {

         png_warning(png_ptr, "Invalid sBIT depth specified");

         return;

      }

   }

}

#endif

/* Write the cHRM chunk */

void /* PRIVATE */

png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x,

    png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y,

    png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x,

    png_fixed_point blue_y)

{

   PNG_cHRM;

   png_byte buf[32];

#ifdef PNG_CHECK_cHRM_SUPPORTED

   if (png_check_cHRM_fixed(png_ptr, white_x, white_y, red_x, red_y,

       green_x, green_y, blue_x, blue_y))

#endif

   {

      png_save_uint_32(buf, (png_uint_32)white_x);

      png_save_uint_32(buf + 4, (png_uint_32)white_y);

      png_save_uint_32(buf + 12, (png_uint_32)red_y);

      png_save_uint_32(buf + 20, (png_uint_32)green_y);

      png_save_uint_32(buf + 28, (png_uint_32)blue_y);

   }

}

#endif

/* Write the tRNS chunk */

void /* PRIVATE */

png_write_tRNS(png_structp png_ptr, png_const_bytep trans_alpha,

    png_const_color_16p tran, int num_trans, int color_type)

{

   PNG_tRNS;

   png_byte buf[6];

   {

      if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)

      {

         png_warning(png_ptr, "Invalid number of transparent colors specified");

         return;

      }

      png_write_chunk(png_ptr, png_tRNS, trans_alpha, (png_size_t)num_trans);

   }