#else   if (setjmp(png_ptr->jmpbuf))#endif   {      png_free(png_ptr, png_ptr->zbuf);      png_ptr->zbuf=NULL;      png_destroy_struct(png_ptr);      return ((png_structp)NULL);   }#ifdef USE_FAR_KEYWORD   png_memcpy(png_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf));#endif#endif#ifdef PNG_USER_MEM_SUPPORTED   png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);#endif /* PNG_USER_MEM_SUPPORTED */   png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);   i=0;   do   {     if(user_png_ver[i] != png_libpng_ver[i])        png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;   } while (png_libpng_ver[i++]);   if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)   {     /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so      * we must recompile any applications that use any older library version.      * For versions after libpng 1.0, we will be compatible, so we need      * only check the first digit.      */     if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||         (user_png_ver[0] == '0' && user_png_ver[2] < '9'))     {        png_error(png_ptr,           "Incompatible libpng version in application and library");     }     /* Libpng 1.0.6 was not binary compatible, due to insertion of the        info_ptr->free_me member.  Note to maintainer: this test can be        removed from version 2.0.0 and beyond because the previous test        would have already rejected it. */     if (user_png_ver[4] == '6' && user_png_ver[2] == '0' &&         user_png_ver[0] == '1' && user_png_ver[5] == '\0')     {        png_error(png_ptr,           "Application must be recompiled; version 1.0.6 was incompatible");     }   }   /* initialize zbuf - compression buffer */   png_ptr->zbuf_size = PNG_ZBUF_SIZE;   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,      (png_uint_32)png_ptr->zbuf_size);   png_set_write_fn(png_ptr, NULL, NULL, NULL);#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)   png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,      1, NULL, NULL);#endif   return ((png_structp)png_ptr);}/* Initialize png_ptr structure, and allocate any memory needed */#undef png_write_initvoid PNGAPIpng_write_init(png_structp png_ptr){   /* We only come here via pre-1.0.7-compiled applications */   png_write_init_2(png_ptr, "1.0.0", 10000, 10000);}void PNGAPIpng_write_init_2(png_structp png_ptr, png_const_charp user_png_ver,   png_size_t png_struct_size, png_size_t png_info_size){#ifdef PNG_SETJMP_SUPPORTED   jmp_buf tmp_jmp; /* to save current jump buffer */#endif   int i = 0;   do   {     if (user_png_ver[i] != png_libpng_ver[i])     {#ifdef PNG_LEGACY_SUPPORTED       png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;#else       png_ptr->error_fn=(png_error_ptr)NULL;       png_error(png_ptr,       "Application uses deprecated png_write_init() and must be recompiled.");#endif     }   } while (png_libpng_ver[i++]);   if (sizeof(png_struct) > png_struct_size ||      sizeof(png_info) > png_info_size)     {       png_ptr->error_fn=(png_error_ptr)NULL;       png_error(png_ptr,      "Application and library have different sized structs. Please recompile.");     }   png_debug(1, "in png_write_init_2\n");#ifdef PNG_SETJMP_SUPPORTED   /* save jump buffer and error functions */   png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));#endif   /* reset all variables to 0 */   png_memset(png_ptr, 0, sizeof (png_struct));#ifdef PNG_SETJMP_SUPPORTED   /* restore jump buffer */   png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));#endif   /* initialize zbuf - compression buffer */   png_ptr->zbuf_size = PNG_ZBUF_SIZE;   png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,      (png_uint_32)png_ptr->zbuf_size);   png_set_write_fn(png_ptr, NULL, NULL, NULL);#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)   png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,      1, NULL, NULL);#endif}/* Write a few rows of image data.  If the image is interlaced, * either you will have to write the 7 sub images, or, if you * have called png_set_interlace_handling(), you will have to * "write" the image seven times. */void PNGAPIpng_write_rows(png_structp png_ptr, png_bytepp row,   png_uint_32 num_rows){   png_uint_32 i; /* row counter */   png_bytepp rp; /* row pointer */   png_debug(1, "in png_write_rows\n");   /* loop through the rows */   for (i = 0, rp = row; i < num_rows; i++, rp++)   {      png_write_row(png_ptr, *rp);   }}/* Write the image.  You only need to call this function once, even * if you are writing an interlaced image. */void PNGAPIpng_write_image(png_structp png_ptr, png_bytepp image){   png_uint_32 i; /* row index */   int pass, num_pass; /* pass variables */   png_bytepp rp; /* points to current row */   png_debug(1, "in png_write_image\n");#if defined(PNG_WRITE_INTERLACING_SUPPORTED)   /* intialize interlace handling.  If image is not interlaced,      this will set pass to 1 */   num_pass = png_set_interlace_handling(png_ptr);#else   num_pass = 1;#endif   /* loop through passes */   for (pass = 0; pass < num_pass; pass++)   {      /* loop through image */      for (i = 0, rp = image; i < png_ptr->height; i++, rp++)      {         png_write_row(png_ptr, *rp);      }   }}/* called by user to write a row of image data */void PNGAPIpng_write_row(png_structp png_ptr, png_bytep row){   png_debug2(1, "in png_write_row (row %ld, pass %d)\n",      png_ptr->row_number, png_ptr->pass);   /* initialize transformations and other stuff if first time */   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_WRITE_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_WRITE_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_WRITE_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_WRITE_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_WRITE_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_WRITE_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_WRITE_SWAP_SUPPORTED is not defined.");#endif      png_write_start_row(png_ptr);   }#if defined(PNG_WRITE_INTERLACING_SUPPORTED)   /* if interlaced and not interested in row, return */   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))   {      switch (png_ptr->pass)      {         case 0:            if (png_ptr->row_number & 0x07)            {               png_write_finish_row(png_ptr);               return;            }            break;         case 1:            if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)            {               png_write_finish_row(png_ptr);               return;            }            break;         case 2:            if ((png_ptr->row_number & 0x07) != 4)            {               png_write_finish_row(png_ptr);               return;            }            break;         case 3:            if ((png_ptr->row_number & 0x03) || png_ptr->width < 3)            {               png_write_finish_row(png_ptr);               return;            }            break;         case 4:            if ((png_ptr->row_number & 0x03) != 2)            {               png_write_finish_row(png_ptr);               return;            }            break;         case 5:            if ((png_ptr->row_number & 0x01) || png_ptr->width < 2)            {               png_write_finish_row(png_ptr);               return;            }            break;         case 6:            if (!(png_ptr->row_number & 0x01))            {               png_write_finish_row(png_ptr);               return;            }            break;      }   }#endif   /* set up row info for transformations */   png_ptr->row_info.color_type = png_ptr->color_type;   png_ptr->row_info.width = png_ptr->usr_width;   png_ptr->row_info.channels = png_ptr->usr_channels;   png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth;   png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *      png_ptr->row_info.channels);   png_ptr->row_info.rowbytes = ((png_ptr->row_info.width *      (png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3);   png_debug1(3, "row_info->color_type = %d\n", png_ptr->row_info.color_type);   png_debug1(3, "row_info->width = %lu\n", png_ptr->row_info.width);   png_debug1(3, "row_info->channels = %d\n", png_ptr->row_info.channels);   png_debug1(3, "row_info->bit_depth = %d\n", png_ptr->row_info.bit_depth);   png_debug1(3, "row_info->pixel_depth = %d\n", png_ptr->row_info.pixel_depth);   png_debug1(3, "row_info->rowbytes = %lu\n", png_ptr->row_info.rowbytes);   /* Copy user's row into buffer, leaving room for filter byte. */   png_memcpy_check(png_ptr, png_ptr->row_buf + 1, row,      png_ptr->row_info.rowbytes);#if defined(PNG_WRITE_INTERLACING_SUPPORTED)   /* handle interlacing */   if (png_ptr->interlaced && png_ptr->pass < 6 &&      (png_ptr->transformations & PNG_INTERLACE))   {      png_do_write_interlace(&(png_ptr->row_info),         png_ptr->row_buf + 1, png_ptr->pass);      /* this should always get caught above, but still ... */      if (!(png_ptr->row_info.width))      {         png_write_finish_row(png_ptr);         return;      }   }#endif   /* handle other transformations */   if (png_ptr->transformations)      png_do_write_transformations(png_ptr);#if defined(PNG_MNG_FEATURES_SUPPORTED)   /* Write filter_method 64 (intrapixel differencing) only if    * 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((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&      (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))   {      /* Intrapixel differencing */      png_do_write_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);   }#endif   /* Find a filter if necessary, filter the row and write it out. */   png_write_find_filter(png_ptr, &(png_ptr->row_info));   if (png_ptr->write_row_fn != NULL)      (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);}#if defined(PNG_WRITE_FLUSH_SUPPORTED)/* Set the automatic flush interval or 0 to turn flushing off */void PNGAPIpng_set_flush(png_structp png_ptr, int nrows){   png_debug(1, "in png_set_flush\n");   png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);}/* flush the current output buffers now */void PNGAPIpng_write_flush(png_structp png_ptr){   int wrote_IDAT;   png_debug(1, "in png_write_flush\n");   /* We have already written out all of the data */   if (png_ptr->row_number >= png_ptr->num_rows)     return;   do   {      int ret;      /* compress the data */      ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH);      wrote_IDAT = 0;      /* check for compression errors */      if (ret != Z_OK)      {         if (png_ptr->zstream.msg != NULL)            png_error(png_ptr, png_ptr->zstream.msg);         else            png_error(png_ptr, "zlib error");      }      if (!(png_ptr->zstream.avail_out))      {         /* write the IDAT and reset the zlib output buffer */         png_write_IDAT(png_ptr, png_ptr->zbuf,                        png_ptr->zbuf_size);         png_ptr->zstream.next_out = png_ptr->zbuf;         png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;         wrote_IDAT = 1;      }   } while(wrote_IDAT == 1);   /* If there is any data left to be output, write it into a new IDAT */   if (png_ptr->zbuf_size != png_ptr->zstream.avail_out)   {      /* write the IDAT and reset the zlib output buffer */      png_write_IDAT(png_ptr, png_ptr->zbuf,                     png_ptr->zbuf_size - png_ptr->zstream.avail_out);      png_ptr->zstream.next_out = png_ptr->zbuf;      png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;   }   png_ptr->flush_rows = 0;   png_flush(png_ptr);}#endif /* PNG_WRITE_FLUSH_SUPPORTED *//* free all memory used by the write */void PNGAPIpng_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr){   png_structp png_ptr = NULL;   png_infop info_ptr = NULL;#ifdef PNG_USER_MEM_SUPPORTED   png_free_ptr free_fn = NULL;#endif   png_debug(1, "in png_destroy_write_struct\n");   if (png_ptr_ptr != NULL)   {      png_ptr = *png_ptr_ptr;#ifdef PNG_USER_MEM_SUPPORTED      free_fn = png_ptr->free_fn;#endif   }   if (info_ptr_ptr != NULL)      info_ptr = *info_ptr_ptr;   if (info_ptr != NULL)   {      png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)      if (png_ptr->num_chunk_list)      {         png_free(png_ptr, png_ptr->chunk_list);         png_ptr->chunk_list=NULL;         png_ptr->num_chunk_list=0;      }#endif#ifdef PNG_USER_MEM_SUPPORTED      png_destroy_struct_2((png_voidp)info_ptr, free_fn);#else      png_destroy_struct((png_voidp)info_ptr);#endif      *info_ptr_ptr = (png_infop)NULL;   }