Subversion Repositories Kolibri OS

 *

 * Last changed in libpng 1.6.4 [September 14, 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

 *

 * This file contains routines that are only called from within

 * libpng itself during the course of reading an image.

 */

png_get_uint_31(png_const_structrp png_ptr, png_const_bytep buf)

{

   png_uint_32 uval = png_get_uint_32(buf);

      png_error(png_ptr, "PNG unsigned integer out of range");

}

/* The following is a variation on the above for use with the fixed

 * point values used for gAMA and cHRM.  Instead of png_error it

 * issues a warning and returns (-1) - an invalid value because both

 * gAMA and cHRM use *unsigned* integers for fixed point values.

 */

#define PNG_FIXED_ERROR (-1)

png_get_fixed_point(png_structrp png_ptr, png_const_bytep buf)

{

   png_uint_32 uval = png_get_uint_32(buf);

      return (png_fixed_point)uval; /* known to be in range */

   if (png_ptr != NULL)

      png_warning(png_ptr, "PNG fixed point integer out of range");

}

#endif

/* NOTE: the read macros will obscure these definitions, so that if

 * PNG_USE_READ_MACROS is set the library will not use them internally,

 * but the APIs will still be available externally.

 *

 * The parentheses around "PNGAPI function_name" in the following three

 * functions are necessary because they allow the macros to co-exist with

 * these (unused but exported) functions.

 */

png_uint_32 (PNGAPI

png_get_uint_32)(png_const_bytep buf)

{

   png_uint_32 uval =

       ((png_uint_32)(*(buf    )) << 24) +

       ((png_uint_32)(*(buf + 1)) << 16) +

       ((png_uint_32)(*(buf + 2)) <<  8) +

       ((png_uint_32)(*(buf + 3))      ) ;

}

 * data is stored in the PNG file in two's complement format and there

 * is no guarantee that a 'png_int_32' is exactly 32 bits, therefore

 * the following code does a two's complement to native conversion.

 */

png_int_32 (PNGAPI

png_get_int_32)(png_const_bytep buf)

{

   png_uint_32 uval = png_get_uint_32(buf);

   if ((uval & 0x80000000) == 0) /* non-negative */

      return uval;

   return -(png_int_32)uval;

}

png_uint_16 (PNGAPI

png_get_uint_16)(png_const_bytep buf)

{

   /* ANSI-C requires an int value to accomodate at least 16 bits so this

    * works and allows the compiler not to worry about possible narrowing

    * on 32 bit systems.  (Pre-ANSI systems did not make integers smaller

    * than 16 bits either.)

    */

   unsigned int val =

       ((unsigned int)(*buf) << 8) +

       ((unsigned int)(*(buf + 1)));

}

void /* PRIVATE */

png_read_sig(png_structrp png_ptr, png_inforp info_ptr)

{

   png_size_t num_checked, num_to_check;

   if (png_ptr->sig_bytes >= 8)

      return;

   num_to_check = 8 - num_checked;

   png_ptr->io_state = PNG_IO_READING | PNG_IO_SIGNATURE;

#endif

   png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check);

   png_ptr->sig_bytes = 8;

   {

      if (num_checked < 4 &&

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

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

      else

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

   }

   if (num_checked < 3)

      png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;

}

 * Put the type name into png_ptr->chunk_name, and return the length.

 */

png_uint_32 /* PRIVATE */

png_read_chunk_header(png_structrp png_ptr)

{

   png_byte buf[8];

   png_uint_32 length;

   png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_HDR;

#endif

    * This must be performed in a single I/O call.

    */

   png_read_data(png_ptr, buf, 8);

   length = png_get_uint_31(png_ptr, buf);

   png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(buf+4);

       (unsigned long)png_ptr->chunk_name, (unsigned long)length);

   png_reset_crc(png_ptr);

   png_calculate_crc(png_ptr, buf + 4, 4);

   png_check_chunk_name(png_ptr, png_ptr->chunk_name);

   png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_DATA;

#endif

}

void /* PRIVATE */

png_crc_read(png_structrp png_ptr, png_bytep buf, png_uint_32 length)

{

   if (png_ptr == NULL)

      return;

   png_calculate_crc(png_ptr, buf, length);

}

 * are reading an ancillary or critical chunk, and how the program has set

 * things up, we may calculate the CRC on the data and print a message.

 * Returns '1' if there was a CRC error, '0' otherwise.

 */

int /* PRIVATE */

png_crc_finish(png_structrp png_ptr, png_uint_32 skip)

{

   /* The size of the local buffer for inflate is a good guess as to a

    * reasonable size to use for buffering reads from the application.

    */

   while (skip > 0)

   {

      png_uint_32 len;

      png_byte tmpbuf[PNG_INFLATE_BUF_SIZE];

      if (len > skip)

         len = skip;

      skip -= len;

   }

   {

      if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name) ?

          !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) :

          (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE))

      {

         png_chunk_warning(png_ptr, "CRC error");

      }

      {

         png_chunk_benign_error(png_ptr, "CRC error");

         return (0);

      }

   }

}

 * the data it has read thus far.

 */

int /* PRIVATE */

png_crc_error(png_structrp png_ptr)

{

   png_byte crc_bytes[4];

   png_uint_32 crc;

   int need_crc = 1;

   {

      if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==

          (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))

         need_crc = 0;

   }

   {

      if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)

         need_crc = 0;

   }

   png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_CRC;

#endif

   png_read_data(png_ptr, crc_bytes, 4);

   {

      crc = png_get_uint_32(crc_bytes);

      return ((int)(crc != png_ptr->crc));

   }

      return (0);

}

 * enough (or if it is not allocated).  The routine returns a pointer to the

 * buffer; if an error occurs and 'warn' is set the routine returns NULL, else

 * it will call png_error (via png_malloc) on failure.  (warn == 2 means

 * 'silent').

 */

static png_bytep

png_read_buffer(png_structrp png_ptr, png_alloc_size_t new_size, int warn)

{

   png_bytep buffer = png_ptr->read_buffer;

   {

      png_ptr->read_buffer = NULL;

      png_ptr->read_buffer = NULL;

      png_ptr->read_buffer_size = 0;

      png_free(png_ptr, buffer);

      buffer = NULL;

   }

   {

      buffer = png_voidcast(png_bytep, png_malloc_base(png_ptr, new_size));

      {

         png_ptr->read_buffer = buffer;

         png_ptr->read_buffer_size = new_size;

      }

      {

#ifdef PNG_WARNINGS_SUPPORTED

         if (warn)

             png_chunk_warning(png_ptr, "insufficient memory to read chunk");

         else

#endif

         {

#ifdef PNG_ERROR_TEXT_SUPPORTED

             png_chunk_error(png_ptr, "insufficient memory to read chunk");

#endif

         }

      }

   }

}

 * decompression.  Returns Z_OK on success, else a zlib error code.  It checks

 * the owner but, in final release builds, just issues a warning if some other

 * chunk apparently owns the stream.  Prior to release it does a png_error.

 */

static int

png_inflate_claim(png_structrp png_ptr, png_uint_32 owner)

{

   if (png_ptr->zowner != 0)

   {

      char msg[64];

      /* 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), 4, " using zstream");

#     if PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC

         png_chunk_warning(png_ptr, msg);

         png_ptr->zowner = 0;

#     else

         png_chunk_error(png_ptr, msg);

#     endif

   }

    * does not take the size of the data as an argument.  Some efficiency could

    * be gained by using this when it is known *if* the zlib stream itself does

    * not record the number; however, this is an illusion: the original writer

    * of the PNG may have selected a lower window size, and we really must

    * follow that because, for systems with with limited capabilities, we

    * would otherwise reject the application's attempts to use a smaller window

    * size (zlib doesn't have an interface to say "this or lower"!).

    *

    * inflateReset2 was added to zlib 1.2.4; before this the window could not be

    * reset, therefore it is necessary to always allocate the maximum window

    * size with earlier zlibs just in case later compressed chunks need it.

    */

   {

      int ret; /* zlib return code */

#     if PNG_ZLIB_VERNUM >= 0x1240

            defined(PNG_MAXIMUM_INFLATE_WINDOW)

            int window_bits;

               PNG_OPTION_ON)

               window_bits = 15;

               window_bits = 0;

#        else

#           define window_bits 0

#        endif

#     endif

       * memory allocations.

       */

      png_ptr->zstream.next_in = NULL;

      png_ptr->zstream.avail_in = 0;

      png_ptr->zstream.next_out = NULL;

      png_ptr->zstream.avail_out = 0;

      {

#        if PNG_ZLIB_VERNUM < 0x1240

            ret = inflateReset(&png_ptr->zstream);

#        else

            ret = inflateReset2(&png_ptr->zstream, window_bits);

#        endif

      }

      {

#        if PNG_ZLIB_VERNUM < 0x1240

            ret = inflateInit(&png_ptr->zstream);

#        else

            ret = inflateInit2(&png_ptr->zstream, window_bits);

#        endif

            png_ptr->flags |= PNG_FLAG_ZSTREAM_INITIALIZED;

      }

         png_ptr->zowner = owner;

         png_zstream_error(png_ptr, ret);

   }

#     undef window_bits

#  endif

}

/* png_inflate now returns zlib error codes including Z_OK and Z_STREAM_END to

 * allow the caller to do multiple calls if required.  If the 'finish' flag is

 * set Z_FINISH will be passed to the final inflate() call and Z_STREAM_END must

 * be returned or there has been a problem, otherwise Z_SYNC_FLUSH is used and

 * Z_OK or Z_STREAM_END will be returned on success.

 *

 * The input and output sizes are updated to the actual amounts of data consumed

 * or written, not the amount available (as in a z_stream).  The data pointers

 * are not changed, so the next input is (data+input_size) and the next

 * available output is (output+output_size).

 */

static int

png_inflate(png_structrp png_ptr, png_uint_32 owner, int finish,

    /* INPUT: */ png_const_bytep input, png_uint_32p input_size_ptr,

    /* OUTPUT: */ png_bytep output, png_alloc_size_t *output_size_ptr)

{

   if (png_ptr->zowner == owner) /* Else not claimed */

   {

      int ret;

      png_alloc_size_t avail_out = *output_size_ptr;

      png_uint_32 avail_in = *input_size_ptr;

       * can't even necessarily handle 65536 bytes) because the type uInt is

       * "16 bits or more".  Consequently it is necessary to chunk the input to

       * zlib.  This code uses ZLIB_IO_MAX, from pngpriv.h, as the maximum (the

       * maximum value that can be stored in a uInt.)  It is possible to set

       * ZLIB_IO_MAX to a lower value in pngpriv.h and this may sometimes have

       * a performance advantage, because it reduces the amount of data accessed

       * at each step and that may give the OS more time to page it in.

       */

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

      /* avail_in and avail_out are set below from 'size' */

      png_ptr->zstream.avail_in = 0;

      png_ptr->zstream.avail_out = 0;

       * a local buffer below if output is NULL).

       */

      if (output != NULL)

         png_ptr->zstream.next_out = output;

      {

         uInt avail;

         Byte local_buffer[PNG_INFLATE_BUF_SIZE];

         /* The setting of 'avail_in' used to be outside the loop; by setting it

          * inside it is possible to chunk the input to zlib and simply rely on

          * zlib to advance the 'next_in' pointer.  This allows arbitrary

          * amounts of data to be passed through zlib at the unavoidable cost of

          * requiring a window save (memcpy of up to 32768 output bytes)

          * every ZLIB_IO_MAX input bytes.

          */

         avail_in += png_ptr->zstream.avail_in; /* not consumed last time */

            avail = (uInt)avail_in; /* safe: < than ZLIB_IO_MAX */

         png_ptr->zstream.avail_in = avail;

         avail_out += png_ptr->zstream.avail_out; /* not written last time */

         {

            /* Reset the output buffer each time round if output is NULL and

             * make available the full buffer, up to 'remaining_space'

             */

            png_ptr->zstream.next_out = local_buffer;

            if ((sizeof local_buffer) < avail)

               avail = (sizeof local_buffer);

         }

            avail = (uInt)avail_out; /* safe: < ZLIB_IO_MAX */

         avail_out -= avail;

         /* In fact 'avail_out' may be 0 at this point, that happens at the end

          * of the read when the final LZ end code was not passed at the end of

          * the previous chunk of input data.  Tell zlib if we have reached the

          * end of the output buffer.

          */

         ret = inflate(&png_ptr->zstream, avail_out > 0 ? Z_NO_FLUSH :

            (finish ? Z_FINISH : Z_SYNC_FLUSH));

      } while (ret == Z_OK);

      if (output == NULL)

         png_ptr->zstream.next_out = NULL;

      avail_in += png_ptr->zstream.avail_in;

      avail_out += png_ptr->zstream.avail_out;

       * consumed or written, effectively the inverse of what zlib uses.

       */

      if (avail_out > 0)

         *output_size_ptr -= avail_out;

         *input_size_ptr -= avail_in;

      png_zstream_error(png_ptr, ret);

      return ret;

   }

   {

      /* This is a bad internal error.  The recovery assigns to the zstream msg

       * pointer, which is not owned by the caller, but this is safe; it's only

       * used on errors!

       */

      png_ptr->zstream.msg = PNGZ_MSG_CAST("zstream unclaimed");

      return Z_STREAM_ERROR;

   }

}

 * Decompress trailing data in a chunk.  The assumption is that read_buffer

 * points at an allocated area holding the contents of a chunk with a

 * trailing compressed part.  What we get back is an allocated area

 * holding the original prefix part and an uncompressed version of the

 * trailing part (the malloc area passed in is freed).

 */

static int

png_decompress_chunk(png_structrp png_ptr,

   png_uint_32 chunklength, png_uint_32 prefix_size,

   png_alloc_size_t *newlength /* must be initialized to the maximum! */,

   int terminate /*add a '\0' to the end of the uncompressed data*/)

{

   /* TODO: implement different limits for different types of chunk.

    *

    * The caller supplies *newlength set to the maximum length of the

    * uncompressed data, but this routine allocates space for the prefix and

    * maybe a '\0' terminator too.  We have to assume that 'prefix_size' is

    * limited only by the maximum chunk size.

    */

   png_alloc_size_t limit = PNG_SIZE_MAX;

      if (png_ptr->user_chunk_malloc_max > 0 &&

         png_ptr->user_chunk_malloc_max < limit)

         limit = png_ptr->user_chunk_malloc_max;

#  elif PNG_USER_CHUNK_MALLOC_MAX > 0

      if (PNG_USER_CHUNK_MALLOC_MAX < limit)

         limit = PNG_USER_CHUNK_MALLOC_MAX;

#  endif

   {

      int ret;

         *newlength = limit;

      ret = png_inflate_claim(png_ptr, png_ptr->chunk_name);

      {

         png_uint_32 lzsize = chunklength - prefix_size;

            /* input: */ png_ptr->read_buffer + prefix_size, &lzsize,

            /* output: */ NULL, newlength);

         {

            /* Use 'inflateReset' here, not 'inflateReset2' because this

             * preserves the previously decided window size (otherwise it would

             * be necessary to store the previous window size.)  In practice

             * this doesn't matter anyway, because png_inflate will call inflate

             * with Z_FINISH in almost all cases, so the window will not be

             * maintained.

             */

            if (inflateReset(&png_ptr->zstream) == Z_OK)

            {

               /* Because of the limit checks above we know that the new,

                * expanded, size will fit in a size_t (let alone an

                * png_alloc_size_t).  Use png_malloc_base here to avoid an

                * extra OOM message.

                */

               png_alloc_size_t new_size = *newlength;

               png_alloc_size_t buffer_size = prefix_size + new_size +

                  (terminate != 0);

               png_bytep text = png_voidcast(png_bytep, png_malloc_base(png_ptr,

                  buffer_size));

               {

                  ret = png_inflate(png_ptr, png_ptr->chunk_name, 1/*finish*/,

                     png_ptr->read_buffer + prefix_size, &lzsize,

                     text + prefix_size, newlength);

                  {

                     if (new_size == *newlength)

                     {

                        if (terminate)

                           text[prefix_size + *newlength] = 0;

                           memcpy(text, png_ptr->read_buffer, prefix_size);

                           png_bytep old_ptr = png_ptr->read_buffer;

                           png_ptr->read_buffer_size = buffer_size;

                           text = old_ptr; /* freed below */

                        }

                     }

                     {

                        /* The size changed on the second read, there can be no

                         * guarantee that anything is correct at this point.

                         * The 'msg' pointer has been set to "unexpected end of

                         * LZ stream", which is fine, but return an error code

                         * that the caller won't accept.

                         */

                        ret = PNG_UNEXPECTED_ZLIB_RETURN;

                     }

                  }

                     ret = PNG_UNEXPECTED_ZLIB_RETURN; /* for safety */

                   * success)

                   */

                  png_free(png_ptr, text);

                   * the extra space may otherwise be used as a Trojan Horse.

                   */

                  if (ret == Z_STREAM_END &&

                     chunklength - prefix_size != lzsize)

                     png_chunk_benign_error(png_ptr, "extra compressed data");

               }

               {

                  /* Out of memory allocating the buffer */

                  ret = Z_MEM_ERROR;

                  png_zstream_error(png_ptr, Z_MEM_ERROR);

               }

            }

            {

               /* inflateReset failed, store the error message */

               png_zstream_error(png_ptr, ret);

                  ret = PNG_UNEXPECTED_ZLIB_RETURN;

            }

         }

            ret = PNG_UNEXPECTED_ZLIB_RETURN;

         png_ptr->zowner = 0;

      }

         ret = PNG_UNEXPECTED_ZLIB_RETURN;

   }

   {

      /* Application/configuration limits exceeded */

      png_zstream_error(png_ptr, Z_MEM_ERROR);

      return Z_MEM_ERROR;

   }

}

#endif /* PNG_READ_COMPRESSED_TEXT_SUPPORTED */

/* Perform a partial read and decompress, producing 'avail_out' bytes and

 * reading from the current chunk as required.

 */

static int

png_inflate_read(png_structrp png_ptr, png_bytep read_buffer, uInt read_size,

   png_uint_32p chunk_bytes, png_bytep next_out, png_alloc_size_t *out_size,

   int finish)

{

   if (png_ptr->zowner == png_ptr->chunk_name)

   {

      int ret;

      png_ptr->zstream.next_out = next_out;

      png_ptr->zstream.avail_out = 0; /* set in the loop */

      {

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

         {

            if (read_size > *chunk_bytes)

               read_size = (uInt)*chunk_bytes;

            *chunk_bytes -= read_size;

               png_crc_read(png_ptr, read_buffer, read_size);

            png_ptr->zstream.avail_in = read_size;

         }

         {

            uInt avail = ZLIB_IO_MAX;

            if (avail > *out_size)

               avail = (uInt)*out_size;

            *out_size -= avail;

         }

          * the available output is produced; this allows reading of truncated

          * streams.

          */

         ret = inflate(&png_ptr->zstream,

            *chunk_bytes > 0 ? Z_NO_FLUSH : (finish ? Z_FINISH : Z_SYNC_FLUSH));

      }

      while (ret == Z_OK && (*out_size > 0 || png_ptr->zstream.avail_out > 0));

      png_ptr->zstream.avail_out = 0; /* Should not be required, but is safe */

      png_zstream_error(png_ptr, ret);

      return ret;

   }

   {

      png_ptr->zstream.msg = PNGZ_MSG_CAST("zstream unclaimed");

      return Z_STREAM_ERROR;

   }

}

#endif

void /* PRIVATE */

png_handle_IHDR(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

{

   png_byte buf[13];

   png_uint_32 width, height;

   int bit_depth, color_type, compression_type, filter_type;

   int interlace_type;

      png_chunk_error(png_ptr, "out of place");

   if (length != 13)

      png_chunk_error(png_ptr, "invalid");

   png_crc_finish(png_ptr, 0);

   height = png_get_uint_31(png_ptr, buf + 4);

   bit_depth = buf[8];

   color_type = buf[9];

   compression_type = buf[10];

   filter_type = buf[11];

   interlace_type = buf[12];

   png_ptr->width = width;

   png_ptr->height = height;

   png_ptr->bit_depth = (png_byte)bit_depth;

   png_ptr->interlaced = (png_byte)interlace_type;

   png_ptr->color_type = (png_byte)color_type;

#ifdef PNG_MNG_FEATURES_SUPPORTED

   png_ptr->filter_type = (png_byte)filter_type;

#endif

   png_ptr->compression_type = (png_byte)compression_type;

   switch (png_ptr->color_type)

   {

      default: /* invalid, png_set_IHDR calls png_error */

      case PNG_COLOR_TYPE_GRAY:

      case PNG_COLOR_TYPE_PALETTE:

         png_ptr->channels = 1;

         break;

         png_ptr->channels = 3;

         break;

         png_ptr->channels = 2;

         break;

         png_ptr->channels = 4;

         break;

   }

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

   png_ptr->channels);

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

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

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

   png_debug1(3, "rowbytes = %lu", (unsigned long)png_ptr->rowbytes);

   png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,

       color_type, interlace_type, compression_type, filter_type);

}

void /* PRIVATE */

png_handle_PLTE(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

{

   png_color palette[PNG_MAX_PALETTE_LENGTH];

   int num, i;

#ifdef PNG_POINTER_INDEXING_SUPPORTED

   png_colorp pal_ptr;

#endif

      png_chunk_error(png_ptr, "missing IHDR");

    * PLTE chunks are potentially ignored (the spec says there shall not be more

    * than one PLTE, the error is not treated as benign, so this check trumps

    * the requirement that PLTE appears before IDAT.)

    */

   else if (png_ptr->mode & PNG_HAVE_PLTE)

      png_chunk_error(png_ptr, "duplicate");

   {

      /* This is benign because the non-benign error happened before, when an

       * IDAT was encountered in a color-mapped image with no PLTE.

       */

      png_crc_finish(png_ptr, length);

      png_chunk_benign_error(png_ptr, "out of place");

      return;

   }

   {

      png_crc_finish(png_ptr, length);

      png_chunk_benign_error(png_ptr, "ignored in grayscale PNG");

      return;

   }

   if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)

   {

      png_crc_finish(png_ptr, length);

      return;

   }

#endif

   {

      png_crc_finish(png_ptr, length);

         png_chunk_benign_error(png_ptr, "invalid");

         png_chunk_error(png_ptr, "invalid");

   }

   num = (int)length / 3;

   for (i = 0, pal_ptr = palette; i < num; i++, pal_ptr++)

   {

      png_byte buf[3];

      pal_ptr->red = buf[0];

      pal_ptr->green = buf[1];

      pal_ptr->blue = buf[2];

   }

#else

   for (i = 0; i < num; i++)

   {

      png_byte buf[3];

      /* Don't depend upon png_color being any order */

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

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

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

   }

#endif

    * whatever the normal CRC configuration tells us.  However, if we

    * have an RGB image, the PLTE can be considered ancillary, so

    * we will act as though it is.

    */

#ifndef PNG_READ_OPT_PLTE_SUPPORTED

   if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

#endif

   {

      png_crc_finish(png_ptr, 0);

   }

   else if (png_crc_error(png_ptr))  /* Only if we have a CRC error */

   {

      /* If we don't want to use the data from an ancillary chunk,

       * we have two options: an error abort, or a warning and we

       * ignore the data in this chunk (which should be OK, since

       * it's considered ancillary for a RGB or RGBA image).

       *

       * IMPLEMENTATION NOTE: this is only here because png_crc_finish uses the

       * chunk type to determine whether to check the ancillary or the critical

       * flags.

       */

      if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE))

      {

         if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)

         {

            png_chunk_benign_error(png_ptr, "CRC error");

         }

         {

            png_chunk_warning(png_ptr, "CRC error");

            return;

         }

      }

      else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN))

      {

         png_chunk_warning(png_ptr, "CRC error");

      }

   }

#endif

    * own copy of the palette.  This has the side effect that when png_start_row

    * is called (this happens after any call to png_read_update_info) the

    * info_ptr palette gets changed.  This is extremely unexpected and

    * confusing.

    *

    * Fix this by not sharing the palette in this way.

    */

   png_set_PLTE(png_ptr, info_ptr, palette, num);

    * IDAT.  Prior to 1.6.0 this was not checked; instead the code merely

    * checked the apparent validity of a tRNS chunk inserted before PLTE on a

    * palette PNG.  1.6.0 attempts to rigorously follow the standard and

    * therefore does a benign error if the erroneous condition is detected *and*

    * cancels the tRNS if the benign error returns.  The alternative is to

    * amend the standard since it would be rather hypocritical of the standards

    * maintainers to ignore it.

    */

#ifdef PNG_READ_tRNS_SUPPORTED

   if (png_ptr->num_trans > 0 ||

      (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS) != 0))

   {

      /* Cancel this because otherwise it would be used if the transforms

       * require it.  Don't cancel the 'valid' flag because this would prevent

       * detection of duplicate chunks.

       */

      png_ptr->num_trans = 0;

         info_ptr->num_trans = 0;

   }

#endif

   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST) != 0)

      png_chunk_benign_error(png_ptr, "hIST must be after");

#endif

   if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD) != 0)

      png_chunk_benign_error(png_ptr, "bKGD must be after");

#endif

}

png_handle_IEND(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

{

   png_debug(1, "in png_handle_IEND");

      png_chunk_error(png_ptr, "out of place");

      png_chunk_benign_error(png_ptr, "invalid");

}

void /* PRIVATE */

png_handle_gAMA(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

{

   png_fixed_point igamma;

   png_byte buf[4];

      png_chunk_error(png_ptr, "missing IHDR");

   {

      png_crc_finish(png_ptr, length);

      png_chunk_benign_error(png_ptr, "out of place");

      return;

   }

   {

      png_crc_finish(png_ptr, length);

      png_chunk_benign_error(png_ptr, "invalid");

      return;

   }

      return;