/* pngread.c - read a png file

   libpng 1.0 beta 3 - version 0.89
   For conditions of distribution and use, see copyright notice in png.h
   Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
   May 25, 1996
   */

#define PNG_INTERNAL
#include "png.h"

/* Create a png structure for reading, and allocate any memory needed. */
png_structp
png_create_read_struct(png_const_charp user_png_ver, voidp error_ptr,
   png_error_ptr warn_fn, png_error_ptr error_fn)
{
   png_structp png_ptr;

   if ((png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG)) == NULL)
   {
      return (png_structp)NULL;
   }

   if (setjmp(png_ptr->jmpbuf))
   {
      png_large_free(png_ptr, png_ptr->zbuf);
      png_free(png_ptr, png_ptr->zstream);
      png_destroy_struct(png_ptr);
      return (png_structp)NULL;
   }

   png_set_error_fn(png_ptr, error_ptr, warn_fn, error_fn);

   if (user_png_ver == NULL || strcmp(user_png_ver, png_libpng_ver))
   {
      if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0])
      {
         png_error(png_ptr, "Incompatible libpng versions");
      }
      else
      {
         png_warning(png_ptr, "Different libpng versions");
      }
   }

   /* initialize zbuf - compression buffer */
   png_ptr->zbuf_size = PNG_ZBUF_SIZE;
   png_ptr->zbuf = png_large_malloc(png_ptr, png_ptr->zbuf_size);

   png_ptr->zstream = (z_stream *)png_malloc(png_ptr, sizeof (z_stream));
   png_ptr->zstream->zalloc = png_zalloc;
   png_ptr->zstream->zfree = png_zfree;
   png_ptr->zstream->opaque = (voidpf)png_ptr;

   switch (inflateInit(png_ptr->zstream))
   {
     case Z_OK: /* Do nothing */ break;
     case Z_MEM_ERROR:
     case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); break;
     case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error"); break;
     default: png_error(png_ptr, "Unknown zlib error");
   }

   png_ptr->zstream->next_out = png_ptr->zbuf;
   png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;

   png_set_read_fn(png_ptr, NULL, NULL);

   png_ptr->do_free |= PNG_FREE_STRUCT;

   return (png_ptr);
}


/* initialize png structure for reading, and allocate any memory needed */
/* This interface is depreciated in favour of the png_create_read_struct() */
void
png_read_init(png_structp png_ptr)
{
   jmp_buf tmp_jmp;  /* to save current jump buffer */

   /* save jump buffer and error functions */
   png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));

   /* reset all variables to 0 */
   png_memset(png_ptr, 0, sizeof (png_struct));

   /* restore jump buffer */
   png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));

   /* initialize zbuf - compression buffer */
   png_ptr->zbuf_size = PNG_ZBUF_SIZE;
   png_ptr->zbuf = png_large_malloc(png_ptr, png_ptr->zbuf_size);

   png_ptr->zstream = (z_stream *)png_malloc(png_ptr, sizeof (z_stream));
   png_ptr->zstream->zalloc = png_zalloc;
   png_ptr->zstream->zfree = png_zfree;
   png_ptr->zstream->opaque = (voidpf)png_ptr;

   switch (inflateInit(png_ptr->zstream))
   {
     case Z_OK: /* Do nothing */ break;
     case Z_MEM_ERROR:
     case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory"); break;
     case Z_VERSION_ERROR: png_error(png_ptr, "zlib version"); break;
     default: png_error(png_ptr, "Unknown zlib error");
   }

   png_ptr->zstream->next_out = png_ptr->zbuf;
   png_ptr->zstream->avail_out = (uInt)png_ptr->zbuf_size;

   png_set_read_fn(png_ptr, NULL, NULL);
}

/* read the information before the actual image data. */
void
png_read_info(png_structp png_ptr, png_infop info)
{
   png_byte chunk_start[8];
   png_uint_32 length;

   png_read_data(png_ptr, chunk_start, 8);
   if (!png_check_sig(chunk_start, 8))
   {
      if (!png_check_sig(chunk_start, 4))
         png_error(png_ptr, "Not a PNG file");
      else
         png_error(png_ptr, "PNG file corrupted by ASCII conversion");
   }

   while (1)
   {
      png_uint_32 crc;

      png_read_data(png_ptr, chunk_start, 8);
      length = png_get_uint_32(chunk_start);
      png_reset_crc(png_ptr);
      png_calculate_crc(png_ptr, chunk_start + 4, 4);
      if (!png_memcmp(chunk_start + 4, png_IHDR, 4))
         png_handle_IHDR(png_ptr, info, length);
      else if (!png_memcmp(chunk_start + 4, png_PLTE, 4))
         png_handle_PLTE(png_ptr, info, length);
      else if (!png_memcmp(chunk_start + 4, png_IDAT, 4))
      {
         if (!(png_ptr->mode & PNG_HAVE_IHDR))
            png_error(png_ptr, "Missing IHDR before IDAT");
         else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
                  !(png_ptr->mode & PNG_HAVE_PLTE))
            png_error(png_ptr, "Missing PLTE before IDAT");

         png_ptr->idat_size = length;
         png_ptr->mode |= PNG_HAVE_IDAT;
         break;
      }
      else if (!png_memcmp(chunk_start + 4, png_IEND, 4))
         png_error(png_ptr, "No image in file");
#if defined(PNG_READ_gAMA_SUPPORTED)
      else if (!png_memcmp(chunk_start + 4, png_gAMA, 4))
         png_handle_gAMA(png_ptr, info, length);
#endif
#if defined(PNG_READ_sBIT_SUPPORTED)
      else if (!png_memcmp(chunk_start + 4, png_sBIT, 4))
         png_handle_sBIT(png_ptr, info, length);
#endif
#if defined(PNG_READ_cHRM_SUPPORTED)
      else if (!png_memcmp(chunk_start + 4, png_cHRM, 4))
         png_handle_cHRM(png_ptr, info, length);
#endif
#if defined(PNG_READ_tRNS_SUPPORTED)
      else if (!png_memcmp(chunk_start + 4, png_tRNS, 4))
         png_handle_tRNS(png_ptr, info, length);
#endif
#if defined(PNG_READ_bKGD_SUPPORTED)
      else if (!png_memcmp(chunk_start + 4, png_bKGD, 4))
         png_handle_bKGD(png_ptr, info, length);
#endif
#if defined(PNG_READ_hIST_SUPPORTED)
      else if (!png_memcmp(chunk_start + 4, png_hIST, 4))
         png_handle_hIST(png_ptr, info, length);
#endif
#if defined(PNG_READ_pHYs_SUPPORTED)
      else if (!png_memcmp(chunk_start + 4, png_pHYs, 4))
         png_handle_pHYs(png_ptr, info, length);
#endif
#if defined(PNG_READ_oFFs_SUPPORTED)
      else if (!png_memcmp(chunk_start + 4, png_oFFs, 4))
         png_handle_oFFs(png_ptr, info, length);
#endif
#if defined(PNG_READ_tIME_SUPPORTED)
      else if (!png_memcmp(chunk_start + 4, png_tIME, 4))
         png_handle_tIME(png_ptr, info, length);
#endif
#if defined(PNG_READ_tEXt_SUPPORTED)
      else if (!png_memcmp(chunk_start + 4, png_tEXt, 4))
         png_handle_tEXt(png_ptr, info, length);
#endif
#if defined(PNG_READ_zTXt_SUPPORTED)
      else if (!png_memcmp(chunk_start + 4, png_zTXt, 4))
         png_handle_zTXt(png_ptr, info, length);
#endif
      else
      {
         if (chunk_start[4] < 41 || chunk_start[4] > 122  ||
             (chunk_start[4] > 90 && chunk_start[4] < 97) ||
             chunk_start[5] < 41 || chunk_start[5] > 122  ||
             (chunk_start[5] > 90 && chunk_start[5] < 97) ||
             chunk_start[6] < 41 || chunk_start[6] > 122  ||
             (chunk_start[6] > 90 && chunk_start[6] < 97) ||
             chunk_start[7] < 41 || chunk_start[7] > 122  ||
             (chunk_start[7] > 90 && chunk_start[7] < 97))
         {
            char msg[45];

            sprintf(msg, "Invalid chunk type 0x%02X 0x%02X 0x%02X 0x%02X",
               chunk_start[4], chunk_start[5], chunk_start[6], chunk_start[7]);
            png_error(png_ptr, msg);
         }

         if ((chunk_start[4] & 0x20) == 0)
         {
            char msg[40];

            sprintf(msg, "Unknown critical chunk %c%c%c%c",
               chunk_start[4], chunk_start[5], chunk_start[6], chunk_start[7]);
            png_error(png_ptr, msg);
         }

         png_crc_skip(png_ptr, length);
      }
      png_read_data(png_ptr, chunk_start, 4);
      crc = png_get_uint_32(chunk_start);
      if (((crc ^ 0xffffffffL) & 0xffffffffL) != (png_ptr->crc & 0xffffffffL))
         png_error(png_ptr, "Bad CRC value");
   }
}

/* optional call to update the users info structure */
void
png_read_update_info(png_structp png_ptr, png_infop info)
{
   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
      png_read_start_row(png_ptr);
   png_read_transform_info(png_ptr, info);
}

/* initialize palette, background, etc, after transformations
   are set, but before any reading takes place.  This allows
   the user to obtail a gamma corrected palette, for example.
   If the user doesn't call this, we will do it ourselves. */
void
png_start_read_image(png_structp png_ptr)
{
   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
      png_read_start_row(png_ptr);
}

void
png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
{
   int ret;
   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
      png_read_start_row(png_ptr);

#if defined(PNG_READ_INTERLACING_SUPPORTED)
   /* if interlaced and we do not need a new row, combine row and return */
   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
   {
      switch (png_ptr->pass)
      {
         case 0:
            if (png_ptr->row_number & 7)
            {
               if (dsp_row)
                  png_combine_row(png_ptr, dsp_row,
                     png_pass_dsp_mask[png_ptr->pass]);
               png_read_finish_row(png_ptr);
               return;
            }
            break;
         case 1:
            if ((png_ptr->row_number & 7) || png_ptr->width < 5)
            {
               if (dsp_row)
                  png_combine_row(png_ptr, dsp_row,
                     png_pass_dsp_mask[png_ptr->pass]);
               png_read_finish_row(png_ptr);
               return;
            }
            break;
         case 2:
            if ((png_ptr->row_number & 7) != 4)
            {
               if (dsp_row && (png_ptr->row_number & 4))
                  png_combine_row(png_ptr, dsp_row,
                     png_pass_dsp_mask[png_ptr->pass]);
               png_read_finish_row(png_ptr);
               return;
            }
            break;
         case 3:
            if ((png_ptr->row_number & 3) || png_ptr->width < 3)
            {
               if (dsp_row)
                  png_combine_row(png_ptr, dsp_row,
                     png_pass_dsp_mask[png_ptr->pass]);
               png_read_finish_row(png_ptr);
               return;
            }
            break;
         case 4:
            if ((png_ptr->row_number & 3) != 2)
            {
               if (dsp_row && (png_ptr->row_number & 2))
                  png_combine_row(png_ptr, dsp_row,
                     png_pass_dsp_mask[png_ptr->pass]);
               png_read_finish_row(png_ptr);
               return;
            }
            break;
         case 5:
            if ((png_ptr->row_number & 1) || png_ptr->width < 2)
            {
               if (dsp_row)
                  png_combine_row(png_ptr, dsp_row,
                     png_pass_dsp_mask[png_ptr->pass]);
               png_read_finish_row(png_ptr);
               return;
            }
            break;
         case 6:
            if (!(png_ptr->row_number & 1))
            {
               png_read_finish_row(png_ptr);
               return;
            }
            break;
      }
   }
#endif

   if (!(png_ptr->mode & PNG_HAVE_IDAT))
      png_error(png_ptr, "Invalid attempt to read row data");

   png_ptr->zstream->next_out = png_ptr->row_buf;
   png_ptr->zstream->avail_out = (uInt)png_ptr->irowbytes;
   do
   {
      if (!(png_ptr->zstream->avail_in))
      {
         while (!png_ptr->idat_size)
         {
            png_byte buf[4];
            png_uint_32 crc;

            png_read_data(png_ptr, buf, 4);
            crc = png_get_uint_32(buf);
            if (((crc ^ 0xffffffffL) & 0xffffffffL) !=
               (png_ptr->crc & 0xffffffffL))
               png_error(png_ptr, "Bad CRC value");

            png_read_data(png_ptr, buf, 4);
            png_ptr->idat_size = png_get_uint_32(buf);
            png_reset_crc(png_ptr);

            png_crc_read(png_ptr, buf, 4);
            if (png_memcmp(buf, png_IDAT, 4))
               png_error(png_ptr, "Not enough IDATs for image");
         }
         png_ptr->zstream->avail_in = (uInt)png_ptr->zbuf_size;
         png_ptr->zstream->next_in = png_ptr->zbuf;
         if (png_ptr->zbuf_size > png_ptr->idat_size)
            png_ptr->zstream->avail_in = (uInt)png_ptr->idat_size;
         png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream->avail_in);
         png_ptr->idat_size -= png_ptr->zstream->avail_in;
      }
      ret = inflate(png_ptr->zstream, Z_PARTIAL_FLUSH);
      if (ret == Z_STREAM_END)
      {
         if (png_ptr->zstream->avail_out || png_ptr->zstream->avail_in ||
            png_ptr->idat_size)
            png_error(png_ptr, "Extra compressed data");
         png_ptr->mode |= PNG_AT_LAST_IDAT;
         png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
         break;
      }
      if (ret != Z_OK)
         png_error(png_ptr, png_ptr->zstream->msg ? png_ptr->zstream->msg :
                   "Decompression error");
   } while (png_ptr->zstream->avail_out);

   png_ptr->row_info.color_type = png_ptr->color_type;
   png_ptr->row_info.width = png_ptr->iwidth;
   png_ptr->row_info.channels = png_ptr->channels;
   png_ptr->row_info.bit_depth = png_ptr->bit_depth;
   png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;
   png_ptr->row_info.rowbytes = ((png_ptr->row_info.width *
      (png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3);

   png_read_filter_row(png_ptr, &(png_ptr->row_info),
      png_ptr->row_buf + 1, png_ptr->prev_row + 1,
      (int)(png_ptr->row_buf[0]));

   png_memcpy(png_ptr->prev_row, png_ptr->row_buf, (png_size_t)png_ptr->rowbytes + 1);

   if (png_ptr->transformations)
      png_do_read_transformations(png_ptr);

#if defined(PNG_READ_INTERLACING_SUPPORTED)
   /* blow up interlaced rows to full size */
   if (png_ptr->interlaced &&
      (png_ptr->transformations & PNG_INTERLACE))
   {
      if (png_ptr->pass < 6)
         png_do_read_interlace(&(png_ptr->row_info),
            png_ptr->row_buf + 1, png_ptr->pass);

      if (dsp_row)
         png_combine_row(png_ptr, dsp_row,
            png_pass_dsp_mask[png_ptr->pass]);
      if (row)
         png_combine_row(png_ptr, row,
            png_pass_mask[png_ptr->pass]);
   }
   else
#endif
   {
      if (row)
         png_combine_row(png_ptr, row, 0xff);
      if (dsp_row)
         png_combine_row(png_ptr, dsp_row, 0xff);
   }
   png_read_finish_row(png_ptr);
}

/* read a one or more rows of image data.   If the image is interlaced,
   and png_set_interlace_handling() has been called, the rows need to
   to contain the contents of the rows from the previous pass.  If
   the image has alpha or transparency, and png_handle_alpha() has been
   called, the rows contents must be initialized to the contents of the
   screen.  row holds the actual image, and pixels are placed in it
   as they arrive.  If the image is displayed after each pass, it will
   appear to "sparkle" in.  display_row can be used to display a
   "chunky" progressive image, with finer detail added as it becomes
   available.  If you do not want this "chunky" display, you may pass
   NULL for display_rows.  If you do not want the sparkle display, and
   you have not called png_handle_alpha(), you may pass NULL for rows.
   If you have called png_handle_alpha(), and the image has either an
   alpha channel or a transparency chunk, you must provide a buffer for
   rows.  In this case, you do not have to provide a display_rows buffer
   also, but you may.  If the image is not interlaced, or if you have
   not called png_set_interlace_handling(), the display_row buffer will
   be ignored, so pass NULL to it. */

void
png_read_rows(png_structp png_ptr, png_bytepp row,
   png_bytepp display_row, png_uint_32 num_rows)
{
   png_uint_32 i;
   png_bytepp rp;
   png_bytepp dp;

   rp = row;
   dp = display_row;
   for (i = 0; i < num_rows; i++)
   {
      png_bytep rptr;
      png_bytep dptr;

      if (rp)
         rptr = *rp;
      else
         rptr = NULL;
      if (dp)
         dptr = *dp;
      else
         dptr = NULL;
      png_read_row(png_ptr, rptr, dptr);
      if (row)
         rp++;
      if (display_row)
         dp++;
   }
}

/* read the image.  If the image has an alpha channel or a transparency
   chunk, and you have called png_handle_alpha(), you will need to
   initialize the image to the current image that png will be overlaying.
   We set the num_rows again here, in case it was incorrectly set in
   png_read_start_row() by a call to png_read_update_info() or
   png_start_read_image() if png_set_interlace_handling() wasn't called
   prior to either of these functions like it should have been.  You only
   need to call this function once.  If you desire to have an image for
   each pass of a interlaced image, use png_read_rows() instead */
void
png_read_image(png_structp png_ptr, png_bytepp image)
{
   png_uint_32 i;
   int pass, j;
   png_bytepp rp;

   pass = png_set_interlace_handling(png_ptr);

   png_ptr->num_rows = png_ptr->height; /* Make sure this is set correctly */

   for (j = 0; j < pass; j++)
   {
      rp = image;
      for (i = 0; i < png_ptr->height; i++)
      {
         png_read_row(png_ptr, *rp, NULL);
         rp++;
      }
   }
}

/* read the end of the png file.  Will not read past the end of the
   file, will verify the end is accurate, and will read any comments
   or time information at the end of the file, if info is not NULL. */
void
png_read_end(png_structp png_ptr, png_infop info)
{
   png_byte chunk_start[8];
   png_uint_32 length;
   png_uint_32 crc;

   png_read_data(png_ptr, chunk_start, 4);
   crc = png_get_uint_32(chunk_start);
   if (((crc ^ 0xffffffffL) & 0xffffffffL) !=
      (png_ptr->crc & 0xffffffffL))
      png_error(png_ptr, "Bad CRC value");

   do
   {
      png_read_data(png_ptr, chunk_start, 8);
      length = png_get_uint_32(chunk_start);
      png_reset_crc(png_ptr);
      png_calculate_crc(png_ptr, chunk_start + 4, 4);

      if (!png_memcmp(chunk_start + 4, png_IHDR, 4))
      {
         png_error(png_ptr, "Invalid IHDR after IDAT");
      }
      else if (!png_memcmp(chunk_start + 4, png_PLTE, 4))
      {
         png_error(png_ptr, "Invalid PLTE after IDAT");
      }
      else if (!png_memcmp(chunk_start + 4, png_gAMA, 4))
      {
         png_error(png_ptr, "Invalid gAMA after IDAT");
      }
      else if (!png_memcmp(chunk_start + 4, png_sBIT, 4))
      {
         png_error(png_ptr, "Invalid sBIT after IDAT");
      }
      else if (!png_memcmp(chunk_start + 4, png_cHRM, 4))
      {
         png_error(png_ptr, "Invalid cHRM after IDAT");
      }
      else if (!png_memcmp(chunk_start + 4, png_tRNS, 4))
      {
         png_error(png_ptr, "Invalid tRNS after IDAT");
      }
      else if (!png_memcmp(chunk_start + 4, png_bKGD, 4))
      {
         png_error(png_ptr, "Invalid bKGD after IDAT");
      }
      else if (!png_memcmp(chunk_start + 4, png_hIST, 4))
      {
         png_error(png_ptr, "Invalid hIST after IDAT");
      }
      else if (!png_memcmp(chunk_start + 4, png_IDAT, 4))
      {
         if (length > 0 || png_ptr->mode & PNG_AFTER_IDAT)
            png_error(png_ptr, "Too many IDAT's found");
      }
      else if (!png_memcmp(chunk_start + 4, png_pHYs, 4))
      {
         png_error(png_ptr, "Invalid pHYs after IDAT");
      }
      else if (!png_memcmp(chunk_start + 4, png_oFFs, 4))
      {
         png_error(png_ptr, "Invalid oFFs after IDAT");
      }
#if defined(PNG_READ_tIME_SUPPORTED)
      else if (!png_memcmp(chunk_start + 4, png_tIME, 4))
      {
         png_ptr->mode |= PNG_AFTER_IDAT;

         if (info)
            png_handle_tIME(png_ptr, info, length);
         else
            png_crc_skip(png_ptr, length);
      }
#endif
#if defined(PNG_READ_tEXt_SUPPORTED)
      else if (!png_memcmp(chunk_start + 4, png_tEXt, 4))
      {
         png_ptr->mode |= PNG_AFTER_IDAT;

         if (info)
            png_handle_tEXt(png_ptr, info, length);
         else
            png_crc_skip(png_ptr, length);
      }
#endif
#if defined(PNG_READ_zTXt_SUPPORTED)
      else if (!png_memcmp(chunk_start + 4, png_zTXt, 4))
      {
         png_ptr->mode |= PNG_AFTER_IDAT;

         if (info)
            png_handle_zTXt(png_ptr, info, length);
         else
            png_crc_skip(png_ptr, length);
      }
#endif
      else if (!png_memcmp(chunk_start + 4, png_IEND, 4))
      {
         png_ptr->mode |= PNG_AFTER_IDAT;
         png_ptr->mode |= PNG_AFTER_IEND;
      }
      else
      {
         if (chunk_start[4] < 41 || chunk_start[4] > 122  ||
             (chunk_start[4] > 90 && chunk_start[4] < 97) ||
             chunk_start[5] < 41 || chunk_start[5] > 122  ||
             (chunk_start[5] > 90 && chunk_start[5] < 97) ||
             chunk_start[6] < 41 || chunk_start[6] > 122  ||
             (chunk_start[6] > 90 && chunk_start[6] < 97) ||
             chunk_start[7] < 41 || chunk_start[7] > 122  ||
             (chunk_start[7] > 90 && chunk_start[7] < 97))
         {
           png_error(png_ptr, "Invalid chunk type");
         }

         if ((chunk_start[4] & 0x20) == 0)
            png_error(png_ptr, "Unknown critical chunk");

         png_ptr->mode |= PNG_AFTER_IDAT;
         png_crc_skip(png_ptr, length);
      }
      png_read_data(png_ptr, chunk_start, 4);
      crc = png_get_uint_32(chunk_start);
      if (((crc ^ 0xffffffffL) & 0xffffffffL) != (png_ptr->crc & 0xffffffffL))
         png_error(png_ptr, "Bad CRC value");
   } while (!(png_ptr->mode & PNG_AFTER_IEND));
}

/* free all memory used by the read */
void
png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
   png_infopp end_info_ptr)
{
   png_structp png_ptr = NULL;
   png_infop info_ptr = NULL, end_info = NULL;

   if (png_ptr_ptr)
      png_ptr = *png_ptr_ptr;

   if (info_ptr_ptr)
      info_ptr = *info_ptr_ptr;

   if (end_info_ptr)
      end_info = *end_info_ptr;

   png_read_destroy(png_ptr, info_ptr, end_info);

   if (info_ptr)
   {
      png_destroy_struct((voidp)info_ptr);
      *info_ptr_ptr = (png_infop)NULL;
   }

   if (end_info)
   {
      png_destroy_struct((voidp)end_info);
      *end_info_ptr = (png_infop)NULL;
   }

   if (png_ptr)
   {
      png_destroy_struct((voidp)png_ptr);
      *png_ptr_ptr = (png_structp)NULL;
   }
}

/* free all memory used by the read (old) */
void
png_read_destroy(png_structp png_ptr, png_infop info, png_infop end_info)
{
   int i;
   jmp_buf tmp_jmp;
   png_error_ptr error_fn;
   png_error_ptr warning_fn;
   png_voidp error_ptr;

   if (info)
   {
#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_READ_zTXt_SUPPORTED)
      for (i = 0; i < info->num_text; i++)
      {
         png_large_free(png_ptr, info->text[i].key);
      }

      png_large_free(png_ptr, info->text);
#endif
      png_memset(info, 0, sizeof(png_info));
   }

   if (end_info)
   {
#if defined(PNG_READ_tEXt_SUPPORTED) || defined(PNG_READ_zTXt_SUPPORTED)
      for (i = 0; i < end_info->num_text; i++)
      {
         png_large_free(png_ptr, end_info->text[i].key);
      }

      png_large_free(png_ptr, end_info->text);
#endif
      png_memset(end_info, 0, sizeof(png_info));
   }

   png_large_free(png_ptr, png_ptr->zbuf);
   png_large_free(png_ptr, png_ptr->row_buf);
   png_large_free(png_ptr, png_ptr->prev_row);
#if defined(PNG_READ_DITHER_SUPPORTED)
   png_large_free(png_ptr, png_ptr->palette_lookup);
   png_large_free(png_ptr, png_ptr->dither_index);
#endif
#if defined(PNG_READ_GAMMA_SUPPORTED)
   png_large_free(png_ptr, png_ptr->gamma_table);
#endif
#if defined(PNG_READ_BACKGROUND_SUPPORTED)
   png_large_free(png_ptr, png_ptr->gamma_from_1);
   png_large_free(png_ptr, png_ptr->gamma_to_1);
#endif
   if (png_ptr->do_free & PNG_FREE_PALETTE)
      png_large_free(png_ptr, png_ptr->palette);
#if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_bKGD_SUPPORTED)
   if (png_ptr->do_free & PNG_FREE_TRANS)
      png_large_free(png_ptr, png_ptr->trans);
#endif
#if defined(PNG_READ_hIST_SUPPORTED)
   if (png_ptr->do_free & PNG_FREE_HIST)
      png_large_free(png_ptr, png_ptr->hist);
#endif
#if defined(PNG_READ_GAMMA_SUPPORTED)
   if (png_ptr->gamma_16_table)
   {
      for (i = 0; i < (1 << (8 - png_ptr->gamma_shift)); i++)
      {
         png_large_free(png_ptr, png_ptr->gamma_16_table[i]);
      }
   }
#endif
#if defined(PNG_READ_BACKGROUND_SUPPORTED)
   png_large_free(png_ptr, png_ptr->gamma_16_table);
   if (png_ptr->gamma_16_from_1)
   {
      for (i = 0; i < (1 << (8 - png_ptr->gamma_shift)); i++)
      {
         png_large_free(png_ptr, png_ptr->gamma_16_from_1[i]);
      }
   }
   png_large_free(png_ptr, png_ptr->gamma_16_from_1);
   if (png_ptr->gamma_16_to_1)
   {
      for (i = 0; i < (1 << (8 - png_ptr->gamma_shift)); i++)
      {
         png_large_free(png_ptr, png_ptr->gamma_16_to_1[i]);
      }
   }
   png_large_free(png_ptr, png_ptr->gamma_16_to_1);
#endif

   inflateEnd(png_ptr->zstream);
   png_free(png_ptr, png_ptr->zstream);
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
   png_large_free(png_ptr, png_ptr->save_buffer);
#endif

   /* Save the important info out of the png_struct, in case it is
    * being used again.
    */
   png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));

   error_fn = png_ptr->error_fn;
   warning_fn = png_ptr->warning_fn;
   error_ptr = png_ptr->error_ptr;

   png_memset(png_ptr, 0, sizeof (png_struct));

   png_ptr->error_fn = error_fn;
   png_ptr->warning_fn = warning_fn;
   png_ptr->error_ptr = error_ptr;

   png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
}