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)   {   /* make sure we wrote the header info */   if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))      png_error(png_ptr,         "png_write_info was never called before png_write_row.");   /* 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_ROWBYTES(png_ptr->row_info.pixel_depth,      png_ptr->row_info.width);   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;   png_voidp mem_ptr = 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;      mem_ptr = png_ptr->mem_ptr;#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, (png_free_ptr)free_fn,         (png_voidp)mem_ptr);#else      png_destroy_struct((png_voidp)info_ptr);#endif      *info_ptr_ptr = NULL;   }   if (png_ptr != NULL)   {      png_write_destroy(png_ptr);#ifdef PNG_USER_MEM_SUPPORTED      png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,         (png_voidp)mem_ptr);#else      png_destroy_struct((png_voidp)png_ptr);#endif      *png_ptr_ptr = NULL;   }}/* Free any memory used in png_ptr struct (old method) */void /* PRIVATE */png_write_destroy(png_structp png_ptr){#ifdef PNG_SETJMP_SUPPORTED   jmp_buf tmp_jmp; /* save jump buffer */#endif   png_error_ptr error_fn;   png_error_ptr warning_fn;   png_voidp error_ptr;#ifdef PNG_USER_MEM_SUPPORTED   png_free_ptr free_fn;#endif   png_debug(1, "in png_write_destroy\n");   /* free any memory zlib uses */   deflateEnd(&png_ptr->zstream);   /* free our memory.  png_free checks NULL for us. */   png_free(png_ptr, png_ptr->zbuf);   png_free(png_ptr, png_ptr->row_buf);   png_free(png_ptr, png_ptr->prev_row);   png_free(png_ptr, png_ptr->sub_row);   png_free(png_ptr, png_ptr->up_row);   png_free(png_ptr, png_ptr->avg_row);   png_free(png_ptr, png_ptr->paeth_row);#if defined(PNG_TIME_RFC1123_SUPPORTED)   png_free(png_ptr, png_ptr->time_buffer);#endif#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)   png_free(png_ptr, png_ptr->prev_filters);   png_free(png_ptr, png_ptr->filter_weights);   png_free(png_ptr, png_ptr->inv_filter_weights);   png_free(png_ptr, png_ptr->filter_costs);   png_free(png_ptr, png_ptr->inv_filter_costs);#endif#ifdef PNG_SETJMP_SUPPORTED   /* reset structure */   png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof (jmp_buf));#endif   error_fn = png_ptr->error_fn;   warning_fn = png_ptr->warning_fn;   error_ptr = png_ptr->error_ptr;#ifdef PNG_USER_MEM_SUPPORTED   free_fn = png_ptr->free_fn;#endif   png_memset(png_ptr, 0, png_sizeof (png_struct));   png_ptr->error_fn = error_fn;   png_ptr->warning_fn = warning_fn;   png_ptr->error_ptr = error_ptr;#ifdef PNG_USER_MEM_SUPPORTED   png_ptr->free_fn = free_fn;#endif#ifdef PNG_SETJMP_SUPPORTED   png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof (jmp_buf));#endif}/* Allow the application to select one or more row filters to use. */void PNGAPIpng_set_filter(png_structp png_ptr, int method, int filters){   png_debug(1, "in png_set_filter\n");#if defined(PNG_MNG_FEATURES_SUPPORTED)   if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&      (method == PNG_INTRAPIXEL_DIFFERENCING))         method = PNG_FILTER_TYPE_BASE;#endif   if (method == PNG_FILTER_TYPE_BASE)   {