png_read_transform_info(png_ptr, info_ptr);}/* 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 PNGAPIpng_start_read_image(png_structp png_ptr){   png_debug(1, "in png_start_read_image\n");   /* save jump buffer and error functions */   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))      png_read_start_row(png_ptr);}void PNGAPIpng_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row){#ifdef PNG_USE_LOCAL_ARRAYS   PNG_IDAT;   const int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};   const int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};#endif   int ret;   png_debug2(1, "in png_read_row (row %lu, pass %d)\n",      png_ptr->row_number, png_ptr->pass);   /* save jump buffer and error functions */   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))      png_read_start_row(png_ptr);   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)      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)      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)      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)      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)      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)      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)      png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined.");#endif   }#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 & 0x07)            {               if (dsp_row != NULL)                  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 & 0x07) || png_ptr->width < 5)            {               if (dsp_row != NULL)                  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 & 0x07) != 4)            {               if (dsp_row != NULL && (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 != NULL)                  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 != NULL && (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 != NULL)                  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 chunk_length[4];            png_crc_finish(png_ptr, 0);            png_read_data(png_ptr, chunk_length, 4);            png_ptr->idat_size = png_get_uint_32(chunk_length);            png_reset_crc(png_ptr);            png_crc_read(png_ptr, png_ptr->chunk_name, 4);            if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))               png_error(png_ptr, "Not enough image data");         }         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_size_t)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_AFTER_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);   if(png_ptr->row_buf[0])   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_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,      png_ptr->rowbytes + 1);   #if defined(PNG_MNG_FEATURES_SUPPORTED)   if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&      (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))   {      /* Intrapixel differencing */      png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);   }#endif   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)/*       old interface (pre-1.0.9):         png_do_read_interlace(&(png_ptr->row_info),            png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations); */         png_do_read_interlace(png_ptr);      if (dsp_row != NULL)         png_combine_row(png_ptr, dsp_row,            png_pass_dsp_mask[png_ptr->pass]);      if (row != NULL)         png_combine_row(png_ptr, row,            png_pass_mask[png_ptr->pass]);   }   else#endif   {      if (row != NULL)         png_combine_row(png_ptr, row, 0xff);      if (dsp_row != NULL)         png_combine_row(png_ptr, dsp_row, 0xff);   }   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);}/* 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 libpng version 1.0.9 */void PNGAPIpng_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;   png_debug(1, "in png_read_rows\n");   /* save jump buffer and error functions */   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++;      }}/* 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 libpng version 1.0.9 */void PNGAPIpng_read_image(png_structp png_ptr, png_bytepp image){   png_uint_32 i,image_height;   int pass, j;   png_bytepp rp;   png_debug(1, "in png_read_image\n");   /* save jump buffer and error functions */#ifdef PNG_READ_INTERLACING_SUPPORTED   pass = png_set_interlace_handling(png_ptr);#else   if (png_ptr->interlaced)      png_error(png_ptr,        "Cannot read interlaced image -- interlace handler disabled.");   pass = 1;#endif   image_height=png_ptr->height;   png_ptr->num_rows = image_height; /* Make sure this is set correctly */   for (j = 0; j < pass; j++)   {      rp = image;      for (i = 0; i < image_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 PNGAPIpng_read_end(png_structp png_ptr, png_infop info_ptr){   png_byte chunk_length[4];   png_uint_32 length;   png_debug(1, "in png_read_end\n");   /* save jump buffer and error functions */   png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */   do   {#ifdef PNG_USE_LOCAL_ARRAYS      PNG_IHDR;      PNG_IDAT;      PNG_IEND;      PNG_PLTE;#if defined(PNG_READ_bKGD_SUPPORTED)      PNG_bKGD;#endif#if defined(PNG_READ_cHRM_SUPPORTED)      PNG_cHRM;#endif#if defined(PNG_READ_gAMA_SUPPORTED)      PNG_gAMA;#endif#if defined(PNG_READ_hIST_SUPPORTED)      PNG_hIST;#endif#if defined(PNG_READ_iCCP_SUPPORTED)      PNG_iCCP;#endif#if defined(PNG_READ_iTXt_SUPPORTED)      PNG_iTXt;#endif#if defined(PNG_READ_oFFs_SUPPORTED)      PNG_oFFs;#endif#if defined(PNG_READ_pCAL_SUPPORTED)      PNG_pCAL;#endif#if defined(PNG_READ_pHYs_SUPPORTED)      PNG_pHYs;#endif#if defined(PNG_READ_sBIT_SUPPORTED)      PNG_sBIT;#endif#if defined(PNG_READ_sCAL_SUPPORTED)      PNG_sCAL;#endif#if defined(PNG_READ_sPLT_SUPPORTED)      PNG_sPLT;#endif#if defined(PNG_READ_sRGB_SUPPORTED)      PNG_sRGB;#endif#if defined(PNG_READ_tEXt_SUPPORTED)      PNG_tEXt;#endif#if defined(PNG_READ_tIME_SUPPORTED)      PNG_tIME;#endif#if defined(PNG_READ_tRNS_SUPPORTED)      PNG_tRNS;#endif#if defined(PNG_READ_zTXt_SUPPORTED)      PNG_zTXt;#endif#endif /* PNG_GLOBAL_ARRAYS */      png_read_data(png_ptr, chunk_length, 4);      length = png_get_uint_32(chunk_length);      png_reset_crc(png_ptr);      png_crc_read(png_ptr, png_ptr->chunk_name, 4);      png_debug1(0, "Reading %s chunk.\n", png_ptr->chunk_name);      if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))         png_handle_IHDR(png_ptr, info_ptr, length);      else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))         png_handle_IEND(png_ptr, info_ptr, length);#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED      else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))      {         if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))         {            if (length > 0 || png_ptr->mode & PNG_AFTER_IDAT)