~random-stuff/libpng/libpng-1.6.x

/* pngread.c - read a PNG file

 *

 * Last changed in libpng 1.6.17 [March 26, 2015]

 * Copyright (c) 1998-2015 Glenn Randers-Pehrson

 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

 *

 * This code is released under the libpng license.

 * For conditions of distribution and use, see the disclaimer

 * and license in png.h

 *

 * This file contains routines that an application calls directly to

 * read a PNG file or stream.

 */

#include "pngpriv.h"

#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) && defined(PNG_STDIO_SUPPORTED)

#  include <errno.h>

#endif

#ifdef PNG_READ_SUPPORTED

/* Create a PNG structure for reading, and allocate any memory needed. */

PNG_FUNCTION(png_structp,PNGAPI

png_create_read_struct,(png_const_charp user_png_ver, png_voidp error_ptr,

    png_error_ptr error_fn, png_error_ptr warn_fn),PNG_ALLOCATED)

{

#ifndef PNG_USER_MEM_SUPPORTED

   png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,

      error_fn, warn_fn, NULL, NULL, NULL);

#else

   return png_create_read_struct_2(user_png_ver, error_ptr, error_fn,

       warn_fn, NULL, NULL, NULL);

}

/* Alternate create PNG structure for reading, and allocate any memory

 * needed.

 */

PNG_FUNCTION(png_structp,PNGAPI

png_create_read_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr,

    png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,

    png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)

{

   png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,

      error_fn, warn_fn, mem_ptr, malloc_fn, free_fn);

#endif /* USER_MEM */

   if (png_ptr != NULL)

   {

      png_ptr->mode = PNG_IS_READ_STRUCT;

      /* Added in libpng-1.6.0; this can be used to detect a read structure if

       * required (it will be zero in a write structure.)

       */

#     ifdef PNG_SEQUENTIAL_READ_SUPPORTED

         png_ptr->IDAT_read_size = PNG_IDAT_READ_SIZE;

#     endif

#     ifdef PNG_BENIGN_READ_ERRORS_SUPPORTED

         png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;

         /* In stable builds only warn if an application error can be completely

          * handled.

          */

#        if PNG_RELEASE_BUILD

            png_ptr->flags |= PNG_FLAG_APP_WARNINGS_WARN;

#        endif

#     endif

      /* TODO: delay this, it can be done in png_init_io (if the app doesn't

       * do it itself) avoiding setting the default function if it is not

       * required.

       */

      png_set_read_fn(png_ptr, NULL, NULL);

   }

   return png_ptr;

}

#ifdef PNG_SEQUENTIAL_READ_SUPPORTED

/* Read the information before the actual image data.  This has been

 * changed in v0.90 to allow reading a file that already has the magic

 * bytes read from the stream.  You can tell libpng how many bytes have

 * been read from the beginning of the stream (up to the maximum of 8)

 * via png_set_sig_bytes(), and we will only check the remaining bytes

 * here.  The application can then have access to the signature bytes we

 * read if it is determined that this isn't a valid PNG file.

 */

void PNGAPI

png_read_info(png_structrp png_ptr, png_inforp info_ptr)

{

#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

   int keep;

#endif

   png_debug(1, "in png_read_info");

   if (png_ptr == NULL || info_ptr == NULL)

      return;

   /* Read and check the PNG file signature. */

   png_read_sig(png_ptr, info_ptr);

   for (;;)

   {

      png_uint_32 length = png_read_chunk_header(png_ptr);

      png_uint_32 chunk_name = png_ptr->chunk_name;

      /* IDAT logic needs to happen here to simplify getting the two flags

       * right.

       */

      if (chunk_name == png_IDAT)

      {

         if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)

            png_chunk_error(png_ptr, "Missing IHDR before IDAT");

         else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&

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

            png_chunk_error(png_ptr, "Missing PLTE before IDAT");

         else if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)

            png_chunk_benign_error(png_ptr, "Too many IDATs found");

         png_ptr->mode |= PNG_HAVE_IDAT;

      }

      else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)

         png_ptr->mode |= PNG_AFTER_IDAT;

      /* This should be a binary subdivision search or a hash for

       * matching the chunk name rather than a linear search.

       */

      if (chunk_name == png_IHDR)

         png_handle_IHDR(png_ptr, info_ptr, length);

      else if (chunk_name == png_IEND)

         png_handle_IEND(png_ptr, info_ptr, length);

#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED

      else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)

      {

         png_handle_unknown(png_ptr, info_ptr, length, keep);

         if (chunk_name == png_PLTE)

            png_ptr->mode |= PNG_HAVE_PLTE;

         else if (chunk_name == png_IDAT)

         {

            png_ptr->idat_size = 0; /* It has been consumed */

            break;

         }

      }

#endif

      else if (chunk_name == png_PLTE)

         png_handle_PLTE(png_ptr, info_ptr, length);

      else if (chunk_name == png_IDAT)

      {

         png_ptr->idat_size = length;

         break;

      }

#ifdef PNG_READ_bKGD_SUPPORTED

      else if (chunk_name == png_bKGD)

         png_handle_bKGD(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_cHRM_SUPPORTED

      else if (chunk_name == png_cHRM)

         png_handle_cHRM(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_gAMA_SUPPORTED

      else if (chunk_name == png_gAMA)

         png_handle_gAMA(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_hIST_SUPPORTED

      else if (chunk_name == png_hIST)

         png_handle_hIST(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_oFFs_SUPPORTED

      else if (chunk_name == png_oFFs)

         png_handle_oFFs(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_pCAL_SUPPORTED

      else if (chunk_name == png_pCAL)

         png_handle_pCAL(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_sCAL_SUPPORTED

      else if (chunk_name == png_sCAL)

         png_handle_sCAL(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_pHYs_SUPPORTED

      else if (chunk_name == png_pHYs)

         png_handle_pHYs(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_sBIT_SUPPORTED

      else if (chunk_name == png_sBIT)

         png_handle_sBIT(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_sRGB_SUPPORTED

      else if (chunk_name == png_sRGB)

         png_handle_sRGB(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_iCCP_SUPPORTED

      else if (chunk_name == png_iCCP)

         png_handle_iCCP(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_sPLT_SUPPORTED

      else if (chunk_name == png_sPLT)

         png_handle_sPLT(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_tEXt_SUPPORTED

      else if (chunk_name == png_tEXt)

         png_handle_tEXt(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_tIME_SUPPORTED

      else if (chunk_name == png_tIME)

         png_handle_tIME(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_tRNS_SUPPORTED

      else if (chunk_name == png_tRNS)

         png_handle_tRNS(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_zTXt_SUPPORTED

      else if (chunk_name == png_zTXt)

         png_handle_zTXt(png_ptr, info_ptr, length);

#endif

#ifdef PNG_READ_iTXt_SUPPORTED

      else if (chunk_name == png_iTXt)

         png_handle_iTXt(png_ptr, info_ptr, length);

#endif

      else

         png_handle_unknown(png_ptr, info_ptr, length,

            PNG_HANDLE_CHUNK_AS_DEFAULT);

   }

}

#endif /* SEQUENTIAL_READ */

/* Optional call to update the users info_ptr structure */

void PNGAPI

png_read_update_info(png_structrp png_ptr, png_inforp info_ptr)

{

   png_debug(1, "in png_read_update_info");

   if (png_ptr != NULL)

   {

      if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)

      {

         png_read_start_row(png_ptr);

#        ifdef PNG_READ_TRANSFORMS_SUPPORTED

            png_read_transform_info(png_ptr, info_ptr);

#        else

            PNG_UNUSED(info_ptr)

#        endif

      }

      /* New in 1.6.0 this avoids the bug of doing the initializations twice */

      else

         png_app_error(png_ptr,

            "png_read_update_info/png_start_read_image: duplicate call");

   }

}

#ifdef PNG_SEQUENTIAL_READ_SUPPORTED

/* Initialize palette, background, etc, after transformations

 * are set, but before any reading takes place.  This allows

 * the user to obtain a gamma-corrected palette, for example.

 * If the user doesn't call this, we will do it ourselves.

 */

void PNGAPI

png_start_read_image(png_structrp png_ptr)

{

   png_debug(1, "in png_start_read_image");

   if (png_ptr != NULL)

   {

      if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)

         png_read_start_row(png_ptr);

      /* New in 1.6.0 this avoids the bug of doing the initializations twice */

      else

         png_app_error(png_ptr,

            "png_start_read_image/png_read_update_info: duplicate call");

   }

}

#endif /* SEQUENTIAL_READ */

#ifdef PNG_SEQUENTIAL_READ_SUPPORTED

#ifdef PNG_MNG_FEATURES_SUPPORTED

/* Undoes intrapixel differencing,

 * NOTE: this is apparently only supported in the 'sequential' reader.

 */

static void

png_do_read_intrapixel(png_row_infop row_info, png_bytep row)

{

   png_debug(1, "in png_do_read_intrapixel");

   if (

       (row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)

   {

      int bytes_per_pixel;

      png_uint_32 row_width = row_info->width;

      if (row_info->bit_depth == 8)

      {

         png_bytep rp;

         png_uint_32 i;

         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

            bytes_per_pixel = 3;

         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

            bytes_per_pixel = 4;

         else

            return;

         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

         {

            *(rp) = (png_byte)((256 + *rp + *(rp + 1)) & 0xff);

            *(rp+2) = (png_byte)((256 + *(rp + 2) + *(rp + 1)) & 0xff);

         }

      }

      else if (row_info->bit_depth == 16)

      {

         png_bytep rp;

         png_uint_32 i;

         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

            bytes_per_pixel = 6;

         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

            bytes_per_pixel = 8;

         else

            return;

         for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)

         {

            png_uint_32 s0   = (*(rp    ) << 8) | *(rp + 1);

            png_uint_32 s1   = (*(rp + 2) << 8) | *(rp + 3);

            png_uint_32 s2   = (*(rp + 4) << 8) | *(rp + 5);

            png_uint_32 red  = (s0 + s1 + 65536) & 0xffff;

            png_uint_32 blue = (s2 + s1 + 65536) & 0xffff;

            *(rp    ) = (png_byte)((red >> 8) & 0xff);

            *(rp + 1) = (png_byte)(red & 0xff);

            *(rp + 4) = (png_byte)((blue >> 8) & 0xff);

            *(rp + 5) = (png_byte)(blue & 0xff);

         }

      }

   }

}

#endif /* MNG_FEATURES */

void PNGAPI

png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)

{

   png_row_info row_info;

   if (png_ptr == NULL)

      return;

   png_debug2(1, "in png_read_row (row %lu, pass %d)",

       (unsigned long)png_ptr->row_number, png_ptr->pass);

   /* png_read_start_row sets the information (in particular iwidth) for this

    * interlace pass.

    */

   if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)

      png_read_start_row(png_ptr);

   /* 1.5.6: row_info moved out of png_struct to a local here. */

   row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */

   row_info.color_type = png_ptr->color_type;

   row_info.bit_depth = png_ptr->bit_depth;

   row_info.channels = png_ptr->channels;

   row_info.pixel_depth = png_ptr->pixel_depth;

   row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width);

#ifdef PNG_WARNINGS_SUPPORTED

   if (png_ptr->row_number == 0 && png_ptr->pass == 0)

   {

   /* Check for transforms that have been set but were defined out */

#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)

   if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)

      png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined");

#endif

#if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED)

   if ((png_ptr->transformations & PNG_FILLER) != 0)

      png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined");

#endif

#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \

    !defined(PNG_READ_PACKSWAP_SUPPORTED)

   if ((png_ptr->transformations & PNG_PACKSWAP) != 0)

      png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined");

#endif

#if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED)

   if ((png_ptr->transformations & PNG_PACK) != 0)

      png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined");

#endif

#if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED)

   if ((png_ptr->transformations & PNG_SHIFT) != 0)

      png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined");

#endif

#if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED)

   if ((png_ptr->transformations & PNG_BGR) != 0)

      png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined");

#endif

#if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED)

   if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)

      png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined");

#endif

   }

#endif /* WARNINGS */

#ifdef PNG_READ_INTERLACING_SUPPORTED

   /* If interlaced and we do not need a new row, combine row and return.

    * Notice that the pixels we have from previous rows have been transformed

    * already; we can only combine like with like (transformed or

    * untransformed) and, because of the libpng API for interlaced images, this

    * means we must transform before de-interlacing.

    */

   if (png_ptr->interlaced != 0 &&

       (png_ptr->transformations & PNG_INTERLACE) != 0)

   {

      switch (png_ptr->pass)

      {

         case 0:

            if (png_ptr->row_number & 0x07)

            {

               if (dsp_row != NULL)

                  png_combine_row(png_ptr, dsp_row, 1/*display*/);

               png_read_finish_row(png_ptr);

               return;

            }

            break;

         case 1:

            if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)

            {

               if (dsp_row != NULL)

                  png_combine_row(png_ptr, dsp_row, 1/*display*/);

               png_read_finish_row(png_ptr);

               return;

            }

            break;

         case 2:

            if ((png_ptr->row_number & 0x07) != 4)

            {

               if (dsp_row != NULL && (png_ptr->row_number & 4))

                  png_combine_row(png_ptr, dsp_row, 1/*display*/);

               png_read_finish_row(png_ptr);

               return;

            }

            break;

         case 3:

            if ((png_ptr->row_number & 3) || png_ptr->width < 3)

            {

               if (dsp_row != NULL)

                  png_combine_row(png_ptr, dsp_row, 1/*display*/);

               png_read_finish_row(png_ptr);

               return;

            }

            break;

         case 4:

            if ((png_ptr->row_number & 3) != 2)

            {

               if (dsp_row != NULL && (png_ptr->row_number & 2))

                  png_combine_row(png_ptr, dsp_row, 1/*display*/);

               png_read_finish_row(png_ptr);

               return;

            }

            break;

         case 5:

            if ((png_ptr->row_number & 1) || png_ptr->width < 2)

            {

               if (dsp_row != NULL)

                  png_combine_row(png_ptr, dsp_row, 1/*display*/);

               png_read_finish_row(png_ptr);

               return;

            }

            break;

         default:

         case 6:

            if ((png_ptr->row_number & 1) == 0)

            {

               png_read_finish_row(png_ptr);

               return;

            }

            break;

      }

   }

#endif

   if ((png_ptr->mode & PNG_HAVE_IDAT) == 0)

      png_error(png_ptr, "Invalid attempt to read row data");

   /* Fill the row with IDAT data: */

   png_read_IDAT_data(png_ptr, png_ptr->row_buf, row_info.rowbytes + 1);

   if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE)

   {

      if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST)

         png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1,

            png_ptr->prev_row + 1, png_ptr->row_buf[0]);

      else

         png_error(png_ptr, "bad adaptive filter value");

   }

   /* libpng 1.5.6: the following line was copying png_ptr->rowbytes before

    * 1.5.6, while the buffer really is this big in current versions of libpng

    * it may not be in the future, so this was changed just to copy the

    * interlaced count:

    */

   memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);

#ifdef PNG_MNG_FEATURES_SUPPORTED

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

       (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))

   {

      /* Intrapixel differencing */

      png_do_read_intrapixel(&row_info, png_ptr->row_buf + 1);

   }

#endif

#ifdef PNG_READ_TRANSFORMS_SUPPORTED

   if (png_ptr->transformations)

      png_do_read_transformations(png_ptr, &row_info);

#endif

   /* The transformed pixel depth should match the depth now in row_info. */

   if (png_ptr->transformed_pixel_depth == 0)

   {

      png_ptr->transformed_pixel_depth = row_info.pixel_depth;

      if (row_info.pixel_depth > png_ptr->maximum_pixel_depth)

         png_error(png_ptr, "sequential row overflow");

   }

   else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth)

      png_error(png_ptr, "internal sequential row size calculation error");

#ifdef PNG_READ_INTERLACING_SUPPORTED

   /* Expand interlaced rows to full size */

   if (png_ptr->interlaced != 0 &&

      (png_ptr->transformations & PNG_INTERLACE) != 0)

   {

      if (png_ptr->pass < 6)

         png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,

            png_ptr->transformations);

      if (dsp_row != NULL)

         png_combine_row(png_ptr, dsp_row, 1/*display*/);

      if (row != NULL)

         png_combine_row(png_ptr, row, 0/*row*/);

   }

   else

#endif

   {

      if (row != NULL)

         png_combine_row(png_ptr, row, -1/*ignored*/);

      if (dsp_row != NULL)

         png_combine_row(png_ptr, dsp_row, -1/*ignored*/);

   }

   png_read_finish_row(png_ptr);

   if (png_ptr->read_row_fn != NULL)

      (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);

}

#endif /* SEQUENTIAL_READ */

#ifdef PNG_SEQUENTIAL_READ_SUPPORTED

/* Read one or more rows of image data.  If the image is interlaced,

 * and png_set_interlace_handling() has been called, the rows need 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_row.  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_row 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.

 *

 * [*] png_handle_alpha() does not exist yet, as of this version of libpng

 */

void PNGAPI

png_read_rows(png_structrp png_ptr, png_bytepp row,

    png_bytepp display_row, png_uint_32 num_rows)

{

   png_uint_32 i;

   png_bytepp rp;

   png_bytepp dp;

   png_debug(1, "in png_read_rows");

   if (png_ptr == NULL)

      return;

   rp = row;

   dp = display_row;

   if (rp != NULL && dp != NULL)

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

      {

         png_bytep rptr = *rp++;

         png_bytep dptr = *dp++;

         png_read_row(png_ptr, rptr, dptr);

      }

   else if (rp != NULL)

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

      {

         png_bytep rptr = *rp;

         png_read_row(png_ptr, rptr, NULL);

         rp++;

      }

   else if (dp != NULL)

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

      {

         png_bytep dptr = *dp;

         png_read_row(png_ptr, NULL, dptr);

         dp++;

      }

}

#endif /* SEQUENTIAL_READ */

#ifdef PNG_SEQUENTIAL_READ_SUPPORTED

/* Read the entire image.  If the image has an alpha channel or a tRNS

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

 * only call this function once.  If you desire to have an image for

 * each pass of a interlaced image, use png_read_rows() instead.

 *

 * [*] png_handle_alpha() does not exist yet, as of this version of libpng

 */

void PNGAPI

png_read_image(png_structrp png_ptr, png_bytepp image)

{

   png_uint_32 i, image_height;

   int pass, j;

   png_bytepp rp;

   png_debug(1, "in png_read_image");

   if (png_ptr == NULL)

      return;

#ifdef PNG_READ_INTERLACING_SUPPORTED

   if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)

   {

      pass = png_set_interlace_handling(png_ptr);

      /* And make sure transforms are initialized. */

      png_start_read_image(png_ptr);

   }

   else

   {

      if (png_ptr->interlaced != 0 &&

          (png_ptr->transformations & PNG_INTERLACE) == 0)

      {

         /* Caller called png_start_read_image or png_read_update_info without

          * first turning on the PNG_INTERLACE transform.  We can fix this here,

          * but the caller should do it!

          */

         png_warning(png_ptr, "Interlace handling should be turned on when "

            "using png_read_image");

         /* Make sure this is set correctly */

         png_ptr->num_rows = png_ptr->height;

      }