Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
LIBPNG(3)		   Library Functions Manual		     LIBPNG(3)

NAME
       libpng -	Portable Network Graphics (PNG)	Reference Library 1.6.29

SYNOPSIS
	#include <png.h>

       png_uint_32 png_access_version_number (void);

       void png_benign_error (png_structp png_ptr, png_const_charp error);

       void png_build_grayscale_palette	(int bit_depth,	png_colorp palette);

       png_voidp png_calloc (png_structp png_ptr, png_alloc_size_t size);

       void  png_chunk_benign_error  (png_structp png_ptr, png_const_charp er-
       ror);

       void png_chunk_error (png_structp png_ptr, png_const_charp error);

       void png_chunk_warning (png_structp png_ptr, png_const_charp message);

       void png_convert_from_struct_tm	(png_timep  ptime,  struct  tm	FAR  *
       ttime);

       void png_convert_from_time_t (png_timep ptime, time_t ttime);

       png_charp   png_convert_to_rfc1123   (png_structp   png_ptr,  png_timep
       ptime);

       png_infop png_create_info_struct	(png_structp png_ptr);

       png_structp   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_structp   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_structp   png_create_write_struct   (png_const_charp	 user_png_ver,
       png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn);

       png_structp  png_create_write_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);

       void  png_data_freer  (png_structp  png_ptr,  png_infop	info_ptr,  int
       freer, png_uint_32 mask));

       void    png_destroy_info_struct	  (png_structp	 png_ptr,   png_infopp
       info_ptr_ptr);

       void  png_destroy_read_struct  (png_structpp  png_ptr_ptr,   png_infopp
       info_ptr_ptr, png_infopp	end_info_ptr_ptr);

       void  png_destroy_write_struct  (png_structpp  png_ptr_ptr,  png_infopp
       info_ptr_ptr);

       void png_err (png_structp png_ptr);

       void png_error (png_structp png_ptr, png_const_charp error);

       void png_free (png_structp png_ptr, png_voidp ptr);

       void png_free_chunk_list	(png_structp png_ptr);

       void png_free_default (png_structp png_ptr, png_voidp ptr);

       void png_free_data (png_structp png_ptr,	png_infop info_ptr, int	num);

       png_byte	png_get_bit_depth (png_const_structp png_ptr,  png_const_infop
       info_ptr);

       png_uint_32    png_get_bKGD   (png_const_structp	  png_ptr,   png_infop
       info_ptr, png_color_16p *background);

       png_byte	png_get_channels (png_const_structp  png_ptr,  png_const_infop
       info_ptr);

       png_uint_32  png_get_cHRM  (png_const_structp  png_ptr, png_const_infop
       info_ptr, double	 *white_x,  double  *white_y,  double  *red_x,	double
       *red_y,	double	*green_x,  double  *green_y,  double  *blue_x,	double
       *blue_y);

       png_uint_32     png_get_cHRM_fixed     (png_const_structp      png_ptr,
       png_const_infop	info_ptr,  png_uint_32 *white_x, png_uint_32 *white_y,
       png_uint_32   *red_x,   png_uint_32   *red_y,   png_uint_32   *green_x,
       png_uint_32 *green_y, png_uint_32 *blue_x, png_uint_32 *blue_y);

       png_uint_32   png_get_cHRM_XYZ  (png_structp  png_ptr,  png_const_infop
       info_ptr, double	*red_X,	double *red_Y, double *red_Z, double *green_X,
       double  *green_Y, double	*green_Z, double *blue_X, double *blue_Y, dou-
       ble *blue_Z);

       png_uint_32 png_get_cHRM_XYZ_fixed (png_structp png_ptr,	 png_const_in-
       fop  info_ptr,  png_fixed_point *int_red_X, png_fixed_point *int_red_Y,
       png_fixed_point	   *int_red_Z,	    png_fixed_point	 *int_green_X,
       png_fixed_point	   *int_green_Y,     png_fixed_point	 *int_green_Z,
       png_fixed_point	   *int_blue_X,	     png_fixed_point	  *int_blue_Y,
       png_fixed_point *int_blue_Z);

       png_uint_32 png_get_chunk_cache_max (png_const_structp png_ptr);

       png_alloc_size_t	png_get_chunk_malloc_max (png_const_structp png_ptr);

       png_byte	png_get_color_type (png_const_structp png_ptr, png_const_infop
       info_ptr);

       png_uint_32     png_get_compression_buffer_size	    (png_const_structp
       png_ptr);

       png_byte	    png_get_compression_type	(png_const_structp    png_ptr,
       png_const_infop info_ptr);

       png_byte	png_get_copyright (png_const_structp png_ptr);

       png_uint_32 png_get_current_row_number (png_const_structp);

       png_byte	png_get_current_pass_number (png_const_structp);

       png_voidp png_get_error_ptr (png_const_structp png_ptr);

       png_byte	png_get_filter_type (png_const_structp png_ptr,	 png_const_in-
       fop info_ptr);

       png_uint_32  png_get_gAMA  (png_const_structp  png_ptr, png_const_infop
       info_ptr, double	*file_gamma);

       png_uint_32     png_get_gAMA_fixed     (png_const_structp      png_ptr,
       png_const_infop info_ptr, png_uint_32 *int_file_gamma);

       png_byte	png_get_header_ver (png_const_structp png_ptr);

       png_byte	png_get_header_version (png_const_structp png_ptr);

       png_uint_32  png_get_hIST  (png_const_structp  png_ptr, png_const_infop
       info_ptr, png_uint_16p *hist);

       png_uint_32 png_get_iCCP	 (png_const_structp  png_ptr,  png_const_infop
       info_ptr,  png_charpp  name, int	*compression_type, png_bytepp profile,
       png_uint_32 *proflen);

       png_uint_32  png_get_IHDR  (png_structp	png_ptr,  png_infop  info_ptr,
       png_uint_32   *width,   png_uint_32   *height,	int   *bit_depth,  int
       *color_type, int	 *interlace_type,  int	*compression_type,  int	 *fil-
       ter_type);

       png_uint_32     png_get_image_height	(png_const_structp    png_ptr,
       png_const_infop info_ptr);

       png_uint_32     png_get_image_width     (png_const_structp     png_ptr,
       png_const_infop info_ptr);

       png_int_32 png_get_int_32 (png_bytep buf);

       png_byte	    png_get_interlace_type     (png_const_structp     png_ptr,
       png_const_infop info_ptr);

       png_uint_32 png_get_io_chunk_type (png_const_structp png_ptr);

       png_voidp png_get_io_ptr	(png_structp png_ptr);

       png_uint_32 png_get_io_state (png_structp png_ptr);

       png_byte	png_get_libpng_ver (png_const_structp png_ptr);

       int  png_get_palette_max(png_const_structp   png_ptr,   png_const_infop
       info_ptr);

       png_voidp png_get_mem_ptr (png_const_structp png_ptr);

       png_uint_32  png_get_oFFs  (png_const_structp  png_ptr, png_const_infop
       info_ptr,   png_uint_32	 *offset_x,   png_uint_32    *offset_y,	   int
       *unit_type);

       png_uint_32  png_get_pCAL  (png_const_structp  png_ptr, png_const_infop
       info_ptr, png_charp  *purpose,  png_int_32  *X0,	 png_int_32  *X1,  int
       *type, int *nparams, png_charp *units, png_charpp *params);

       png_uint_32  png_get_pHYs  (png_const_structp  png_ptr, png_const_infop
       info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type);

       float	png_get_pixel_aspect_ratio     (png_const_structp     png_ptr,
       png_const_infop info_ptr);

       png_uint_32  png_get_pHYs_dpi (png_const_structp	png_ptr, png_const_in-
       fop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type);

       png_fixed_point	 png_get_pixel_aspect_ratio_fixed   (png_const_structp
       png_ptr,	png_const_infop	info_ptr);

       png_uint_32    png_get_pixels_per_inch	 (png_const_structp   png_ptr,
       png_const_infop info_ptr);

       png_uint_32   png_get_pixels_per_meter	(png_const_structp    png_ptr,
       png_const_infop info_ptr);

       png_voidp png_get_progressive_ptr (png_const_structp png_ptr);

       png_uint_32  png_get_PLTE  (png_const_structp  png_ptr, png_const_infop
       info_ptr, png_colorp *palette, int *num_palette);

       png_byte	png_get_rgb_to_gray_status (png_const_structp png_ptr);

       png_uint_32 png_get_rowbytes (png_const_structp png_ptr,	 png_const_in-
       fop info_ptr);

       png_bytepp  png_get_rows	 (png_const_structp  png_ptr,  png_const_infop
       info_ptr);

       png_uint_32   png_get_sBIT   (png_const_structp	 png_ptr,    png_infop
       info_ptr, png_color_8p *sig_bit);

       void png_get_sCAL (png_const_structp png_ptr, png_const_infop info_ptr,
       int* unit, double* width, double* height);

       void  png_get_sCAL_fixed	 (png_const_structp  png_ptr,  png_const_infop
       info_ptr, int* unit, png_fixed_pointp width, png_fixed_pointp height);

       void   png_get_sCAL_s   (png_const_structp   png_ptr,   png_const_infop
       info_ptr, int* unit, png_charpp width, png_charpp height);

       png_bytep  png_get_signature  (png_const_structp	  png_ptr,   png_infop
       info_ptr);

       png_uint_32  png_get_sPLT  (png_const_structp  png_ptr, png_const_infop
       info_ptr, png_spalette_p	*splt_ptr);

       png_uint_32 png_get_sRGB	 (png_const_structp  png_ptr,  png_const_infop
       info_ptr, int *file_srgb_intent);

       png_uint_32  png_get_text  (png_const_structp  png_ptr, png_const_infop
       info_ptr, png_textp *text_ptr, int *num_text);

       png_uint_32   png_get_tIME   (png_const_structp	 png_ptr,    png_infop
       info_ptr, png_timep *mod_time);

       png_uint_32    png_get_tRNS   (png_const_structp	  png_ptr,   png_infop
       info_ptr,  png_bytep  *trans_alpha,   int   *num_trans,	 png_color_16p
       *trans_color);

       /* This function	is really an inline macro. */

       png_uint_16 png_get_uint_16 (png_bytep buf);

       png_uint_32 png_get_uint_31 (png_structp	png_ptr, png_bytep buf);

       /* This function	is really an inline macro. */

       png_uint_32 png_get_uint_32 (png_bytep buf);

       png_uint_32    png_get_unknown_chunks	(png_const_structp    png_ptr,
       png_const_infop info_ptr, png_unknown_chunkpp unknowns);

       png_voidp png_get_user_chunk_ptr	(png_const_structp png_ptr);

       png_uint_32 png_get_user_height_max (png_const_structp png_ptr);

       png_voidp png_get_user_transform_ptr (png_const_structp png_ptr);

       png_uint_32 png_get_user_width_max (png_const_structp png_ptr);

       png_uint_32 png_get_valid (png_const_structp  png_ptr,  png_const_infop
       info_ptr, png_uint_32 flag);

       float png_get_x_offset_inches (png_const_structp	png_ptr, png_const_in-
       fop info_ptr);

       png_fixed_point	png_get_x_offset_inches_fixed  (png_structp   png_ptr,
       png_const_infop info_ptr);

       png_int_32    png_get_x_offset_microns	 (png_const_structp   png_ptr,
       png_const_infop info_ptr);

       png_int_32    png_get_x_offset_pixels	(png_const_structp    png_ptr,
       png_const_infop info_ptr);

       png_uint_32   png_get_x_pixels_per_inch	 (png_const_structp   png_ptr,
       png_const_infop info_ptr);

       png_uint_32  png_get_x_pixels_per_meter	 (png_const_structp   png_ptr,
       png_const_infop info_ptr);

       float png_get_y_offset_inches (png_const_structp	png_ptr, png_const_in-
       fop info_ptr);

       png_fixed_point	png_get_y_offset_inches_fixed  (png_structp   png_ptr,
       png_const_infop info_ptr);

       png_int_32    png_get_y_offset_microns	 (png_const_structp   png_ptr,
       png_const_infop info_ptr);

       png_int_32    png_get_y_offset_pixels	(png_const_structp    png_ptr,
       png_const_infop info_ptr);

       png_uint_32   png_get_y_pixels_per_inch	 (png_const_structp   png_ptr,
       png_const_infop info_ptr);

       png_uint_32  png_get_y_pixels_per_meter	 (png_const_structp   png_ptr,
       png_const_infop info_ptr);

       int png_handle_as_unknown (png_structp png_ptr, png_bytep chunk_name);

       int   png_image_begin_read_from_file   (png_imagep  image,  const  char
       *file_name);

       int png_image_begin_read_from_stdio (png_imagep image, FILE* file);

       int,	 png_image_begin_read_from_memory      (png_imagep	image,
       png_const_voidp memory, png_size_t size);

       int  png_image_finish_read  (png_imagep	image,	png_colorp background,
       void *buffer, png_int_32	row_stride, void *colormap);

       void png_image_free (png_imagep image);

       int png_image_write_to_file (png_imagep image, const  char  *file,  int
       convert_to_8bit,	 const void *buffer, png_int_32	row_stride, void *col-
       ormap);

       int png_image_write_to_memory (png_imagep image,	void *memory,  png_al-
       loc_size_t  *  PNG_RESTRICT  memory_bytes,  int convert_to_8_bit, const
       void *buffer, png_int_32	row_stride, const void *colormap));

       int png_image_write_to_stdio (png_imagep	image, FILE  *file,  int  con-
       vert_to_8_bit,  const  void  *buffer, png_int_32	row_stride, void *col-
       ormap));

       void	png_info_init_3	    (png_infopp	     info_ptr,	    png_size_t
       png_info_struct_size);

       void png_init_io	(png_structp png_ptr, FILE *fp);

       void png_longjmp	(png_structp png_ptr, int val);

       png_voidp png_malloc (png_structp png_ptr, png_alloc_size_t size);

       png_voidp  png_malloc_default  (png_structp  png_ptr,  png_alloc_size_t
       size);

       png_voidp png_malloc_warn (png_structp png_ptr, png_alloc_size_t	size);

       png_uint_32 png_permit_mng_features (png_structp	 png_ptr,  png_uint_32
       mng_features_permitted);

       void   png_process_data	 (png_structp	png_ptr,  png_infop  info_ptr,
       png_bytep buffer, png_size_t buffer_size);

       png_size_t png_process_data_pause (png_structp, int save);

       png_uint_32 png_process_data_skip (png_structp);

       void  png_progressive_combine_row   (png_structp	  png_ptr,   png_bytep
       old_row,	png_bytep new_row);

       void png_read_end (png_structp png_ptr, png_infop info_ptr);

       void png_read_image (png_structp	png_ptr, png_bytepp image);

       void png_read_info (png_structp png_ptr,	png_infop info_ptr);

       void  png_read_png (png_structp png_ptr,	png_infop info_ptr, int	trans-
       forms, png_voidp	params);

       void png_read_row (png_structp png_ptr, png_bytep row,  png_bytep  dis-
       play_row);

       void  png_read_rows  (png_structp  png_ptr,  png_bytepp row, png_bytepp
       display_row, png_uint_32	num_rows);

       void png_read_update_info (png_structp png_ptr, png_infop info_ptr);

       int png_reset_zstream (png_structp png_ptr);

       void png_save_int_32 (png_bytep buf, png_int_32 i);

       void png_save_uint_16 (png_bytep	buf, unsigned int i);

       void png_save_uint_32 (png_bytep	buf, png_uint_32 i);

       void png_set_add_alpha (png_structp png_ptr,  png_uint_32  filler,  int
       flags);

       void  png_set_alpha_mode	 (png_structp  png_ptr,	 int mode, double out-
       put_gamma);

       void   png_set_alpha_mode_fixed	 (png_structp	png_ptr,   int	 mode,
       png_fixed_point output_gamma);

       void   png_set_background  (png_structp	png_ptr,  png_color_16p	 back-
       ground_color, int background_gamma_code,	int need_expand, double	 back-
       ground_gamma);

       void png_set_background_fixed (png_structp png_ptr, png_color_16p back-
       ground_color, int background_gamma_code,	int  need_expand,  png_uint_32
       background_gamma);

       void png_set_benign_errors (png_structp png_ptr,	int allowed);

       void png_set_bgr	(png_structp png_ptr);

       void    png_set_bKGD    (png_structp   png_ptr,	 png_infop   info_ptr,
       png_color_16p background);

       void  png_set_check_for_invalid_index(png_structrp  png_ptr,  int   al-
       lowed);

       void  png_set_cHRM  (png_structp	 png_ptr,  png_infop  info_ptr,	double
       white_x,	double white_y,	double red_x, double  red_y,  double  green_x,
       double green_y, double blue_x, double blue_y);

       void   png_set_cHRM_fixed  (png_structp	png_ptr,  png_infop  info_ptr,
       png_uint_32   white_x,	png_uint_32   white_y,	 png_uint_32	red_x,
       png_uint_32    red_y,   png_uint_32   green_x,	png_uint_32   green_y,
       png_uint_32 blue_x, png_uint_32 blue_y);

       void png_set_cHRM_XYZ (png_structp png_ptr, png_infop info_ptr,	double
       red_X, double red_Y, double red_Z, double green_X, double green_Y, dou-
       ble green_Z, double blue_X, double blue_Y, double blue_Z);

       void png_set_cHRM_XYZ_fixed (png_structp	png_ptr,  png_infop  info_ptr,
       png_fixed_point	int_red_X,  png_fixed_point int_red_Y, png_fixed_point
       int_red_Z, png_fixed_point  int_green_X,	 png_fixed_point  int_green_Y,
       png_fixed_point	    int_green_Z,      png_fixed_point	   int_blue_X,
       png_fixed_point int_blue_Y, png_fixed_point int_blue_Z);

       void   png_set_chunk_cache_max	(png_structp   png_ptr,	   png_uint_32
       user_chunk_cache_max);

       void png_set_compression_level (png_structp png_ptr, int	level);

       void    png_set_compression_mem_level	(png_structp	png_ptr,   int
       mem_level);

       void png_set_compression_method (png_structp png_ptr, int method);

       void png_set_compression_strategy (png_structp png_ptr, int strategy);

       void png_set_compression_window_bits  (png_structp  png_ptr,  int  win-
       dow_bits);

       void  png_set_crc_action	(png_structp png_ptr, int crit_action, int an-
       cil_action);

       void  png_set_error_fn  (png_structp  png_ptr,	png_voidp   error_ptr,
       png_error_ptr error_fn, png_error_ptr warning_fn);

       void png_set_expand (png_structp	png_ptr);

       void png_set_expand_16 (png_structp png_ptr);

       void png_set_expand_gray_1_2_4_to_8 (png_structp	png_ptr);

       void  png_set_filler  (png_structp  png_ptr,  png_uint_32  filler,  int
       flags);

       void png_set_filter (png_structp	png_ptr, int method, int filters);

       void  png_set_filter_heuristics	(png_structp  png_ptr,	 int   heuris-
       tic_method,  int	 num_weights,  png_doublep filter_weights, png_doublep
       filter_costs);

       void png_set_filter_heuristics_fixed (png_structp png_ptr, int  heuris-
       tic_method,    int   num_weights,   png_fixed_point_p   filter_weights,
       png_fixed_point_p filter_costs);

       void png_set_flush (png_structp png_ptr,	int nrows);

       void png_set_gamma (png_structp png_ptr,	 double	 screen_gamma,	double
       default_file_gamma);

       void	png_set_gamma_fixed    (png_structp    png_ptr,	   png_uint_32
       screen_gamma, png_uint_32 default_file_gamma);

       void png_set_gAMA  (png_structp	png_ptr,  png_infop  info_ptr,	double
       file_gamma);

       void   png_set_gAMA_fixed  (png_structp	png_ptr,  png_infop  info_ptr,
       png_uint_32 file_gamma);

       void png_set_gray_1_2_4_to_8 (png_structp png_ptr);

       void png_set_gray_to_rgb	(png_structp png_ptr);

       void   png_set_hIST   (png_structp   png_ptr,	png_infop    info_ptr,
       png_uint_16p hist);

       void    png_set_iCCP    (png_structp   png_ptr,	 png_infop   info_ptr,
       png_const_charp name, int  compression_type,  png_const_bytep  profile,
       png_uint_32 proflen);

       int png_set_interlace_handling (png_structp png_ptr);

       void  png_set_invalid  (png_structp  png_ptr,  png_infop	 info_ptr, int
       mask);

       void png_set_invert_alpha (png_structp png_ptr);

       void png_set_invert_mono	(png_structp png_ptr);

       void png_set_IHDR (png_structp png_ptr, png_infop info_ptr, png_uint_32
       width,  png_uint_32  height,  int bit_depth, int	color_type, int	inter-
       lace_type, int compression_type,	int filter_type);

       void  png_set_keep_unknown_chunks  (png_structp	png_ptr,   int	 keep,
       png_bytep chunk_list, int num_chunks);

       jmp_buf*	  png_set_longjmp_fn   (png_structp  png_ptr,  png_longjmp_ptr
       longjmp_fn, size_t jmp_buf_size);

       void png_set_chunk_malloc_max  (png_structp  png_ptr,  png_alloc_size_t
       user_chunk_cache_max);

       void  png_set_compression_buffer_size (png_structp png_ptr, png_uint_32
       size);

       void png_set_mem_fn (png_structp	png_ptr, png_voidp  mem_ptr,  png_mal-
       loc_ptr malloc_fn, png_free_ptr free_fn);

       void png_set_oFFs (png_structp png_ptr, png_infop info_ptr, png_uint_32
       offset_x, png_uint_32 offset_y, int unit_type);

       int png_set_option(png_structrp png_ptr,	int option, int	onoff);

       void png_set_packing (png_structp png_ptr);

       void png_set_packswap (png_structp png_ptr);

       void png_set_palette_to_rgb (png_structp	png_ptr);

       void png_set_pCAL (png_structp png_ptr, png_infop  info_ptr,  png_charp
       purpose,	png_int_32 X0, png_int_32 X1, int type,	int nparams, png_charp
       units, png_charpp params);

       void png_set_pHYs (png_structp png_ptr, png_infop info_ptr, png_uint_32
       res_x, png_uint_32 res_y, int unit_type);

       void  png_set_progressive_read_fn  (png_structp png_ptr,	png_voidp pro-
       gressive_ptr, png_progressive_info_ptr info_fn, png_progressive_row_ptr
       row_fn, png_progressive_end_ptr end_fn);

       void  png_set_PLTE (png_structp png_ptr,	png_infop info_ptr, png_colorp
       palette,	int num_palette);

       void png_set_quantize (png_structp  png_ptr,  png_colorp	 palette,  int
       num_palette, int	maximum_colors,	png_uint_16p histogram,	int full_quan-
       tize);

       void png_set_read_fn (png_structp png_ptr, png_voidp io_ptr, png_rw_ptr
       read_data_fn);

       void  png_set_read_status_fn  (png_structp png_ptr, png_read_status_ptr
       read_row_fn);

       void   png_set_read_user_chunk_fn   (png_structp	  png_ptr,   png_voidp
       user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn);

       void	 png_set_read_user_transform_fn	     (png_structp     png_ptr,
       png_user_transform_ptr read_user_transform_fn);

       void png_set_rgb_to_gray	(png_structp png_ptr, int error_action,	double
       red, double green);

       void  png_set_rgb_to_gray_fixed	(png_structp png_ptr, int error_action
       png_uint_32 red,	png_uint_32 green);

       void png_set_rows (png_structp png_ptr, png_infop info_ptr,  png_bytepp
       row_pointers);

       void    png_set_sBIT    (png_structp   png_ptr,	 png_infop   info_ptr,
       png_color_8p sig_bit);

       void png_set_sCAL (png_structp png_ptr, png_infop info_ptr,  int	 unit,
       double width, double height);

       void  png_set_sCAL_fixed	 (png_structp png_ptr, png_infop info_ptr, int
       unit, png_fixed_point width, png_fixed_point height);

       void png_set_sCAL_s (png_structp	png_ptr, png_infop info_ptr, int unit,
       png_charp width,	png_charp height);

       void png_set_scale_16 (png_structp png_ptr);

       void png_set_shift (png_structp png_ptr,	png_color_8p true_bits);

       void png_set_sig_bytes (png_structp png_ptr, int	num_bytes);

       void    png_set_sPLT    (png_structp   png_ptr,	 png_infop   info_ptr,
       png_spalette_p splt_ptr,	int num_spalettes);

       void  png_set_sRGB  (png_structp	 png_ptr,  png_infop   info_ptr,   int
       srgb_intent);

       void   png_set_sRGB_gAMA_and_cHRM   (png_structp	  png_ptr,   png_infop
       info_ptr, int srgb_intent);

       void png_set_strip_16 (png_structp png_ptr);

       void png_set_strip_alpha	(png_structp png_ptr);

       void  png_set_strip_error_numbers  (png_structp	png_ptr,   png_uint_32
       strip_mode);

       void png_set_swap (png_structp png_ptr);

       void png_set_swap_alpha (png_structp png_ptr);

       void  png_set_text  (png_structp	png_ptr, png_infop info_ptr, png_textp
       text_ptr, int num_text);

       void png_set_text_compression_level (png_structp	png_ptr, int level);

       void  png_set_text_compression_mem_level	 (png_structp	png_ptr,   int
       mem_level);

       void png_set_text_compression_strategy (png_structp png_ptr, int	strat-
       egy);

       void  png_set_text_compression_window_bits  (png_structp	 png_ptr,  int
       window_bits);

       void   png_set_text_compression_method,	 (png_structp	png_ptr,   int
       method));

       void png_set_tIME (png_structp png_ptr, png_infop  info_ptr,  png_timep
       mod_time);

       void  png_set_tRNS  (png_structp	png_ptr, png_infop info_ptr, png_bytep
       trans_alpha, int	num_trans, png_color_16p trans_color);

       void png_set_tRNS_to_alpha (png_structp png_ptr);

       png_uint_32  png_set_unknown_chunks  (png_structp  png_ptr,   png_infop
       info_ptr, png_unknown_chunkp unknowns, int num, int location);

       void  png_set_unknown_chunk_location  (png_structp  png_ptr,  png_infop
       info_ptr, int chunk, int	location);

       void    png_set_user_limits    (png_structp    png_ptr,	   png_uint_32
       user_width_max, png_uint_32 user_height_max);

       void   png_set_user_transform_info   (png_structp   png_ptr,  png_voidp
       user_transform_ptr, int user_transform_depth, int  user_transform_chan-
       nels);

       void   png_set_write_fn	 (png_structp	png_ptr,   png_voidp   io_ptr,
       png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn);

       void png_set_write_status_fn (png_structp png_ptr, png_write_status_ptr
       write_row_fn);

       void	 png_set_write_user_transform_fn     (png_structp     png_ptr,
       png_user_transform_ptr write_user_transform_fn);

       int  png_sig_cmp	  (png_bytep   sig,   png_size_t   start,   png_size_t
       num_to_check);

       void png_start_read_image (png_structp png_ptr);

       void png_warning	(png_structp png_ptr, png_const_charp message);

       void   png_write_chunk	(png_structp  png_ptr,	png_bytep  chunk_name,
       png_bytep data, png_size_t length);

       void  png_write_chunk_data  (png_structp	  png_ptr,   png_bytep	 data,
       png_size_t length);

       void png_write_chunk_end	(png_structp png_ptr);

       void  png_write_chunk_start (png_structp	png_ptr, png_bytep chunk_name,
       png_uint_32 length);

       void png_write_end (png_structp png_ptr,	png_infop info_ptr);

       void png_write_flush (png_structp png_ptr);

       void png_write_image (png_structp png_ptr, png_bytepp image);

       void png_write_info (png_structp	png_ptr, png_infop info_ptr);

       void   png_write_info_before_PLTE   (png_structp	  png_ptr,   png_infop
       info_ptr);

       void png_write_png (png_structp png_ptr,	png_infop info_ptr, int	trans-
       forms, png_voidp	params);

       void png_write_row (png_structp png_ptr,	png_bytep row);

       void png_write_rows (png_structp	png_ptr, png_bytepp  row,  png_uint_32
       num_rows);

       void png_write_sig (png_structp png_ptr);

DESCRIPTION
       The  libpng  library supports encoding, decoding, and various manipula-
       tions of	the Portable Network Graphics (PNG) format  image  files.   It
       uses  the  zlib(3)  compression	library.   Following  is a copy	of the
       libpng-manual.txt file that accompanies libpng.

LIBPNG.TXT
       libpng-manual.txt - A description on how	to use and modify libpng

	libpng version 1.6.29 -	March 16, 2017
	Updated	and distributed	by Glenn Randers-Pehrson
	<glennrp at users.sourceforge.net>
	Copyright (c) 1998-2016	Glenn Randers-Pehrson

	This document is released under	the libpng license.
	For conditions of distribution and use,	see the	disclaimer
	and license in png.h

	Based on:

	libpng versions	0.97, January 1998, through 1.6.29 - March 16, 2017
	Updated	and distributed	by Glenn Randers-Pehrson
	Copyright (c) 1998-2016	Glenn Randers-Pehrson

	libpng 1.0 beta	6 - version 0.96 - May 28, 1997
	Updated	and distributed	by Andreas Dilger
	Copyright (c) 1996, 1997 Andreas Dilger

	libpng 1.0 beta	2 - version 0.88 - January 26, 1996
	For conditions of distribution and use,	see copyright
	notice in png.h. Copyright (c) 1995, 1996 Guy Eric
	Schalnat, Group	42, Inc.

	Updated/rewritten per request in the libpng FAQ
	Copyright (c) 1995, 1996 Frank J. T. Wojcik
	December 18, 1995 & January 20,	1996

	TABLE OF CONTENTS

	   I. Introduction
	  II. Structures
	 III. Reading
	  IV. Writing
	   V. Simplified API
	  VI. Modifying/Customizing libpng
	 VII. MNG support
	VIII. Changes to Libpng	from version 0.88
	  IX. Changes to Libpng	from version 1.0.x to 1.2.x
	   X. Changes to Libpng	from version 1.0.x/1.2.x to 1.4.x
	  XI. Changes to Libpng	from version 1.4.x to 1.5.x
	 XII. Changes to Libpng	from version 1.5.x to 1.6.x
	XIII. Detecting	libpng
	 XIV. Source code repository
	  XV. Coding style
	 XVI. Y2K Compliance in	libpng

I. Introduction
       This file describes how to use and modify  the  PNG  reference  library
       (known  as  libpng)  for	your own use.  In addition to this file, exam-
       ple.c is	a good starting	point for using	the library, as	it is  heavily
       commented  and should include everything	most people will need.	We as-
       sume that libpng	is already installed; see the  INSTALL	file  for  in-
       structions on how to configure and install libpng.

       For  examples  of libpng	usage, see the files "example.c", "pngtest.c",
       and the files in	the "contrib" directory, all of	which are included  in
       the libpng distribution.

       Libpng was written as a companion to the	PNG specification, as a	way of
       reducing	the amount of time and effort it takes to support the PNG file
       format in application programs.

       The  PNG	specification (second edition),	November 2003, is available as
       a W3C Recommendation and	as an ISO Standard (ISO/IEC 15948:2004 (E)) at
       <http://www.w3.org/TR/2003/REC-PNG-20031110/  The W3C and ISO documents
       have identical technical	content.

       The  PNG-1.2  specification  is	available  at  <http://png-mng.source-
       forge.net/pub/png/spec/1.2/>.   It is technically equivalent to the PNG
       specification (second edition) but has some additional material.

       The  PNG-1.0  specification  is	available  as  RFC  2083  <http://png-
       mng.sourceforge.net/pub/png/spec/1.0/>  and  as	a  W3C	Recommendation
       <http://www.w3.org/TR/REC-png-961001>.

       Some additional chunks are  described  in  the  special-purpose	public
       chunks documents	at <http://www.libpng.org/pub/png/spec/register/>

       Other  information  about PNG, and the latest version of	libpng,	can be
       found at	the PNG	home page, <http://www.libpng.org/pub/png/>.

       Most users will not have	to modify the library significantly;  advanced
       users may want to modify	it more.  All attempts were made to make it as
       complete	as possible, while keeping the code easy to understand.	  Cur-
       rently,	this  library only supports C.	Support	for other languages is
       being considered.

       Libpng has been designed	to handle multiple sessions at one time, to be
       easily  modifiable,  to	be  portable  to the vast majority of machines
       (ANSI, K&R, 16-,	32-, and 64-bit) available, and	to  be	easy  to  use.
       The  ultimate  goal  of	libpng is to promote the acceptance of the PNG
       file format in whatever way possible.  While there is still work	to  be
       done (see the TODO file), libpng	should cover the majority of the needs
       of its users.

       Libpng uses zlib	for its	compression and	decompression  of  PNG	files.
       Further	information about zlib,	and the	latest version of zlib,	can be
       found at	the zlib home page, <http://zlib.net/>.	 The zlib  compression
       utility	is  a general purpose utility that is useful for more than PNG
       files, and can be used without libpng.  See the documentation delivered
       with  zlib for more details.  You can usually find the source files for
       the zlib	utility	wherever you find the libpng source files.

       Libpng is thread	safe, provided the threads  are	 using	different  in-
       stances	of the structures.  Each thread	should have its	own png_struct
       and png_info instances, and thus	its own	image.	Libpng does  not  pro-
       tect itself against two threads using the same instance of a structure.

II. Structures
       There  are two main structures that are important to libpng, png_struct
       and png_info.  Both are internal	structures that	are no longer  exposed
       in the libpng interface (as of libpng 1.5.0).

       The png_info structure is designed to provide information about the PNG
       file.  At one time, the fields of png_info were intended	to be directly
       accessible  to  the  user.  However, this tended	to cause problems with
       applications using dynamically loaded libraries,	and as a result	a  set
       of  interface  functions	 for png_info (the png_get_*() and png_set_*()
       functions) was developed, and direct access to the png_info fields  was
       deprecated..

       The  png_struct structure is the	object used by the library to decode a
       single image.  As of 1.5.0 this structure is also not exposed.

       Almost all libpng APIs require a	pointer	to a png_struct	as  the	 first
       argument.   Many	 (in particular	the png_set and	png_get	APIs) also re-
       quire a pointer to png_info as the second argument.   Some  application
       visible macros defined in png.h designed	for basic data access (reading
       and writing integers in the PNG format) don't take a png_info  pointer,
       but  it's  almost  always safe to assume	that a (png_struct*) has to be
       passed to call an API function.

       You can have more than one png_info structure associated	with an	image,
       as  illustrated	in  pngtest.c,	one for	information valid prior	to the
       IDAT chunks and another (called	"end_info"  below)  for	 things	 after
       them.

       The  png.h  header file is an invaluable	reference for programming with
       libpng.	And while I'm on the topic, make sure you include  the	libpng
       header file:

       #include	<png.h>

       and also	(as of libpng-1.5.0) the zlib header file, if you need it:

       #include	<zlib.h>

   Types
       The  png.h  header  file	defines	a number of integral types used	by the
       APIs.  Most of these are	fairly obvious;	for example types  correspond-
       ing to integers of particular sizes and types for passing color values.

       One exception is	how non-integral numbers are handled.  For application
       convenience most	APIs that take such numbers have C (double) arguments;
       however,	internally PNG,	and libpng, use	32 bit signed integers and en-
       code the	value by multiplying by	100,000.  As of	libpng 1.5.0 a	conve-
       nience	macro	PNG_FP_1  is  defined  in  png.h  along	 with  a  type
       (png_fixed_point) which is simply (png_int_32).

       All APIs	that take (double) arguments also have	a  matching  API  that
       takes the corresponding fixed point integer arguments.  The fixed point
       API has the same	name as	the floating point one with "_fixed" appended.
       The  actual  range  of  values permitted	in the APIs is frequently less
       than the	full range of (png_fixed_point)	(-21474	to +21474).  When APIs
       require	a  non-negative	 argument  the type is recorded	as png_uint_32
       above.  Consult the header file and the text below  for	more  informa-
       tion.

       Special	care  must  be take with sCAL chunk handling because the chunk
       itself uses non-integral	values encoded as strings  containing  decimal
       floating	point numbers.	See the	comments in the	header file.

   Configuration
       The  main header	file function declarations are frequently protected by
       C preprocessing directives of the form:

	   #ifdef PNG_feature_SUPPORTED
	   declare-function
	   #endif
	   ...
	   #ifdef PNG_feature_SUPPORTED
	   use-function
	   #endif

       The library can be built	without	support	for  these  APIs,  although  a
       standard	 build	will  have all implemented APIs.  Application programs
       should check the	feature	macros before using an API for maximum	porta-
       bility.	 From  libpng 1.5.0 the	feature	macros set during the build of
       libpng are recorded in the header file "pnglibconf.h" and this file  is
       always included by png.h.

       If you don't need to change the library configuration from the default,
       skip to the next	section	("Reading").

       Notice that some	of the makefiles in the	'scripts'  directory  and  (in
       1.5.0)  all of the build	project	files in the 'projects'	directory sim-
       ply copy	scripts/pnglibconf.h.prebuilt  to  pnglibconf.h.   This	 means
       that  these  build systems do not permit	easy auto-configuration	of the
       library - they only support the default configuration.

       The easiest way to make minor changes to	the libpng configuration  when
       auto-configuration  is  supported  is to	add definitions	to the command
       line using (typically) CPPFLAGS.	 For example:

       CPPFLAGS=-DPNG_NO_FLOATING_ARITHMETIC

       will change the internal	libpng math implementation for	gamma  correc-
       tion  and  other	 arithmetic  calculations to fixed point, avoiding the
       need for	fast floating point support.  The result can be	 seen  in  the
       generated  pnglibconf.h	-  make	 sure  it contains the changed feature
       macro setting.

       If you need to make more	extensive configuration	changes	 -  more  than
       one  or two feature macro settings - you	can either add -DPNG_USER_CON-
       FIG to the build	command	line and put a list of feature macro  settings
       in  pngusr.h  or	 you  can set DFA_XTRA (a makefile variable) to	a file
       containing the same information in the form of 'option' settings.

       A. Changing pnglibconf.h

       A variety of methods exist to build libpng.  Not	all of	these  support
       reconfiguration	of  pnglibconf.h.  To reconfigure pnglibconf.h it must
       either be rebuilt from scripts/pnglibconf.dfa using awk or it  must  be
       edited by hand.

       Hand  editing  is  achieved by copying scripts/pnglibconf.h.prebuilt to
       pnglibconf.h and	changing the lines defining  the  supported  features,
       paying	very   close   attention   to	the  'option'  information  in
       scripts/pnglibconf.dfa that describes those features and	their require-
       ments.  This is easy to get wrong.

       B. Configuration	using DFA_XTRA

       Rebuilding  from	 pnglibconf.dfa	 is  easy if a functioning 'awk', or a
       later variant such as 'nawk' or 'gawk', is  available.	The  configure
       build  will  automatically  find	 an  appropriate awk and build pnglib-
       conf.h.	The scripts/pnglibconf.mak file	contains a set of  make	 rules
       for  doing  the	same  thing  if	configure is not used, and many	of the
       makefiles in the	scripts	directory use this approach.

       When rebuilding simply write a new file containing changed options  and
       set DFA_XTRA to the name	of this	file.  This causes the build to	append
       the new file to the end of scripts/pnglibconf.dfa.  The pngusr.dfa file
       should contain lines of the following forms:

       everything = off

       This  turns  all	optional features off.	Include	it at the start	of pn-
       gusr.dfa	to make	it easier to build a minimal configuration.  You  will
       need to turn at least some features on afterward	to enable either read-
       ing or writing code, or both.

       option feature on option	feature	off

       Enable or disable a single feature.   This  will	 automatically	enable
       other features required by a feature that is turned on or disable other
       features	that require a feature which is	turned off.  Conflicting  set-
       tings will cause	an error message to be emitted by awk.

       setting feature default value

       Changes the default value of setting 'feature' to 'value'.  There are a
       small number of settings	listed at the top of  pnglibconf.h,  they  are
       documented  in  the source code.	 Most of these values have performance
       implications for	the library but	most of	them have no visible effect on
       the API.	 Some can also be overridden from the API.

       This  method  of	 building  a customized	pnglibconf.h is	illustrated in
       contrib/pngminim/*.  See	the "$(PNGCONF):" target in the	 makefile  and
       pngusr.dfa in these directories.

       C. Configuration	using PNG_USER_CONFIG

       If  -DPNG_USER_CONFIG  is  added	 to  the CPPFLAGS when pnglibconf.h is
       built, the file pngusr.h	will automatically be included before the  op-
       tions  in  scripts/pnglibconf.dfa  are  processed.   Your pngusr.h file
       should contain only macro definitions turning features  on  or  off  or
       setting settings.

       Apart from the global setting "everything = off"	all the	options	listed
       above can be set	using macros in	pngusr.h:

       #define PNG_feature_SUPPORTED

       is equivalent to:

       option feature on

       #define PNG_NO_feature

       is equivalent to:

       option feature off

       #define PNG_feature value

       is equivalent to:

       setting feature default value

       Notice that in both cases, pngusr.dfa and pngusr.h, the contents	of the
       pngusr file you supply override the contents of scripts/pnglibconf.dfa

       If confusing or incomprehensible	behavior results it is possible	to ex-
       amine the intermediate file pnglibconf.dfn to find the full set of  de-
       pendency	 information  for  each	setting	and option.  Simply locate the
       feature in the file and read the	C comments that	precede	it.

       This method is also illustrated in the contrib/pngminim/* makefiles and
       pngusr.h.

III. Reading
       We'll  now walk you through the possible	functions to call when reading
       in a PNG	file sequentially, briefly explaining the syntax  and  purpose
       of  each	one.  See example.c and	png.h for more detail.	While progres-
       sive reading is covered in the next section, you	will still  need  some
       of the functions	discussed in this section to read a PNG	file.

   Setup
       You  will  want	to  do	the  I/O initialization(*) before you get into
       libpng, so if it	doesn't	work, you don't	have much to undo.  Of course,
       you  will also want to insure that you are, in fact, dealing with a PNG
       file.  Libpng provides a	simple check to	see if a file is a  PNG	 file.
       To  use	it, pass in the	first 1	to 8 bytes of the file to the function
       png_sig_cmp(), and it will return 0 (false) if the bytes	match the cor-
       responding bytes	of the PNG signature, or nonzero (true)	otherwise.  Of
       course, the more	bytes you pass in, the greater	the  accuracy  of  the
       prediction.

       If  you	are intending to keep the file pointer open for	use in libpng,
       you must	ensure you don't read more than	8 bytes	from the beginning  of
       the  file, and you also have to make a call to png_set_sig_bytes() with
       the number of bytes you read from the beginning.	 Libpng	will then only
       check the bytes (if any)	that your program didn't read.

       (*):  If	you are	not using the standard I/O functions, you will need to
       replace them with custom	functions.  See	the discussion under Customiz-
       ing libpng.

	   FILE	*fp = fopen(file_name, "rb");
	   if (!fp)
	   {
	      return (ERROR);
	   }

	   if (fread(header, 1,	number,	fp) != number)
	   {
	      return (ERROR);
	   }

	   is_png = !png_sig_cmp(header, 0, number);
	   if (!is_png)
	   {
	      return (NOT_PNG);
	   }

       Next, png_struct	and png_info need to be	allocated and initialized.  In
       order to	ensure that the	size of	these structures is correct even  with
       a  dynamically linked libpng, there are functions to initialize and al-
       locate the structures.  We also	pass  the  library  version,  optional
       pointers	 to  error  handling functions,	and a pointer to a data	struct
       for use by the error functions, if necessary (the pointer and functions
       can  be	NULL  if  the default error handlers are to be used).  See the
       section on Changes to Libpng below  regarding  the  old	initialization
       functions.   The	 structure allocation functions	quietly	return NULL if
       they fail to create the structure, so your application should check for
       that.

	   png_structp png_ptr = png_create_read_struct
	       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,
	       user_error_fn, user_warning_fn);

	   if (!png_ptr)
	      return (ERROR);

	   png_infop info_ptr =	png_create_info_struct(png_ptr);

	   if (!info_ptr)
	   {
	      png_destroy_read_struct(&png_ptr,
		  (png_infopp)NULL, (png_infopp)NULL);
	      return (ERROR);
	   }

       If  you	want  to use your own memory allocation	routines, use a	libpng
       that was	built with PNG_USER_MEM_SUPPORTED defined,  and	 use  png_cre-
       ate_read_struct_2() instead of png_create_read_struct():

	   png_structp png_ptr = png_create_read_struct_2
	       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,
	       user_error_fn, user_warning_fn, (png_voidp)
	       user_mem_ptr, user_malloc_fn, user_free_fn);

       The  error handling routines passed to png_create_read_struct() and the
       memory alloc/free routines passed  to  png_create_struct_2()  are  only
       necessary  if  you are not using	the libpng supplied error handling and
       memory alloc/free functions.

       When libpng encounters an error,	it expects to  longjmp	back  to  your
       routine.	  Therefore,  you  will	 need  to  call	 setjmp	 and pass your
       png_jmpbuf(png_ptr).  If	you read the file from different routines, you
       will  need to update the	longjmp	buffer every time you enter a new rou-
       tine that will call a png_*() function.

       See your	documentation of setjmp/longjmp	for your compiler for more in-
       formation  on  setjmp/longjmp.  See the discussion on libpng error han-
       dling in	the Customizing	Libpng section below for more  information  on
       the  libpng  error  handling.  If an error occurs, and libpng longjmp's
       back to your setjmp, you	will want to call png_destroy_read_struct() to
       free any	memory.

	   if (setjmp(png_jmpbuf(png_ptr)))
	   {
	      png_destroy_read_struct(&png_ptr,	&info_ptr,
		  &end_info);
	      fclose(fp);
	      return (ERROR);
	   }

       Pass  (png_infopp)NULL  instead	of  &end_info  if you didn't create an
       end_info	structure.

       If you would rather avoid the complexity	of setjmp/longjmp issues,  you
       can compile libpng with PNG_NO_SETJMP, in which case errors will	result
       in a call to PNG_ABORT()	which defaults to abort().

       You can #define PNG_ABORT() to a	function that does something more use-
       ful than	abort(), as long as your function does not return.

       Now  you	 need  to set up the input code.  The default for libpng is to
       use the C function fread().  If you use this, you will need to  pass  a
       valid  FILE  * in the function png_init_io().  Be sure that the file is
       opened in binary	mode.  If you wish to handle reading data  in  another
       way,  you  need	not call the png_init_io() function, but you must then
       implement the libpng I/O	methods	discussed in  the  Customizing	Libpng
       section below.

	   png_init_io(png_ptr,	fp);

       If  you	had  previously	 opened	the file and read any of the signature
       from the	beginning in order to see if this was a	PNG file, you need  to
       let libpng know that there are some bytes missing from the start	of the
       file.

	   png_set_sig_bytes(png_ptr, number);

       You can change the zlib compression buffer size to be used while	 read-
       ing compressed data with

	   png_set_compression_buffer_size(png_ptr, buffer_size);

       where  the  default  size  is 8192 bytes.  Note that the	buffer size is
       changed immediately and the buffer is reallocated immediately,  instead
       of setting a flag to be acted upon later.

       If you want CRC errors to be handled in a different manner than the de-
       fault, use

	   png_set_crc_action(png_ptr, crit_action, ancil_action);

       The values for png_set_crc_action() say how libpng is to	handle CRC er-
       rors in ancillary and critical chunks, and whether to use the data con-
       tained therein. Starting	with libpng-1.6.26, this also governs  how  an
       ADLER32	error is handled while reading the IDAT	chunk. Note that it is
       impossible to "discard" data in a critical chunk.

       Choices for (int) crit_action are
	  PNG_CRC_DEFAULT      0  error/quit
	  PNG_CRC_ERROR_QUIT   1  error/quit
	  PNG_CRC_WARN_USE     3  warn/use data
	  PNG_CRC_QUIET_USE    4  quiet/use data
	  PNG_CRC_NO_CHANGE    5  use the current value

       Choices for (int) ancil_action are
	  PNG_CRC_DEFAULT      0  error/quit
	  PNG_CRC_ERROR_QUIT   1  error/quit
	  PNG_CRC_WARN_DISCARD 2  warn/discard data
	  PNG_CRC_WARN_USE     3  warn/use data
	  PNG_CRC_QUIET_USE    4  quiet/use data
	  PNG_CRC_NO_CHANGE    5  use the current value

       When the	setting	for crit_action	 is  PNG_CRC_QUIET_USE,	 the  CRC  and
       ADLER32 checksums are not only ignored, but they	are not	evaluated.

   Setting up callback code
       You  can	set up a callback function to handle any unknown chunks	in the
       input stream. You must supply the function

	   read_chunk_callback(png_structp png_ptr,
		png_unknown_chunkp chunk);
	   {
	      /* The unknown chunk structure contains your
		 chunk data, along with	similar	data for any other
		 unknown chunks: */

		  png_byte name[5];
		  png_byte *data;
		  png_size_t size;

	      /* Note that libpng has already taken care of
		 the CRC handling */

	      /* put your code here.  Search for your chunk in the
		 unknown chunk structure, process it, and return one
		 of the	following: */

	      return (-n); /* chunk had	an error */
	      return (0); /* did not recognize */
	      return (n); /* success */
	   }

       (You can	give your function another  name  that	you  like  instead  of
       "read_chunk_callback")

       To inform libpng	about your function, use

	   png_set_read_user_chunk_fn(png_ptr, user_chunk_ptr,
	       read_chunk_callback);

       This names not only the callback	function, but also a user pointer that
       you can retrieve	with

	   png_get_user_chunk_ptr(png_ptr);

       If you call the png_set_read_user_chunk_fn() function, then all unknown
       chunks which the	callback does not handle will be saved when read.  You
       can cause them to be discarded by returning '1' ("handled") instead  of
       '0'.   This behavior will change	in libpng 1.7 and the default handling
       set by the  png_set_keep_unknown_chunks()  function,  described	below,
       will be used when the callback returns 0.  If you want the existing be-
       havior you should set the global	 default  to  PNG_HANDLE_CHUNK_IF_SAFE
       now;  this  is  compatible with all current versions of libpng and with
       1.7.  Libpng 1.6	issues a warning if you	keep the default, or  PNG_HAN-
       DLE_CHUNK_NEVER,	and the	callback returns 0.

       At  this	 point,	you can	set up a callback function that	will be	called
       after each row has been read, which you can use to control  a  progress
       meter  or the like.  It's demonstrated in pngtest.c.  You must supply a
       function

	   void	read_row_callback(png_structp png_ptr,
	      png_uint_32 row, int pass);
	   {
	     /*	put your code here */
	   }

       (You can	give it	another	name that you like instead of  "read_row_call-
       back")

       To inform libpng	about your function, use

	   png_set_read_status_fn(png_ptr, read_row_callback);

       When  this  function is called the row has already been completely pro-
       cessed and the 'row' and	'pass' refer to	the next row  to  be  handled.
       For the non-interlaced case the row that	was just handled is simply one
       less than the passed in row number, and pass will always	be 0.  For the
       interlaced  case	 the  same applies unless the row value	is 0, in which
       case the	row just handled was the last one from one  of	the  preceding
       passes.	 Because  interlacing  may skip	a pass you cannot be sure that
       the preceding pass is just 'pass-1'; if you really need	to  know  what
       the  last  pass is record (row,pass) from the callback and use the last
       recorded	value each time.

       As with the user	transform you  can  find  the  output  row  using  the
       PNG_ROW_FROM_PASS_ROW macro.

   Unknown-chunk handling
       Now  you	get to set the way the library processes unknown chunks	in the
       input PNG stream. Both known and	unknown	chunks will be	read.	Normal
       behavior	 is that known chunks will be parsed into information in vari-
       ous info_ptr members while unknown chunks will be discarded.  This  be-
       havior  can  be	wasteful if your application will never	use some known
       chunk types. To change this, you	can call:

	   png_set_keep_unknown_chunks(png_ptr,	keep,
	       chunk_list, num_chunks);

	   keep	      -	0: default unknown chunk handling
			1: ignore; do not keep
			2: keep	only if	safe-to-copy
			3: keep	even if	unsafe-to-copy

		      You can use these	definitions:
			PNG_HANDLE_CHUNK_AS_DEFAULT   0
			PNG_HANDLE_CHUNK_NEVER	      1
			PNG_HANDLE_CHUNK_IF_SAFE      2
			PNG_HANDLE_CHUNK_ALWAYS	      3

	   chunk_list -	list of	chunks affected	(a byte	string,
			five bytes per chunk, NULL or '	' if
			num_chunks is positive;	ignored	if
			numchunks <= 0).

	   num_chunks -	number of chunks affected; if 0, all
			unknown	chunks are affected.  If positive,
			only the chunks	in the list are	affected,
			and if negative	all unknown chunks and
			all known chunks except	for the	IHDR,
			PLTE, tRNS, IDAT, and IEND chunks are
			affected.

       Unknown chunks declared in this way will	be saved as raw	 data  onto  a
       list  of	 png_unknown_chunk  structures.	  If  a	chunk that is normally
       known to	libpng is named	in the list, it	will be	 handled  as  unknown,
       according  to  the "keep" directive.  If	a chunk	is named in successive
       instances of png_set_keep_unknown_chunks(),  the	 final	instance  will
       take  precedence.   The	IHDR  and  IEND	 chunks	should not be named in
       chunk_list; if they are,	libpng will process them normally anyway.   If
       you  know  that your application	will never make	use of some particular
       chunks, use PNG_HANDLE_CHUNK_NEVER (or 1) as demonstrated below.

       Here is an example of the usage of png_set_keep_unknown_chunks(), where
       the  private "vpAg" chunk will later be processed by a user chunk call-
       back function:

	   png_byte vpAg[5]={118, 112,	65, 103, (png_byte) ' '};

	   #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
	     png_byte unused_chunks[]=
	     {
	       104,  73,  83,  84, (png_byte) '	',   /*	hIST */
	       105,  84,  88, 116, (png_byte) '	',   /*	iTXt */
	       112,  67,  65,  76, (png_byte) '	',   /*	pCAL */
	       115,  67,  65,  76, (png_byte) '	',   /*	sCAL */
	       115,  80,  76,  84, (png_byte) '	',   /*	sPLT */
	       116,  73,  77,  69, (png_byte) '	',   /*	tIME */
	     };
	   #endif

	   ...

	   #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
	     /*	ignore all unknown chunks
	      *	(use global setting "2"	for libpng16 and earlier):
	      */
	     png_set_keep_unknown_chunks(read_ptr, 2, NULL, 0);

	     /*	except for vpAg: */
	     png_set_keep_unknown_chunks(read_ptr, 2, vpAg, 1);

	     /*	also ignore unused known chunks: */
	     png_set_keep_unknown_chunks(read_ptr, 1, unused_chunks,
		(int)(sizeof unused_chunks)/5);
	   #endif

   User	limits
       The PNG specification allows the	width and height of an image to	be  as
       large as	2^(31-1	(0x7fffffff), or about 2.147 billion rows and columns.
       For safety, libpng imposes a default limit of 1 million rows  and  col-
       umns.   Larger  images  will be rejected	immediately with a png_error()
       call. If	you wish to change these limits, you can use

	  png_set_user_limits(png_ptr, width_max, height_max);

       to set your own limits (libpng may reject some very wide	images	anyway
       because of potential buffer overflow conditions).

       You  should  put	 this statement	after you create the PNG structure and
       before calling png_read_info(), png_read_png(), or png_process_data().

       When writing a  PNG  datastream,	 put  this  statement  before  calling
       png_write_info()	or png_write_png().

       If you need to retrieve the limits that are being applied, use

	  width_max = png_get_user_width_max(png_ptr);
	  height_max = png_get_user_height_max(png_ptr);

       The  PNG	 specification sets no limit on	the number of ancillary	chunks
       allowed in a PNG	datastream.  By	default, libpng	imposes	a limit	 of  a
       total  of 1000 sPLT, tEXt, iTXt,	zTXt, and unknown chunks to be stored.
       If you have set up both info_ptr	and end_info_ptr,  the	limit  applies
       separately  to  each.   You can change the limit	on the total number of
       such chunks that	will be	stored,	with

	  png_set_chunk_cache_max(png_ptr, user_chunk_cache_max);

       where 0x7fffffffL means unlimited.  You can retrieve this limit with

	  chunk_cache_max = png_get_chunk_cache_max(png_ptr);

       Libpng imposes a	limit of 8 Megabytes (8,000,000	bytes) on  the	amount
       of  memory that a compressed chunk other	than IDAT can occupy, when de-
       compressed.  You	can change this	limit with

	  png_set_chunk_malloc_max(png_ptr, user_chunk_malloc_max);

       and you can retrieve the	limit with

	  chunk_malloc_max = png_get_chunk_malloc_max(png_ptr);

       Any chunks that would cause either of these limits to be	exceeded  will
       be ignored.

   Information about your system
       If  you	intend	to display the PNG or to incorporate it	in other image
       data you	need to	tell libpng information	about your display or  drawing
       surface so that libpng can convert the values in	the image to match the
       display.

       From libpng-1.5.4 this information can be set before  reading  the  PNG
       file  header.   In earlier versions png_set_gamma() existed but behaved
       incorrectly if called before the	PNG file  header  had  been  read  and
       png_set_alpha_mode() did	not exist.

       If  you need to support versions	prior to libpng-1.5.4 test the version
       number as illustrated below using "PNG_LIBPNG_VER >= 10504" and	follow
       the procedures described	in the appropriate manual page.

       You  give  libpng  the  encoding	expected by your system	expressed as a
       'gamma' value.  You can also specify a default  encoding	 for  the  PNG
       file in case the	required information is	missing	from the file.	By de-
       fault libpng assumes that the PNG data matches  your  system,  to  keep
       this default call:

	  png_set_gamma(png_ptr, screen_gamma, output_gamma);

       or you can use the fixed	point equivalent:

	  png_set_gamma_fixed(png_ptr, PNG_FP_1*screen_gamma,
	     PNG_FP_1*output_gamma);

       If you don't know the gamma for your system it is probably 2.2 -	a good
       approximation to	the IEC	standard for display systems (sRGB).   If  im-
       ages  are  too  contrasty or washed out you got the value wrong - check
       your system documentation!

       Many systems permit the system gamma to be changed via a	 lookup	 table
       in  the display driver, a few systems, including	older Macs, change the
       response	by default.  As	of 1.5.4 three special values are available to
       handle common situations:

	  PNG_DEFAULT_sRGB: Indicates that the system conforms to the
			    IEC	61966-2-1 standard.  This matches almost
			    all	systems.
	  PNG_GAMMA_MAC_18: Indicates that the system is an older
			    (pre Mac OS	10.6) Apple Macintosh system with
			    the	default	settings.
	  PNG_GAMMA_LINEAR: Just the fixed point value for 1.0 - indicates
			    that the system expects data with no gamma
			    encoding.

       You  would  use the linear (unencoded) value if you need	to process the
       pixel values further because this avoids	the need to decode and	re-en-
       code  each  component value whenever arithmetic is performed.  A	lot of
       graphics	software uses linear values for	this reason, often with	higher
       precision component values to preserve overall accuracy.

       The  output_gamma  value	expresses how to decode	the output values, not
       how they	are encoded.  The values used correspond to the	normal numbers
       used  to	 describe  the overall gamma of	a computer display system; for
       example 2.2 for an sRGB conformant system.  The values  are  scaled  by
       100000 in the _fixed version of the API (so 220000 for sRGB.)

       The  inverse  of	 the value is always used to provide a default for the
       PNG file	encoding if it has no gAMA chunk and  if  png_set_gamma()  has
       not been	called to override the PNG gamma information.

       When  the  ALPHA_OPTIMIZED mode is selected the output gamma is used to
       encode opaque pixels however pixels with	lower alpha values are not en-
       coded, regardless of the	output gamma setting.

       When  the  standard  Porter  Duff handling is requested with mode 1 the
       output encoding is set to be linear and the output_gamma	value is  only
       relevant	 as  a	default	 for input data	that has no gamma information.
       The linear output encoding will be  overridden  if  png_set_gamma()  is
       called -	the results may	be highly unexpected!

       The  following  numbers	are derived from the sRGB standard and the re-
       search behind it.  sRGB is defined to be	approximated  by  a  PNG  gAMA
       chunk  value of 0.45455 (1/2.2) for PNG.	 The value implicitly includes
       any viewing correction required to take account of any  differences  in
       the  color  environment	of the original	scene and the intended display
       environment; the	value expresses	how to *decode*	the image for display,
       not how the original data was *encoded*.

       sRGB provides a peg for the PNG standard	by defining a viewing environ-
       ment.  sRGB itself, and earlier TV standards, actually use a more  com-
       plex  transform	(a linear portion then a gamma 2.4 power law) than PNG
       can express.  (PNG is limited to	simple power laws.)  By	saying that an
       image  for direct display on an sRGB conformant system should be	stored
       with a gAMA chunk value of 45455	(11.3.3.2 and 11.3.3.5 of the ISO  PNG
       specification) the PNG specification makes it possible to derive	values
       for other display systems and environments.

       The Mac value is	deduced	from the sRGB based on an assumption that  the
       actual  extra  viewing correction used in early Mac display systems was
       implemented as a	power 1.45 lookup table.

       Any system where	a programmable lookup table is used or where  the  be-
       havior  of  the final display device characteristics can	be changed re-
       quires system specific code to obtain the current characteristic.  How-
       ever  this can be difficult and most PNG	gamma correction only requires
       an approximate value.

       By default, if png_set_alpha_mode() is not called, libpng assumes  that
       all  values  are	 unencoded,  linear, values and	that the output	device
       also has	a linear characteristic.  This is only very rarely  correct  -
       it  is  invariably  better  to  call  png_set_alpha_mode() with PNG_DE-
       FAULT_sRGB than rely on the default if you don't	know  what  the	 right
       answer is!

       The  special  value PNG_GAMMA_MAC_18 indicates an older Mac system (pre
       Mac OS 10.6) which used a correction  table  to	implement  a  somewhat
       lower gamma on an otherwise sRGB	system.

       Both  these  values  are	reserved (not simple gamma values) in order to
       allow more precise correction internally	in the future.

       NOTE: the values	can be passed to either	the fixed  or  floating	 point
       APIs,  but  the floating	point API will also accept floating point val-
       ues.

       The second thing	you may	need to	tell libpng about is how  your	system
       handles	alpha  channel information.  Some, but not all,	PNG files con-
       tain an alpha channel.  To display these	files correctly	 you  need  to
       compose	the  data  onto	a suitable background, as described in the PNG
       specification.

       Libpng only supports composing onto a single color (using png_set_back-
       ground;	see  below).   Otherwise  you must do the composition yourself
       and, in this case, you may need to call png_set_alpha_mode:

	  #if PNG_LIBPNG_VER >=	10504
	     png_set_alpha_mode(png_ptr, mode, screen_gamma);
	  #else
	     png_set_gamma(png_ptr, screen_gamma, 1.0/screen_gamma);
	  #endif

       The screen_gamma	value is the same as the  argument  to	png_set_gamma;
       however,	 how  it  affects the output depends on	the mode.  png_set_al-
       pha_mode() sets the file	gamma default to 1/screen_gamma,  so  normally
       you  don't  need	to call	png_set_gamma.	If you need different defaults
       call png_set_gamma() before png_set_alpha_mode()	- if you call it after
       it will override	the settings made by png_set_alpha_mode().

       The mode	is as follows:

	   PNG_ALPHA_PNG:  The data is encoded according to the	PNG specifica-
       tion.  Red, green and blue, or gray, components are gamma encoded color
       values  and  are	not premultiplied by the alpha value.  The alpha value
       is a linear measure of the contribution of the pixel to the correspond-
       ing final output	pixel.

       You should normally use this format if you intend to perform color cor-
       rection on the color values; most, maybe	all, color correction software
       has  no	handling for the alpha channel and, anyway, the	math to	handle
       pre-multiplied component	values is unnecessarily	complex.

       Before you do any arithmetic on the component values you	need to	remove
       the  gamma  encoding  and  multiply out the alpha channel.  See the PNG
       specification for more detail.  It is important to note	that  when  an
       image  with  an alpha channel is	scaled,	linear encoded,	pre-multiplied
       component values	must be	used!

       The remaining modes assume you don't need to do any further color  cor-
       rection	or  that  if  you do, your color correction software knows all
       about alpha (it probably	doesn't!).  They 'associate'  the  alpha  with
       the  color  information	by storing color channel values	that have been
       scaled by the alpha.  The advantage is that the color channels  can  be
       resampled  (the image can be scaled) in this form.  The disadvantage is
       that normal practice is to store	linear,	not  (gamma)  encoded,	values
       and  this  requires  16-bit  channels  for still	images rather than the
       8-bit channels that are just about  sufficient  if  gamma  encoding  is
       used.   In  addition  all  non-transparent pixel	values,	including com-
       pletely opaque ones, must be gamma encoded to produce the final	image.
       These  are  the	'STANDARD',  'ASSOCIATED' or 'PREMULTIPLIED' modes de-
       scribed below (the latter being the two common names for	associated al-
       pha  color channels). Note that PNG files always	contain	non-associated
       color channels; png_set_alpha_mode() with one of	the modes  causes  the
       decoder	to  convert  the pixels	to an associated form before returning
       them to your application.

       Since it	is not necessary to perform arithmetic on opaque color	values
       so  long	 as  they  are	not to be resampled and	are in the final color
       space it	is possible to optimize	the handling of	alpha by  storing  the
       opaque  pixels  in the PNG format (adjusted for the output color	space)
       while storing partially opaque pixels in	the standard, linear,  format.
       The accuracy required for standard alpha	composition is relatively low,
       because the pixels are isolated,	therefore typically the	accuracy  loss
       in storing 8-bit	linear values is acceptable.  (This is not true	if the
       alpha channel is	used to	simulate transparency over large areas	-  use
       16  bits	 or the	PNG mode in this case!)	 This is the 'OPTIMIZED' mode.
       For this	mode a pixel is	treated	as opaque only if the alpha  value  is
       equal to	the maximum value.

	   PNG_ALPHA_STANDARD:	 The  data  libpng  produces is	encoded	in the
       standard	way assumed by most correctly written graphics software.   The
       gamma  encoding will be removed by libpng and the linear	component val-
       ues will	be pre-multiplied by the alpha channel.

       With this format	the final image	must be	re-encoded to match  the  dis-
       play  gamma  before  the	image is displayed.  If	your system doesn't do
       that, yet still seems to	perform	arithmetic on the pixels  without  de-
       coding them, it is broken - check out the modes below.

       With PNG_ALPHA_STANDARD libpng always produces linear component values,
       whatever	screen_gamma you supply.  The screen_gamma value is,  however,
       used  as	 a default for the file	gamma if the PNG file has no gamma in-
       formation.

       If you call png_set_gamma() after png_set_alpha_mode() you  will	 over-
       ride the	linear encoding.  Instead the pre-multiplied pixel values will
       be gamma	encoded	but the	alpha channel will still be linear.  This  may
       actually	 match the requirements	of some	broken software, but it	is un-
       likely.

       While linear 8-bit data is often	used it	has insufficient precision for
       any  image  with	a reasonable dynamic range.  To	avoid problems,	and if
       your software supports it, use png_set_expand_16() to force all	compo-
       nents to	16 bits.

	   PNG_ALPHA_OPTIMIZED:	 This  mode  is	the same as PNG_ALPHA_STANDARD
       except that completely opaque pixels are	gamma encoded according	to the
       screen_gamma  value.   Pixels  with alpha less than 1.0 will still have
       linear components.

       Use this	format if you have control over	your compositing software  and
       so don't	do other arithmetic (such as scaling) on the data you get from
       libpng.	Your compositing software can simply copy opaque pixels	to the
       output but still	has linear values for the non-opaque pixels.

       In  normal  compositing,	 where the alpha channel encodes partial pixel
       coverage	(as opposed to broad area translucency), the  inaccuracies  of
       the 8-bit representation	of non-opaque pixels are irrelevant.

       You  can	also try this format if	your software is broken; it might look
       better.

	   PNG_ALPHA_BROKEN: This is PNG_ALPHA_STANDARD; however,  all	compo-
       nent  values,  including	 the alpha channel are gamma encoded.  This is
       broken because, in practice, no implementation that  uses  this	choice
       correctly  undoes  the encoding before handling alpha composition.  Use
       this choice only	if other serious errors	in the	software  or  hardware
       you  use	 mandate it.  In most cases of broken software or hardware the
       bug in the final	display	manifests as a subtle halo  around  composited
       parts of	the image.  You	may not	even perceive this as a	halo; the com-
       posited part of the image may simply appear  separate  from  the	 back-
       ground, as though it had	been cut out of	paper and pasted on afterward.

       If  you don't have to deal with bugs in software	or hardware, or	if you
       can fix them, there are three recommended  ways	of  using  png_set_al-
       pha_mode():

	  png_set_alpha_mode(png_ptr, PNG_ALPHA_PNG,
	      screen_gamma);

       You  can	 do  color correction on the result (libpng does not currently
       support color correction	internally).  When you handle the alpha	 chan-
       nel you need to undo the	gamma encoding and multiply out	the alpha.

	  png_set_alpha_mode(png_ptr, PNG_ALPHA_STANDARD,
	      screen_gamma);
	  png_set_expand_16(png_ptr);

       If  you	are  using  the	 high  level interface,	don't call png_set_ex-
       pand_16(); instead pass PNG_TRANSFORM_EXPAND_16 to the interface.

       With this mode you can't	do color correction, but  you  can  do	arith-
       metic,  including  composition and scaling, on the data without further
       processing.

	  png_set_alpha_mode(png_ptr, PNG_ALPHA_OPTIMIZED,
	      screen_gamma);

       You can avoid the expansion to 16-bit components	with  this  mode,  but
       you  lose the ability to	scale the image	or perform other linear	arith-
       metic.  All you can do is compose the result onto  a  matching  output.
       Since this mode is libpng-specific you also need	to write your own com-
       position	software.

       The following are examples of calls to  png_set_alpha_mode  to  achieve
       the  required overall gamma correction and, where necessary, alpha pre-
       multiplication.

	   png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB);

       This is the default libpng handling of the alpha	channel	-  it  is  not
       pre-multiplied  into the	color components.  In addition the call	states
       that the	output is for a	sRGB system and	causes all PNG	files  without
       gAMA chunks to be assumed to be encoded using sRGB.

	   png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC);

       In this case the	output is assumed to be	something like an sRGB confor-
       mant display preceeded by a power-law lookup table of power 1.45.  This
       is how early Mac	systems	behaved.

	   png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR);

       This  is	the classic Jim	Blinn approach and will	work in	academic envi-
       ronments	where everything is done by the	book.  It has the  shortcoming
       of  assuming  that input	PNG data with no gamma information is linear -
       this is unlikely	to be correct unless the PNG files where generated lo-
       cally.  Most of the time	the output precision will be so	low as to show
       significant banding in dark areas of the	image.

	   png_set_expand_16(pp);
	   png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_DEFAULT_sRGB);

       This is a somewhat more realistic Jim  Blinn  inspired  approach.   PNG
       files  are assumed to have the sRGB encoding if not marked with a gamma
       value and the output is always 16 bits per component.  This permits ac-
       curate scaling and processing of	the data.  If you know that your input
       PNG files were generated	locally	you  might  need  to  replace  PNG_DE-
       FAULT_sRGB with the correct value for your system.

	   png_set_alpha_mode(pp, PNG_ALPHA_OPTIMIZED, PNG_DEFAULT_sRGB);

       If you just need	to composite the PNG image onto	an existing background
       and if you control the code that	does this you can use the optimization
       setting.	  In  this  case you just copy completely opaque pixels	to the
       output.	For pixels that	are not	completely transparent (you just  skip
       those)  you  do the composition math using png_composite	or png_compos-
       ite_16 below then encode	the resultant 8-bit or 16-bit values to	 match
       the output encoding.

	   Other cases

       If  neither  the	 PNG nor the standard linear encoding work for you be-
       cause of	the software or	hardware you use then you have a big  problem.
       The  PNG	case will probably result in halos around the image.  The lin-
       ear encoding will probably result in a washed out,  too	bright,	 image
       (it's  actually	too  contrasty.)  Try the ALPHA_OPTIMIZED mode above -
       this will probably substantially	reduce the halos.  Alternatively try:

	   png_set_alpha_mode(pp, PNG_ALPHA_BROKEN, PNG_DEFAULT_sRGB);

       This option will	also reduce the	halos, but there will be  slight  dark
       halos  round  the  opaque  parts	 of  the image where the background is
       light.  In the OPTIMIZED	mode the halos will be light halos  where  the
       background  is dark.  Take your pick - the halos	are unavoidable	unless
       you can get your	hardware/software fixed!  (The OPTIMIZED  approach  is
       slightly	faster.)

       When the	default	gamma of PNG files doesn't match the output gamma.  If
       you have	PNG files with no gamma	information png_set_alpha_mode	allows
       you to provide a	default	gamma, but it also sets	the ouput gamma	to the
       matching	value.	If you know your PNG files have	a gamma	 that  doesn't
       match  the  output  you can take	advantage of the fact that png_set_al-
       pha_mode	always sets the	output gamma but only sets the PNG default  if
       it is not already set:

	   png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB);
	   png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC);

       The  first  call	sets both the default and the output gamma values, the
       second call overrides the output	gamma without  changing	 the  default.
       This  is	easier than achieving the same effect with png_set_gamma.  You
       must use	PNG_ALPHA_PNG for  the	first  call  -	internal  checking  in
       png_set_alpha will fire if more than one	call to	png_set_alpha_mode and
       png_set_background is made in the same read operation, however multiple
       calls with PNG_ALPHA_PNG	are ignored.

       If  you	don't  need,  or  can't	handle,	the alpha channel you can call
       png_set_background() to remove it by compositing	against	a fixed	color.
       Don't  call  png_set_strip_alpha()  to do this -	it will	leave spurious
       pixel values in transparent parts of this image.

	  png_set_background(png_ptr, &background_color,
	      PNG_BACKGROUND_GAMMA_SCREEN, 0, 1);

       The background_color is an RGB or grayscale value according to the data
       format  libpng  will  produce  for you.	Because	you don't yet know the
       format of the PNG file, if you call png_set_background  at  this	 point
       you must	arrange	for the	format produced	by libpng to always have 8-bit
       or 16-bit components and	then store the color as	 an  8-bit  or	16-bit
       color  as appropriate.  The color contains separate gray	and RGB	compo-
       nent values, so you can let libpng produce gray or RGB output according
       to  the input format, but low bit depth grayscale images	must always be
       converted to at	least  8-bit  format.	(Even  though  low  bit	 depth
       grayscale  images can't have an alpha channel they can have a transpar-
       ent color!)

       You set the transforms you need later, either  as  flags	 to  the  high
       level  interface	 or libpng API calls for the low level interface.  For
       reference the settings and API calls required are:

       8-bit values:
	  PNG_TRANSFORM_SCALE_16 | PNG_EXPAND
	  png_set_expand(png_ptr); png_set_scale_16(png_ptr);

	  If you must get exactly the same inaccurate results
	  produced by default in versions prior	to libpng-1.5.4,
	  use PNG_TRANSFORM_STRIP_16 and png_set_strip_16(png_ptr)
	  instead.

       16-bit values:
	  PNG_TRANSFORM_EXPAND_16
	  png_set_expand_16(png_ptr);

       In either case palette image data will be expanded to RGB.  If you just
       want    color   data   you   can	  add	PNG_TRANSFORM_GRAY_TO_RGB   or
       png_set_gray_to_rgb(png_ptr) to the list.

       Calling png_set_background before the PNG file header is	read will  not
       work  prior  to	libpng-1.5.4.  Because the failure may result in unex-
       pected  warnings	 or  errors  it	 is  therefore	much  safer  to	  call
       png_set_background  after  the  head has	been read.  Unfortunately this
       means that prior	to libpng-1.5.4	it cannot be used with the high	 level
       interface.

   The high-level read interface
       At  this	 point	there  are two ways to proceed;	through	the high-level
       read interface, or through a sequence  of  low-level  read  operations.
       You can use the high-level interface if (a) you are willing to read the
       entire image into memory, and (b) the input transformations you want to
       do are limited to the following set:

	   PNG_TRANSFORM_IDENTITY      No transformation
	   PNG_TRANSFORM_SCALE_16      Strip 16-bit samples to
				       8-bit accurately
	   PNG_TRANSFORM_STRIP_16      Chop 16-bit samples to
				       8-bit less accurately
	   PNG_TRANSFORM_STRIP_ALPHA   Discard the alpha channel
	   PNG_TRANSFORM_PACKING       Expand 1, 2 and 4-bit
				       samples to bytes
	   PNG_TRANSFORM_PACKSWAP      Change order of packed
				       pixels to LSB first
	   PNG_TRANSFORM_EXPAND	       Perform set_expand()
	   PNG_TRANSFORM_INVERT_MONO   Invert monochrome images
	   PNG_TRANSFORM_SHIFT	       Normalize pixels	to the
				       sBIT depth
	   PNG_TRANSFORM_BGR	       Flip RGB	to BGR,	RGBA
				       to BGRA
	   PNG_TRANSFORM_SWAP_ALPHA    Flip RGBA to ARGB or GA
				       to AG
	   PNG_TRANSFORM_INVERT_ALPHA  Change alpha from opacity
				       to transparency
	   PNG_TRANSFORM_SWAP_ENDIAN   Byte-swap 16-bit	samples
	   PNG_TRANSFORM_GRAY_TO_RGB   Expand grayscale	samples
				       to RGB (or GA to	RGBA)
	   PNG_TRANSFORM_EXPAND_16     Expand samples to 16 bits

       (This  excludes setting a background color, doing gamma transformation,
       quantizing, and setting filler.)	 If this is the	case, simply do	this:

	   png_read_png(png_ptr, info_ptr, png_transforms, NULL)

       where png_transforms is an integer containing the bitwise  OR  of  some
       set   of	  transformation   flags.    This   call   is	equivalent  to
       png_read_info(),	followed the set of transformations indicated  by  the
       transform mask, then png_read_image(), and finally png_read_end().

       (The  final  parameter  of this call is not yet used.  Someday it might
       point to	transformation parameters required by some future input	trans-
       form.)

       You  must use png_transforms and	not call any png_set_transform() func-
       tions when you use png_read_png().

       After you have called png_read_png(), you can retrieve the  image  data
       with

	  row_pointers = png_get_rows(png_ptr, info_ptr);

       where  row_pointers  is an array	of pointers to the pixel data for each
       row:

	  png_bytep row_pointers[height];

       If you know your	image size and pixel size ahead	of time, you can allo-
       cate row_pointers prior to calling png_read_png() with

	  if (height > PNG_UINT_32_MAX/(sizeof (png_byte)))
	     png_error (png_ptr,
		 "Image	is too tall to process in memory");

	  if (width > PNG_UINT_32_MAX/pixel_size)
	     png_error (png_ptr,
		 "Image	is too wide to process in memory");

	  row_pointers = png_malloc(png_ptr,
	      height*(sizeof (png_bytep)));

	  for (int i=0;	i<height, i++)
	     row_pointers[i]=NULL;  /* security	precaution */

	  for (int i=0;	i<height, i++)
	     row_pointers[i]=png_malloc(png_ptr,
		 width*pixel_size);

	  png_set_rows(png_ptr,	info_ptr, &row_pointers);

       Alternatively you could allocate	your image in one big block and	define
       row_pointers[i] to point	into the proper	places in your block.

       If you use png_set_rows(), the application is responsible  for  freeing
       row_pointers (and row_pointers[i], if they were separately allocated).

       If  you	don't allocate row_pointers ahead of time, png_read_png() will
       do it, and it'll	be free'ed by libpng when you call png_destroy_*().

   The low-level read interface
       If you are going	the low-level route, you are now ready to read all the
       file  information up to the actual image	data.  You do this with	a call
       to png_read_info().

	   png_read_info(png_ptr, info_ptr);

       This will process all chunks up to but not including the	image data.

       This also copies	some of	the data from the PNG  file  into  the	decode
       structure  for  use  in	later  transformations.	 Important information
       copied in is:

       1) The PNG file gamma from the gAMA chunk.  This	overwrites the default
       value  provided	by  an	earlier	 call  to png_set_gamma	or png_set_al-
       pha_mode.

       2) Prior	to libpng-1.5.4	the background color from a bKGd chunk.	  This
       damages	the  information  provided by an earlier call to png_set_back-
       ground resulting	in unexpected behavior.	 Libpng-1.5.4 no  longer  does
       this.

       3) The number of	significant bits in each component value.  Libpng uses
       this to optimize	gamma handling by reducing the internal	 lookup	 table
       sizes.

       4)  The	transparent  color information from a tRNS chunk.  This	can be
       modified	by a later call	to png_set_tRNS.

   Querying the	info structure
       Functions are used to get the information from the info_ptr once	it has
       been  read.  Note that these fields may not be completely filled	in un-
       til png_read_end() has read the chunk data following the	image.

	   png_get_IHDR(png_ptr, info_ptr, &width, &height,
	      &bit_depth, &color_type, &interlace_type,
	      &compression_type, &filter_method);

	   width	  - holds the width of the image
			    in pixels (up to 2^31).

	   height	  - holds the height of	the image
			    in pixels (up to 2^31).

	   bit_depth	  - holds the bit depth	of one of the
			    image channels.  (valid values are
			    1, 2, 4, 8,	16 and depend also on
			    the	color_type.  See also
			    significant	bits (sBIT) below).

	   color_type	  - describes which color/alpha	channels
				are present.
			    PNG_COLOR_TYPE_GRAY
			       (bit depths 1, 2, 4, 8, 16)
			    PNG_COLOR_TYPE_GRAY_ALPHA
			       (bit depths 8, 16)
			    PNG_COLOR_TYPE_PALETTE
			       (bit depths 1, 2, 4, 8)
			    PNG_COLOR_TYPE_RGB
			       (bit_depths 8, 16)
			    PNG_COLOR_TYPE_RGB_ALPHA
			       (bit_depths 8, 16)

			    PNG_COLOR_MASK_PALETTE
			    PNG_COLOR_MASK_COLOR
			    PNG_COLOR_MASK_ALPHA

	   interlace_type - (PNG_INTERLACE_NONE	or
			    PNG_INTERLACE_ADAM7)

	   compression_type - (must be PNG_COMPRESSION_TYPE_BASE
			    for	PNG 1.0)

	   filter_method  - (must be PNG_FILTER_TYPE_BASE
			    for	PNG 1.0, and can also be
			    PNG_INTRAPIXEL_DIFFERENCING	if
			    the	PNG datastream is embedded in
			    a MNG-1.0 datastream)

	   Any of width, height, color_type, bit_depth,
	   interlace_type, compression_type, or	filter_method can
	   be NULL if you are not interested in	their values.

	   Note	that png_get_IHDR() returns 32-bit data	into
	   the application's width and height variables.
	   This	is an unsafe situation if these	are not	png_uint_32
	   variables.  In such situations, the
	   png_get_image_width() and png_get_image_height()
	   functions described below are safer.

	   width	    = png_get_image_width(png_ptr,
				info_ptr);

	   height	    = png_get_image_height(png_ptr,
				info_ptr);

	   bit_depth	    = png_get_bit_depth(png_ptr,
				info_ptr);

	   color_type	    = png_get_color_type(png_ptr,
				info_ptr);

	   interlace_type   = png_get_interlace_type(png_ptr,
				info_ptr);

	   compression_type = png_get_compression_type(png_ptr,
				info_ptr);

	   filter_method    = png_get_filter_type(png_ptr,
				info_ptr);

	   channels = png_get_channels(png_ptr,	info_ptr);

	   channels	  - number of channels of info for the
			    color type (valid values are 1 (GRAY,
			    PALETTE), 2	(GRAY_ALPHA), 3	(RGB),
			    4 (RGB_ALPHA or RGB	+ filler byte))

	   rowbytes = png_get_rowbytes(png_ptr,	info_ptr);

	   rowbytes	  - number of bytes needed to hold a row

	   signature = png_get_signature(png_ptr, info_ptr);

	   signature	  - holds the signature	read from the
			    file (if any).  The	data is	kept in
			    the	same offset it would be	if the
			    whole signature were read (i.e. if an
			    application	had already read in 4
			    bytes of signature before starting
			    libpng, the	remaining 4 bytes would
			    be in signature[4] through signature[7]
			    (see png_set_sig_bytes())).

       These are also important, but their validity  depends  on  whether  the
       chunk	has   been   read.    The   png_get_valid(png_ptr,   info_ptr,
       PNG_INFO_<chunk>) and png_get_<chunk>(png_ptr, info_ptr,	...) functions
       return  non-zero	 if  the data has been read, or	zero if	it is missing.
       The parameters to the png_get_<chunk> are set directly if they are sim-
       ple data	types, or a pointer into the info_ptr is returned for any com-
       plex types.

       The colorspace data from	gAMA, cHRM, sRGB, iCCP,	 and  sBIT  chunks  is
       simply returned to give the application information about how the image
       was encoded.  Libpng itself only	does transformations  using  the  file
       gamma  when combining semitransparent pixels with the background	color,
       and, since libpng-1.6.0,	when converting	between	8-bit sRGB and	16-bit
       linear  pixels  within  the  simplified API.  Libpng also uses the file
       gamma when converting RGB to gray, beginning with libpng-1.0.5, if  the
       application calls png_set_rgb_to_gray()).

	   png_get_PLTE(png_ptr, info_ptr, &palette,
			    &num_palette);

	   palette	  - the	palette	for the	file
			    (array of png_color)

	   num_palette	  - number of entries in the palette

	   png_get_gAMA(png_ptr, info_ptr, &file_gamma);
	   png_get_gAMA_fixed(png_ptr, info_ptr, &int_file_gamma);

	   file_gamma	  - the	gamma at which the file	is
			    written (PNG_INFO_gAMA)

	   int_file_gamma - 100,000 times the gamma at which the
			    file is written

	   png_get_cHRM(png_ptr, info_ptr,  &white_x, &white_y,	&red_x,
			    &red_y, &green_x, &green_y,	&blue_x, &blue_y)
	   png_get_cHRM_XYZ(png_ptr, info_ptr, &red_X, &red_Y, &red_Z,
			    &green_X, &green_Y,	&green_Z, &blue_X, &blue_Y,
			    &blue_Z)
	   png_get_cHRM_fixed(png_ptr, info_ptr, &int_white_x,
			    &int_white_y, &int_red_x, &int_red_y,
			    &int_green_x, &int_green_y,	&int_blue_x,
			    &int_blue_y)
	   png_get_cHRM_XYZ_fixed(png_ptr, info_ptr, &int_red_X, &int_red_Y,
			    &int_red_Z,	&int_green_X, &int_green_Y,
			    &int_green_Z, &int_blue_X, &int_blue_Y,
			    &int_blue_Z)

	   {white,red,green,blue}_{x,y}
			    A color space encoding specified using the
			    chromaticities of the end points and the
			    white point. (PNG_INFO_cHRM)

	   {red,green,blue}_{X,Y,Z}
			    A color space encoding specified using the
			    encoding end points	- the CIE tristimulus
			    specification of the intended color	of the red,
			    green and blue channels in the PNG RGB data.
			    The	white point is simply the sum of the three
			    end	points.	(PNG_INFO_cHRM)

	   png_get_sRGB(png_ptr, info_ptr, &srgb_intent);

	   srgb_intent -    the	rendering intent (PNG_INFO_sRGB)
			    The	presence of the	sRGB chunk
			    means that the pixel data is in the
			    sRGB color space.  This chunk also
			    implies specific values of gAMA and
			    cHRM.

	   png_get_iCCP(png_ptr, info_ptr, &name,
	      &compression_type, &profile, &proflen);

	   name		    - The profile name.

	   compression_type - The compression type; always
			      PNG_COMPRESSION_TYPE_BASE	for PNG	1.0.
			      You may give NULL	to this	argument to
			      ignore it.

	   profile	    - International Color Consortium color
			      profile data. May	contain	NULs.

	   proflen	    - length of	profile	data in	bytes.

	   png_get_sBIT(png_ptr, info_ptr, &sig_bit);

	   sig_bit	  - the	number of significant bits for
			    (PNG_INFO_sBIT) each of the	gray,
			    red, green,	and blue channels,
			    whichever are appropriate for the
			    given color	type (png_color_16)

	   png_get_tRNS(png_ptr, info_ptr, &trans_alpha,
			    &num_trans,	&trans_color);

	   trans_alpha	  - array of alpha (transparency)
			    entries for	palette	(PNG_INFO_tRNS)

	   num_trans	  - number of transparent entries
			    (PNG_INFO_tRNS)

	   trans_color	  - graylevel or color sample values of
			    the	single transparent color for
			    non-paletted images	(PNG_INFO_tRNS)

	   png_get_hIST(png_ptr, info_ptr, &hist);
			    (PNG_INFO_hIST)

	   hist		  - histogram of palette (array	of
			    png_uint_16)

	   png_get_tIME(png_ptr, info_ptr, &mod_time);

	   mod_time	  - time image was last	modified
			   (PNG_VALID_tIME)

	   png_get_bKGD(png_ptr, info_ptr, &background);

	   background	  - background color (of type
			    png_color_16p) (PNG_VALID_bKGD)
			    valid 16-bit red, green and	blue
			    values, regardless of color_type

	   num_comments	  = png_get_text(png_ptr, info_ptr,
			    &text_ptr, &num_text);

	   num_comments	  - number of comments

	   text_ptr	  - array of png_text holding image
			    comments

	   text_ptr[i].compression - type of compression used
			on "text" PNG_TEXT_COMPRESSION_NONE
				  PNG_TEXT_COMPRESSION_zTXt
				  PNG_ITXT_COMPRESSION_NONE
				  PNG_ITXT_COMPRESSION_zTXt

	   text_ptr[i].key   - keyword for comment.  Must contain
				1-79 characters.

	   text_ptr[i].text  - text comments for current
				keyword.  Can be empty.

	   text_ptr[i].text_length - length of text string,
			after decompression, 0 for iTXt

	   text_ptr[i].itxt_length - length of itxt string,
			after decompression, 0 for tEXt/zTXt

	   text_ptr[i].lang  - language	of comment (empty
				string for unknown).

	   text_ptr[i].lang_key	 - keyword in UTF-8
				(empty string for unknown).

	   Note	that the itxt_length, lang, and	lang_key
	   members of the text_ptr structure only exist	when the
	   library is built with iTXt chunk support.  Prior to
	   libpng-1.4.0	the library was	built by default without
	   iTXt	support. Also note that	when iTXt is supported,
	   they	contain	NULL pointers when the "compression"
	   field contains PNG_TEXT_COMPRESSION_NONE or
	   PNG_TEXT_COMPRESSION_zTXt.

	   num_text	  - number of comments (same as
			    num_comments; you can put NULL here
			    to avoid the duplication)

	   Note	while png_set_text() will accept text, language,
	   and translated keywords that	can be NULL pointers, the
	   structure returned by png_get_text will always contain
	   regular zero-terminated C strings.  They might be
	   empty strings but they will never be	NULL pointers.

	   num_spalettes = png_get_sPLT(png_ptr, info_ptr,
	      &palette_ptr);

	   num_spalettes  - number of sPLT chunks read.

	   palette_ptr	  - array of palette structures	holding
			    contents of	one or more sPLT chunks
			    read.

	   png_get_oFFs(png_ptr, info_ptr, &offset_x, &offset_y,
	      &unit_type);

	   offset_x	  - positive offset from the left edge
			    of the screen (can be negative)

	   offset_y	  - positive offset from the top edge
			    of the screen (can be negative)

	   unit_type	  - PNG_OFFSET_PIXEL, PNG_OFFSET_MICROMETER

	   png_get_pHYs(png_ptr, info_ptr, &res_x, &res_y,
	      &unit_type);

	   res_x	  - pixels/unit	physical resolution in
			    x direction

	   res_y	  - pixels/unit	physical resolution in
			    x direction

	   unit_type	  - PNG_RESOLUTION_UNKNOWN,
			    PNG_RESOLUTION_METER

	   png_get_sCAL(png_ptr, info_ptr, &unit, &width,
	      &height)

	   unit	       - physical scale	units (an integer)

	   width       - width of a pixel in physical scale units

	   height      - height	of a pixel in physical scale units
			(width and height are doubles)

	   png_get_sCAL_s(png_ptr, info_ptr, &unit, &width,
	      &height)

	   unit	       - physical scale	units (an integer)

	   width       - width of a pixel in physical scale units
			 (expressed as a string)

	   height      - height	of a pixel in physical scale units
			(width and height are strings like "2.54")

	   num_unknown_chunks =	png_get_unknown_chunks(png_ptr,
	      info_ptr,	&unknowns)

	   unknowns	     - array of	png_unknown_chunk
			       structures holding unknown chunks

	   unknowns[i].name  - name of unknown chunk

	   unknowns[i].data  - data of unknown chunk

	   unknowns[i].size  - size of unknown chunk's data

	   unknowns[i].location	- position of chunk in file

	   The value of	"i" corresponds	to the order in	which the
	   chunks were read from the PNG file or inserted with the
	   png_set_unknown_chunks() function.

	   The value of	"location" is a	bitwise	"or" of

		PNG_HAVE_IHDR  (0x01)
		PNG_HAVE_PLTE  (0x02)
		PNG_AFTER_IDAT (0x08)

       The  data  from	the  pHYs chunk	can be retrieved in several convenient
       forms:

	   res_x = png_get_x_pixels_per_meter(png_ptr,
	      info_ptr)

	   res_y = png_get_y_pixels_per_meter(png_ptr,
	      info_ptr)

	   res_x_and_y = png_get_pixels_per_meter(png_ptr,
	      info_ptr)

	   res_x = png_get_x_pixels_per_inch(png_ptr,
	      info_ptr)

	   res_y = png_get_y_pixels_per_inch(png_ptr,
	      info_ptr)

	   res_x_and_y = png_get_pixels_per_inch(png_ptr,
	      info_ptr)

	   aspect_ratio	= png_get_pixel_aspect_ratio(png_ptr,
	      info_ptr)

	   Each	of these returns 0 [signifying "unknown"] if
	      the data is not present or if res_x is 0;
	      res_x_and_y is 0 if res_x	!= res_y

	   Note	that because of	the way	the resolutions	are
	      stored internally, the inch conversions won't
	      come out to exactly even number.	For example,
	      72 dpi is	stored as 0.28346 pixels/meter,	and
	      when this	is retrieved it	is 71.9988 dpi,	so
	      be sure to round the returned value appropriately
	      if you want to display a reasonable-looking result.

       The data	from the oFFs chunk can	be  retrieved  in  several  convenient
       forms:

	   x_offset = png_get_x_offset_microns(png_ptr,	info_ptr);

	   y_offset = png_get_y_offset_microns(png_ptr,	info_ptr);

	   x_offset = png_get_x_offset_inches(png_ptr, info_ptr);

	   y_offset = png_get_y_offset_inches(png_ptr, info_ptr);

	   Each	of these returns 0 [signifying "unknown" if both
	      x	and y are 0] if	the data is not	present	or if the
	      chunk is present but the unit is the pixel.  The
	      remark about inexact inch	conversions applies here
	      as well, because a value in inches can't always be
	      converted	to microns and back without some loss
	      of precision.

       For more	information, see the PNG specification for chunk contents.  Be
       careful with trusting rowbytes, as some of  the	transformations	 could
       increase	 the  space needed to hold a row (expand, filler, gray_to_rgb,
       etc.).  See png_read_update_info(), below.

       A quick word about text_ptr and num_text.  PNG stores comments in  key-
       word/text  pairs,  one  pair  per chunk,	with no	limit on the number of
       text chunks, and	a 2^31 byte limit on their size.  While	there are sug-
       gested  keywords,  there	is no requirement to restrict the use to these
       strings.	 It is strongly	suggested that keywords	and text  be  sensible
       to humans (that's the point), so	don't use abbreviations.  Non-printing
       symbols are not allowed.	 See the PNG specification for	more  details.
       There is	also no	requirement to have text after the keyword.

       Keywords	 should	be limited to 79 Latin-1 characters without leading or
       trailing	spaces,	but non-consecutive spaces are allowed within the key-
       word.   It  is  possible	 to have the same keyword any number of	times.
       The text_ptr is an array	of png_text structures,	each holding a pointer
       to  a  language	string,	a pointer to a keyword and a pointer to	a text
       string.	The text string, language code,	and translated keyword may  be
       empty  or NULL pointers.	 The keyword/text pairs	are put	into the array
       in the order that they are received.  However, some or all of the  text
       chunks  may  be after the image,	so, to make sure you have read all the
       text chunks, don't mess with these until	after you read the stuff after
       the  image.   This will be mentioned again below	in the discussion that
       goes with png_read_end().

   Input transformations
       After you've read the header information, you can set up	the library to
       handle any special transformations of the image data.  The various ways
       to transform the	data will be described in the order that  they	should
       occur.	This  is  important,  as  some	of these change	the color type
       and/or bit depth	of the data, and some  others  only  work  on  certain
       color types and bit depths.

       Transformations	you request are	ignored	if they	don't have any meaning
       for a particular	input data format.  However some  transformations  can
       have  an	effect as a result of a	previous transformation.  If you spec-
       ify a contradictory set of transformations, for example both adding and
       removing	the alpha channel, you cannot predict the final	result.

       The  color  used	 for the transparency values should be supplied	in the
       same format/depth as the	current	image data.  It	is stored in the  same
       format/depth  as	the image data in a tRNS chunk,	so this	is what	libpng
       expects for this	data.

       The color used for the background value depends on the need_expand  ar-
       gument as described below.

       Data  will  be  decoded into the	supplied row buffers packed into bytes
       unless the library has been told	to transform it	into  another  format.
       For  example, 4 bit/pixel paletted or grayscale data will be returned 2
       pixels/byte with	the leftmost pixel in the high-order bits of the byte,
       unless  png_set_packing()  is called.  8-bit RGB	data will be stored in
       RGB RGB RGB format unless png_set_filler()  or  png_set_add_alpha()  is
       called to insert	filler bytes, either before or after each RGB triplet.

       16-bit  RGB data	will be	returned RRGGBB	RRGGBB,	with the most signifi-
       cant byte of the	color value first, unless png_set_scale_16() is	called
       to  transform  it  to  regular RGB RGB triplets,	or png_set_filler() or
       png_set_add alpha() is called to	insert two filler bytes, either	before
       or  after  each	RRGGBB	triplet.  Similarly, 8-bit or 16-bit grayscale
       data  can  be  modified	with  png_set_filler(),	  png_set_add_alpha(),
       png_set_strip_16(), or png_set_scale_16().

       The  following  code  transforms	 grayscale  images of less than	8 to 8
       bits, changes paletted images to	RGB, and adds a	full alpha channel  if
       there is	transparency information in a tRNS chunk.  This	is most	useful
       on grayscale images with	bit depths of 2	or 4 or	if there is  a	multi-
       ple-image  viewing  application	that wishes to treat all images	in the
       same way.

	   if (color_type == PNG_COLOR_TYPE_PALETTE)
	       png_set_palette_to_rgb(png_ptr);

	   if (png_get_valid(png_ptr, info_ptr,
	       PNG_INFO_tRNS)) png_set_tRNS_to_alpha(png_ptr);

	   if (color_type == PNG_COLOR_TYPE_GRAY &&
	       bit_depth < 8) png_set_expand_gray_1_2_4_to_8(png_ptr);

       The first two functions	are  actually  aliases	for  png_set_expand(),
       added  in libpng	version	1.0.4, with the	function names expanded	to im-
       prove code readability.	In some	future version they  may  actually  do
       different things.

       As of libpng version 1.2.9, png_set_expand_gray_1_2_4_to_8() was	added.
       It expands the sample depth without changing tRNS to alpha.

       As of libpng version 1.5.2, png_set_expand_16() was added.  It  behaves
       as  png_set_expand();  however,	the  resultant	channels  have 16 bits
       rather than 8.  Use this	when the output	color  or  gray	 channels  are
       made linear to avoid fairly severe accuracy loss.

	  if (bit_depth	< 16)
	     png_set_expand_16(png_ptr);

       PNG  can	have files with	16 bits	per channel.  If you only can handle 8
       bits per	channel, this will strip the pixels down to 8-bit.

	   if (bit_depth == 16)	#if PNG_LIBPNG_VER >= 10504
	      png_set_scale_16(png_ptr); #else
	      png_set_strip_16(png_ptr); #endif

       (The more accurate "png_set_scale_16()" API became available in	libpng
       version 1.5.4).

       If  you	need to	process	the alpha channel on the image separately from
       the image data (for example if you convert it to	a bitmap mask)	it  is
       possible	 to  have  libpng  strip  the channel leaving just RGB or gray
       data:

	   if (color_type & PNG_COLOR_MASK_ALPHA)
	      png_set_strip_alpha(png_ptr);

       If you strip the	alpha channel you need to find some other way of deal-
       ing  with  the information.  If,	instead, you want to convert the image
       to an opaque version with no alpha channel use png_set_background;  see
       below.

       As of libpng version 1.5.2, almost all useful expansions	are supported,
       the major ommissions are	conversion  of	grayscale  to  indexed	images
       (which  can be done trivially in	the application) and conversion	of in-
       dexed to	grayscale (which can be	done by	a trivial manipulation of  the
       palette.)

       In  the	following table, the 01	means grayscale	with depth<8, 31 means
       indexed with depth<8, other numerals  represent	the  color  type,  "T"
       means  the  tRNS	chunk is present, A means an alpha channel is present,
       and O means tRNS	or alpha is present but	all pixels in  the  image  are
       opaque.

	 FROM  01  31	0  0T  0O   2  2T  2O	3  3T  3O  4A  4O  6A  6O
	  TO
	  01	-  [G]	-   -	-   -	-   -	-   -	-   -	-   -	-
	  31   [Q]  Q  [Q] [Q] [Q]  Q	Q   Q	Q   Q	Q  [Q] [Q]  Q	Q
	   0	1   G	+   .	.   G	G   G	G   G	G   B	B  GB  GB
	  0T	lt  Gt	t   +	.   Gt	G   G	Gt  G	G   Bt	Bt GBt GBt
	  0O	lt  Gt	t   .	+   Gt	Gt  G	Gt  Gt	G   Bt	Bt GBt GBt
	   2	C   P	C   C	C   +	.   .	C   -	-  CB  CB   B	B
	  2T	Ct  -	Ct  C	C   t	+   t	-   -	-  CBt CBt  Bt	Bt
	  2O	Ct  -	Ct  C	C   t	t   +	-   -	-  CBt CBt  Bt	Bt
	   3   [Q]  p  [Q] [Q] [Q]  Q	Q   Q	+   .	.  [Q] [Q]  Q	Q
	  3T   [Qt] p  [Qt][Q] [Q]  Qt	Qt  Qt	t   +	t  [Qt][Qt] Qt	Qt
	  3O   [Qt] p  [Qt][Q] [Q]  Qt	Qt  Qt	t   t	+  [Qt][Qt] Qt	Qt
	  4A	lA  G	A   T	T   GA	GT  GT	GA  GT	GT  +	BA  G  GBA
	  4O	lA GBA	A   T	T   GA	GT  GT	GA  GT	GT  BA	+  GBA	G
	  6A	CA  PA	CA  C	C   A	T  tT	PA  P	P   C  CBA  +	BA
	  6O	CA PBA	CA  C	C   A  tT   T	PA  P	P  CBA	C   BA	+

       Within the matrix,
	    "+"	identifies entries where 'from'	and 'to' are the same.
	    "-"	means the transformation is not	supported.
	    "."	means nothing is necessary (a tRNS chunk can just be ignored).
	    "t"	means the transformation is obtained by	png_set_tRNS.
	    "A"	means the transformation is obtained by	png_set_add_alpha().
	    "X"	means the transformation is obtained by	png_set_expand().
	    "1"	means the transformation is obtained by
		png_set_expand_gray_1_2_4_to_8() (and by png_set_expand()
		if there is no transparency in the original or the final
		format).
	    "C"	means the transformation is obtained by	png_set_gray_to_rgb().
	    "G"	means the transformation is obtained by	png_set_rgb_to_gray().
	    "P"	means the transformation is obtained by
		png_set_expand_palette_to_rgb().
	    "p"	means the transformation is obtained by	png_set_packing().
	    "Q"	means the transformation is obtained by	png_set_quantize().
	    "T"	means the transformation is obtained by
		png_set_tRNS_to_alpha().
	    "B"	means the transformation is obtained by
		png_set_background(), or png_strip_alpha().

       When  an	entry has multiple transforms listed all are required to cause
       the right overall transformation.  When two transforms are separated by
       a comma either will do the job.	When transforms	are enclosed in	[] the
       transform should	do the job but this is	currently  unimplemented  -  a
       different format	will result if the suggested transformations are used.

       In  PNG	files,	the alpha channel in an	image is the level of opacity.
       If you need the alpha channel in	an image to be the level of  transpar-
       ency  instead of	opacity, you can invert	the alpha channel (or the tRNS
       chunk data) after it's read, so that 0 is  fully	 opaque	 and  255  (in
       8-bit  or  paletted images) or 65535 (in	16-bit images) is fully	trans-
       parent, with

	   png_set_invert_alpha(png_ptr);

       PNG files pack pixels of	bit depths 1, 2, and 4 into bytes as small  as
       they can, resulting in, for example, 8 pixels per byte for 1 bit	files.
       This code expands to 1 pixel per	byte without changing  the  values  of
       the pixels:

	   if (bit_depth < 8)
	      png_set_packing(png_ptr);

       PNG  files  have	possible bit depths of 1, 2, 4,	8, and 16.  All	pixels
       stored in a PNG image have been "scaled"	or "shifted" up	 to  the  next
       higher  possible	bit depth (e.g.	from 5 bits/sample in the range	[0,31]
       to 8 bits/sample	in the range [0, 255]).	 However, it is	also  possible
       to convert the PNG pixel	data back to the original bit depth of the im-
       age.  This call reduces the pixels back down to the original bit	depth:

	   png_color_8p	sig_bit;

	   if (png_get_sBIT(png_ptr, info_ptr, &sig_bit))
	      png_set_shift(png_ptr, sig_bit);

       PNG files store 3-color pixels in red, green, blue  order.   This  code
       changes the storage of the pixels to blue, green, red:

	   if (color_type == PNG_COLOR_TYPE_RGB	||
	       color_type == PNG_COLOR_TYPE_RGB_ALPHA)
	      png_set_bgr(png_ptr);

       PNG  files store	RGB pixels packed into 3 or 6 bytes. This code expands
       them into 4 or 8	bytes for windowing systems that  need	them  in  this
       format:

	   if (color_type == PNG_COLOR_TYPE_RGB)
	      png_set_filler(png_ptr, filler, PNG_FILLER_BEFORE);

       where  "filler" is the 8-bit or 16-bit number to	fill with, and the lo-
       cation is either	PNG_FILLER_BEFORE or PNG_FILLER_AFTER, depending  upon
       whether	you  want  the filler before the RGB or	after. When filling an
       8-bit pixel, the	least significant 8 bits of the	number are used, if  a
       16-bit  number is supplied.  This transformation	does not affect	images
       that already have full alpha channels.  To add an opaque	alpha channel,
       use filler=0xffff and PNG_FILLER_AFTER which will generate RGBA pixels.

       Note that png_set_filler() does not change the color type.  If you want
       to do that, you can add a true alpha channel with

	   if (color_type == PNG_COLOR_TYPE_RGB	||
	      color_type == PNG_COLOR_TYPE_GRAY)
	      png_set_add_alpha(png_ptr, filler, PNG_FILLER_AFTER);

       where "filler" contains the alpha value to assign to each  pixel.   The
       png_set_add_alpha() function was	added in libpng-1.2.7.

       If  you	are  reading  an image with an alpha channel, and you need the
       data as ARGB instead of the normal PNG format RGBA:

	   if (color_type == PNG_COLOR_TYPE_RGB_ALPHA)
	      png_set_swap_alpha(png_ptr);

       For some	uses, you may want a grayscale image to	be represented as RGB.
       This code will do that conversion:

	   if (color_type == PNG_COLOR_TYPE_GRAY ||
	       color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
	      png_set_gray_to_rgb(png_ptr);

       Conversely,  you	 can  convert  an  RGB	or  RGBA image to grayscale or
       grayscale with alpha.

	   if (color_type == PNG_COLOR_TYPE_RGB	||
	       color_type == PNG_COLOR_TYPE_RGB_ALPHA)
	      png_set_rgb_to_gray(png_ptr, error_action,
		 double	red_weight, double green_weight);

	   error_action	= 1: silently do the conversion

	   error_action	= 2: issue a warning if	the original
			     image has any pixel where
			     red != green or red != blue

	   error_action	= 3: issue an error and	abort the
			     conversion	if the original
			     image has any pixel where
			     red != green or red != blue

	   red_weight:	     weight of red component

	   green_weight:     weight of green component
			     If	either weight is negative, default
			     weights are used.

       In the corresponding fixed point	API the	 red_weight  and  green_weight
       values are simply scaled	by 100,000:

	   png_set_rgb_to_gray(png_ptr,	error_action,
	      png_fixed_point red_weight,
	      png_fixed_point green_weight);

       If  you have set	error_action = 1 or 2, you can later check whether the
       image really was	gray,  after  processing  the  image  rows,  with  the
       png_get_rgb_to_gray_status(png_ptr)   function.	  It   will  return  a
       png_byte	that is	zero if	the image was gray or 1	if there were any non-
       gray  pixels.   Background  and sBIT data will be silently converted to
       grayscale, using	the green channel data for sBIT, regardless of the er-
       ror_action setting.

       The default values come from the	PNG file cHRM chunk if present;	other-
       wise, the defaults correspond to	the ITU-R recommendation 709, and also
       the  sRGB  color	 space,	as recommended in the Charles Poynton's	Colour
       FAQ, Copyright (c) 2006-11-28 Charles Poynton, in section 9:

       <http://www.poynton.com/notes/colour_and_gamma/ColorFAQ.html#RTFToC9>

	   Y = 0.2126 *	R + 0.7152 * G + 0.0722	* B

       Previous	versions of this document, 1998	through	 2002,	recommended  a
       slightly	different formula:

	   Y = 0.212671	* R + 0.715160 * G + 0.072169 *	B

       Libpng uses an integer approximation:

	   Y = (6968 * R + 23434 * G + 2366 * B)/32768

       The  calculation	is done	in a linear colorspace,	if the image gamma can
       be determined.

       The png_set_background()	function has been described already; it	 tells
       libpng  to  composite  images with alpha	or simple transparency against
       the supplied background color.	For  compatibility  with  versions  of
       libpng  earlier	than  libpng-1.5.4 it is recommended that you call the
       function	after reading the file header, even if you don't want  to  use
       the color in a bKGD chunk, if one exists.

       If  the	PNG  file contains a bKGD chunk	(PNG_INFO_bKGD valid), you may
       use this	color, or supply another color more suitable for  the  current
       display (e.g., the background color from	a web page).  You need to tell
       libpng how the color is represented, both the format of	the  component
       values  in the color (the number	of bits) and the gamma encoding	of the
       color.  The function takes  two	arguments,  background_gamma_mode  and
       need_expand  to convey this information;	however, only two combinations
       are likely to be	useful:

	   png_color_16	my_background;
	   png_color_16p image_background;

	   if (png_get_bKGD(png_ptr, info_ptr, &image_background))
	      png_set_background(png_ptr, image_background,
		  PNG_BACKGROUND_GAMMA_FILE, 1/*needs to be expanded*/,	1);
	   else
	      png_set_background(png_ptr, &my_background,
		  PNG_BACKGROUND_GAMMA_SCREEN, 0/*do not expand*/, 1);

       The second call was described above - my_background is in the format of
       the  final,  display,  output produced by libpng.  Because you now know
       the format of the PNG it	is possible to avoid the need to choose	either
       8-bit or	16-bit output and to retain palette images (the	palette	colors
       will be modified	appropriately and the tRNS chunk  removed.)   However,
       if  you	are doing this,	take great care	not to ask for transformations
       without checking	first that they	apply!

       In the first call the background	color has the original bit  depth  and
       color  type  of the PNG file.  So, for palette images the color is sup-
       plied as	a palette index	and for	low bit	greyscale images the color  is
       a reduced bit value in image_background->gray.

       If  you didn't call png_set_gamma() before reading the file header, for
       example if you need your	code to	remain compatible with older  versions
       of libpng prior to libpng-1.5.4,	this is	the place to call it.

       Do not call it if you called png_set_alpha_mode(); doing	so will	damage
       the settings put	in place  by  png_set_alpha_mode().   (If  png_set_al-
       pha_mode()  is  supported then you can certainly	do png_set_gamma() be-
       fore reading the	PNG header.)

       This API	unconditionally	sets the screen	and file gamma values,	so  it
       will  override the value	in the PNG file	unless it is called before the
       PNG file	reading	starts.	 For this reason you must always call it  with
       the PNG file value when you call	it in this position:

	  if (png_get_gAMA(png_ptr, info_ptr, &file_gamma))
	     png_set_gamma(png_ptr, screen_gamma, file_gamma);

	  else
	     png_set_gamma(png_ptr, screen_gamma, 0.45455);

       If  you need to reduce an RGB file to a paletted	file, or if a paletted
       file has	more entries than will fit on your screen,  png_set_quantize()
       will  do	 that.	 Note  that  this  is a	simple match quantization that
       merely finds the	closest	color available.  This should work fairly well
       with  optimized palettes, but fairly badly with linear color cubes.  If
       you pass	a palette that is larger than maximum_colors,  the  file  will
       reduce  the  number  of colors in the palette so	it will	fit into maxi-
       mum_colors.  If there is	a histogram, libpng will use it	to  make  more
       intelligent  choices  when  reducing  the palette.  If there is no his-
       togram, it may not do as	good a job.

	  if (color_type & PNG_COLOR_MASK_COLOR)
	  {
	     if	(png_get_valid(png_ptr,	info_ptr,
		 PNG_INFO_PLTE))
	     {
		png_uint_16p histogram = NULL;

		png_get_hIST(png_ptr, info_ptr,
		    &histogram);
		png_set_quantize(png_ptr, palette, num_palette,
		   max_screen_colors, histogram, 1);
	     }

	     else
	     {
		png_color std_color_cube[MAX_SCREEN_COLORS] =
		   { ... colors	... };

		png_set_quantize(png_ptr, std_color_cube,
		   MAX_SCREEN_COLORS, MAX_SCREEN_COLORS,
		   NULL,0);
	     }
	  }

       PNG files describe monochrome as	black being zero and white being  one.
       The  following  code  will reverse this (make black be one and white be
       zero):

	  if (bit_depth	== 1 &&	color_type == PNG_COLOR_TYPE_GRAY)
	     png_set_invert_mono(png_ptr);

       This function can also be used to invert	grayscale and  gray-alpha  im-
       ages:

	  if (color_type == PNG_COLOR_TYPE_GRAY	||
	      color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
	     png_set_invert_mono(png_ptr);

       PNG  files  store  16-bit pixels	in network byte	order (big-endian, ie.
       most significant	bits first).  This code	changes	 the  storage  to  the
       other  way  (little-endian,  i.e. least significant bits	first, the way
       PCs store them):

	   if (bit_depth == 16)
	      png_set_swap(png_ptr);

       If you are using	packed-pixel images (1,	2, or 4	bits/pixel),  and  you
       need to change the order	the pixels are packed into bytes, you can use:

	   if (bit_depth < 8)
	      png_set_packswap(png_ptr);

       Finally,	 you can write your own	transformation function	if none	of the
       existing	ones meets your	needs.	This is	done  by  setting  a  callback
       with

	   png_set_read_user_transform_fn(png_ptr,
	       read_transform_fn);

       You must	supply the function

	   void	read_transform_fn(png_structp png_ptr, png_row_infop
	       row_info, png_bytep data)

       See  pngtest.c for a working example.  Your function will be called af-
       ter all of the other transformations have been  processed.   Take  care
       with  interlaced	images if you do the interlace yourself	- the width of
       the row is the width in 'row_info', not the overall image width.

       If supported, libpng provides two information routines that you can use
       to find where you are in	processing the image:

	  png_get_current_pass_number(png_structp png_ptr);
	  png_get_current_row_number(png_structp png_ptr);

       Don't  try  using these outside a transform callback - firstly they are
       only supported if user transforms are supported,	secondly they may well
       return unexpected results unless	the row	is actually being processed at
       the moment they are called.

       With interlaced images the value	returned is the	row in the input  sub-
       image	 image.	     Use    PNG_ROW_FROM_PASS_ROW(row,	  pass)	   and
       PNG_COL_FROM_PASS_COL(col, pass)	to find	the output pixel  (x,y)	 given
       an interlaced sub-image pixel (row,col,pass).

       The discussion of interlace handling above contains more	information on
       how to use these	values.

       You can also set	up a pointer to	a user structure for use by your call-
       back  function,	and you	can inform libpng that your transform function
       will change the number of channels or bit depth with the	function

	   png_set_user_transform_info(png_ptr,	user_ptr,
	       user_depth, user_channels);

       The user's application, not libpng, is responsible for  allocating  and
       freeing any memory required for the user	structure.

       You  can	 retrieve  the	pointer	 via  the function png_get_user_trans-
       form_ptr().  For	example:

	   voidp read_user_transform_ptr =
	       png_get_user_transform_ptr(png_ptr);

       The last	thing to handle	is interlacing;	this is	covered	in detail  be-
       low,  but  you must call	the function here if you want libpng to	handle
       expansion of the	interlaced image.

	   number_of_passes = png_set_interlace_handling(png_ptr);

       After setting the transformations,  libpng  can	update	your  png_info
       structure  to  reflect  any  transformations you've requested with this
       call.

	   png_read_update_info(png_ptr, info_ptr);

       This is most useful to update the info structure's  rowbytes  field  so
       you  can	use it to allocate your	image memory.  This function will also
       update your palette with	the correct  screen_gamma  and	background  if
       these  have  been  given	 with  the  calls  above.   You	 may only call
       png_read_update_info() once with	a particular info_ptr.

       After you call png_read_update_info(), you can allocate any memory  you
       need  to	 hold the image.  The row data is simply raw byte data for all
       forms of	images.	 As the	actual allocation varies  among	 applications,
       no  example  will be given.  If you are allocating one large chunk, you
       will need to build an array of pointers to each	row,  as  it  will  be
       needed for some of the functions	below.

       Remember: Before	you call png_read_update_info(), the png_get_*() func-
       tions return the	values corresponding to	the original PNG image.	 After
       you call	png_read_update_info the values	refer to the image that	libpng
       will output.  Consequently you must call	all the	png_set_ functions be-
       fore  you  call png_read_update_info().	This is	particularly important
       for  png_set_interlace_handling()  -  if	 you   are   going   to	  call
       png_read_update_info()  you  must call png_set_interlace_handling() be-
       fore it unless you want to receive interlaced output.

   Reading image data
       After you've allocated memory, you can read the image data.   The  sim-
       plest  way  to  do this is in one function call.	 If you	are allocating
       enough memory to	hold the whole image, you can just  call  png_read_im-
       age() and libpng	will read in all the image data	and put	it in the mem-
       ory area	supplied.  You will need to pass in an array  of  pointers  to
       each row.

       This  function  automatically handles interlacing, so you don't need to
       call  png_set_interlace_handling()  (unless   you   call	  png_read_up-
       date_info()) or call this function multiple times, or any of that other
       stuff necessary with png_read_rows().

	  png_read_image(png_ptr, row_pointers);

       where row_pointers is:

	  png_bytep row_pointers[height];

       You can point to	void or	char or	whatever you use for pixels.

       If you don't want to read in the	whole  image  at  once,	 you  can  use
       png_read_rows()	instead.   If  there  is  no interlacing (check	inter-
       lace_type == PNG_INTERLACE_NONE), this is simple:

	   png_read_rows(png_ptr, row_pointers,	NULL,
	       number_of_rows);

       where row_pointers is the same as in the	png_read_image() call.

       If you are doing	this just one row at a time, you can do	 this  with  a
       single row_pointer instead of an	array of row_pointers:

	   png_bytep row_pointer = row;
	   png_read_row(png_ptr, row_pointer, NULL);

       If  the	file  is  interlaced  (interlace_type != 0 in the IHDR chunk),
       things get somewhat harder.  The	only current (PNG  Specification  ver-
       sion  1.2)  interlacing	type  for PNG is (interlace_type == PNG_INTER-
       LACE_ADAM7); a somewhat	complicated  2D	 interlace  scheme,  known  as
       Adam7,  that  breaks down an image into seven smaller images of varying
       size, based on an 8x8 grid.  This number	is defined (from  libpng  1.5)
       as PNG_INTERLACE_ADAM7_PASSES in	png.h

       libpng  can  fill  out those images or it can give them to you "as is".
       It is almost always better to have libpng handle	 the  interlacing  for
       you.  If	you want the images filled out,	there are two ways to do that.
       The one mentioned in the	PNG specification is to	expand each  pixel  to
       cover  those  pixels  that  have	 not  been  read  yet (the "rectangle"
       method).	 This results in a blocky image	 for  the  first  pass,	 which
       gradually smooths out as	more pixels are	read.  The other method	is the
       "sparkle" method, where pixels are drawn	only in	their final locations,
       with the	rest of	the image remaining whatever colors they were initial-
       ized to before the start	of the read.  The first	method	usually	 looks
       better,	but tends to be	slower,	as there are more pixels to put	in the
       rows.

       If, as is likely, you want libpng to expand the images, call  this  be-
       fore calling png_start_read_image() or png_read_update_info():

	   if (interlace_type == PNG_INTERLACE_ADAM7)
	      number_of_passes
		  = png_set_interlace_handling(png_ptr);

       This  will  return  the	number	of  passes needed.  Currently, this is
       seven, but may change if	another	interlace type is added.   This	 func-
       tion  can  be  called even if the file is not interlaced, where it will
       return one  pass.   You	then  need  to	read  the  whole  image	 'num-
       ber_of_passes'  times.	Each  time will	distribute the pixels from the
       current pass to the correct place in the	output image, so you  need  to
       supply the same rows to png_read_rows in	each pass.

       If  you are not going to	display	the image after	each pass, but are go-
       ing to wait until the entire image is read in, use the sparkle  effect.
       This  effect  is	 faster	and the	end result of either method is exactly
       the same.  If you are planning on displaying the	image after each pass,
       the "rectangle" effect is generally considered the better looking one.

       If  you	only  want  the	 "sparkle" effect, just	call png_read_row() or
       png_read_rows() as normal, with the third parameter  NULL.   Make  sure
       you  make  pass	over  the  image number_of_passes times, and you don't
       change the data in the rows between calls.  You can  change  the	 loca-
       tions of	the data, just not the data.  Each pass	only writes the	pixels
       appropriate for that pass, and assumes the data from previous passes is
       still valid.

	   png_read_rows(png_ptr, row_pointers,	NULL,
	       number_of_rows);
	   or
	   png_read_row(png_ptr, row_pointers, NULL);

       If  you only want the first effect (the rectangles), do the same	as be-
       fore except pass	the row	buffer in the third parameter, and  leave  the
       second parameter	NULL.

	   png_read_rows(png_ptr, NULL,	row_pointers,
	       number_of_rows);
	   or
	   png_read_row(png_ptr, NULL, row_pointers);

       If  you	don't want libpng to handle the	interlacing details, just call
       png_read_rows() PNG_INTERLACE_ADAM7_PASSES times	to read	in all the im-
       ages.  Each of the images is a valid image by itself; however, you will
       almost certainly	need to	distribute the pixels from each	 sub-image  to
       the correct place.  This	is where everything gets very tricky.

       If  you	want to	retrieve the separate images you must pass the correct
       number of rows to each successive call of png_read_rows().  The	calcu-
       lation  gets pretty complicated for small images, where some sub-images
       may not even exist because either their width or	height ends  up	 zero.
       libpng provides two macros to help you in 1.5 and later versions:

	  png_uint_32 width = PNG_PASS_COLS(image_width, pass_number);
	  png_uint_32 height = PNG_PASS_ROWS(image_height, pass_number);

       Respectively  these tell	you the	width and height of the	sub-image cor-
       responding to the numbered pass.	 'pass'	is in in the range 0  to  6  -
       this  can  be  confusing	 because  the specification refers to the same
       passes as 1 to 7!  Be careful, you must check both the width and	height
       before  calling png_read_rows() and not call it for that	pass if	either
       is zero.

       You can,	of course, read	each sub-image row by row.   If	 you  want  to
       produce	optimal	code to	make a pixel-by-pixel transformation of	an in-
       terlaced	image this is the best approach; read each row of  each	 pass,
       transform it, and write it out to a new interlaced image.

       If  you want to de-interlace the	image yourself libpng provides further
       macros to help that tell	you where to place the pixels  in  the	output
       image.	Because	the interlacing	scheme is rectangular -	sub-image pix-
       els are always arranged on a rectangular	grid - all you	need  to  know
       for each	pass is	the starting column and	row in the output image	of the
       first pixel plus	the spacing between each  pixel.   As  of  libpng  1.5
       there are four macros to	retrieve this information:

	  png_uint_32 x	= PNG_PASS_START_COL(pass);
	  png_uint_32 y	= PNG_PASS_START_ROW(pass);
	  png_uint_32 xStep = 1U << PNG_PASS_COL_SHIFT(pass);
	  png_uint_32 yStep = 1U << PNG_PASS_ROW_SHIFT(pass);

       These allow you to write	the obvious loop:

	  png_uint_32 input_y =	0;
	  png_uint_32 output_y = PNG_PASS_START_ROW(pass);

	  while	(output_y < output_image_height)
	  {
	     png_uint_32 input_x = 0;
	     png_uint_32 output_x = PNG_PASS_START_COL(pass);

	     while (output_x < output_image_width)
	     {
		image[output_y][output_x] =
		    subimage[pass][input_y][input_x++];

		output_x += xStep;
	     }

	     ++input_y;
	     output_y += yStep;
	  }

       Notice  that  the  steps	between	successive output rows and columns are
       returned	as shifts.  This is possible because the pixels	in the	subim-
       ages are	always a power of 2 apart - 1, 2, 4 or 8 pixels	- in the orig-
       inal image.  In practice	you may	need to	directly calculate the	output
       coordinate  given  an  input  coordinate.   libpng provides two further
       macros for this purpose:

	  png_uint_32 output_x = PNG_COL_FROM_PASS_COL(input_x,	pass);
	  png_uint_32 output_y = PNG_ROW_FROM_PASS_ROW(input_y,	pass);

       Finally a pair of macros	are provided to	tell you if a particular image
       row or column appears in	a given	pass:

	  int col_in_pass = PNG_COL_IN_INTERLACE_PASS(output_x,	pass);
	  int row_in_pass = PNG_ROW_IN_INTERLACE_PASS(output_y,	pass);

       Bear  in	 mind  that you	will probably also need	to check the width and
       height of the pass in addition to the above to be sure  the  pass  even
       exists!

       With  any  luck you are convinced by now	that you don't want to do your
       own interlace handling.	In reality normally the	only good  reason  for
       doing this is if	you are	processing PNG files on	a pixel-by-pixel basis
       and don't want to load the whole	file into memory  when	it  is	inter-
       laced.

       libpng  includes	a test program,	pngvalid, that illustrates reading and
       writing of interlaced images.  If you can't get interlacing to work  in
       your  code  and	don't  want to leave it	to libpng (the recommended ap-
       proach),	see how	pngvalid.c does	it.

   Finishing a sequential read
       After you are finished reading the image	through	the  low-level	inter-
       face, you can finish reading the	file.

       If  you	want  to use a different crc action for	handling CRC errors in
       chunks after the	image data, you	can call png_set_crc_action() again at
       this point.

       If  you	are interested in comments or time, which may be stored	either
       before or after the image data, you should pass the  separate  png_info
       struct if you want to keep the comments from before and after the image
       separate.

	   png_infop end_info =	png_create_info_struct(png_ptr);

	   if (!end_info)
	   {
	      png_destroy_read_struct(&png_ptr,	&info_ptr,
		  (png_infopp)NULL);
	      return (ERROR);
	   }

	  png_read_end(png_ptr,	end_info);

       If you are not interested, you should still call	png_read_end() but you
       can  pass  NULL,	avoiding the need to create an end_info	structure.  If
       you do this, libpng will	not process any	chunks after IDAT  other  than
       skipping	 over  them  and perhaps (depending on whether you have	called
       png_set_crc_action) checking their CRCs	while  looking	for  the  IEND
       chunk.

	  png_read_end(png_ptr,	(png_infop)NULL);

       If  you	don't call png_read_end(), then	your file pointer will be left
       pointing	to the first chunk after the last IDAT,	which is probably  not
       what you	want if	you expect to read something beyond the	end of the PNG
       datastream.

       When you	are done, you can free all memory  allocated  by  libpng  like
       this:

	  png_destroy_read_struct(&png_ptr, &info_ptr,
	      &end_info);

       or, if you didn't create	an end_info structure,

	  png_destroy_read_struct(&png_ptr, &info_ptr,
	      (png_infopp)NULL);

       It  is  also  possible  to  individually	free the info_ptr members that
       point to	libpng-allocated storage with the following function:

	   png_free_data(png_ptr, info_ptr, mask, seq)

	   mask	- identifies data to be	freed, a mask
		  containing the bitwise OR of one or
		  more of
		    PNG_FREE_PLTE, PNG_FREE_TRNS,
		    PNG_FREE_HIST, PNG_FREE_ICCP,
		    PNG_FREE_PCAL, PNG_FREE_ROWS,
		    PNG_FREE_SCAL, PNG_FREE_SPLT,
		    PNG_FREE_TEXT, PNG_FREE_UNKN,
		  or simply PNG_FREE_ALL

	   seq	- sequence number of item to be	freed
		  (-1 for all items)

       This function may be safely called when the relevant  storage  has  al-
       ready  been  freed,  or has not yet been	allocated, or was allocated by
       the user	and not	by libpng,  and	will in	those cases do	nothing.   The
       "seq"  parameter	is ignored if only one item of the selected data type,
       such as PLTE, is	allowed.  If "seq" is not -1, and multiple  items  are
       allowed for the data type identified in the mask, such as text or sPLT,
       only the	n'th item in the structure is freed, where n is	"seq".

       The default behavior is only to free data that was allocated internally
       by libpng.  This	can be changed,	so that	libpng will not	free the data,
       or so that it will free data  that  was	allocated  by  the  user  with
       png_malloc()  or	png_calloc() and passed	in via a png_set_*() function,
       with

	   png_data_freer(png_ptr, info_ptr, freer, mask)

	   freer  - one	of
		      PNG_DESTROY_WILL_FREE_DATA
		      PNG_SET_WILL_FREE_DATA
		      PNG_USER_WILL_FREE_DATA

	   mask	  - which data elements	are affected
		    same choices as in png_free_data()

       This function only affects data that has	already	been  allocated.   You
       can  call  this	function after reading the PNG data but	before calling
       any  png_set_*()	 functions,  to	 control  whether  the	user  or   the
       png_set_*()  function is	responsible for	freeing	any existing data that
       might be	present, and again after the png_set_*() functions to  control
       whether the user	or png_destroy_*() is supposed to free the data.  When
       the user	assumes	responsibility for libpng-allocated data, the applica-
       tion  must  use	png_free() to free it, and when	the user transfers re-
       sponsibility to libpng for data that the	user has allocated,  the  user
       must have used png_malloc() or png_calloc() to allocate it.

       If  you	allocated  your	 row_pointers  in a single block, as suggested
       above in	the description	of the high level read interface, you must not
       transfer	  responsibility   for	freeing	 it  to	 the  png_set_rows  or
       png_read_destroy	function, because they would also try to free the  in-
       dividual	row_pointers[i].

       If  you	allocated  text_ptr.text,  text_ptr.lang,  and text_ptr.trans-
       lated_keyword separately, do not	transfer  responsibility  for  freeing
       text_ptr	 to  libpng, because when libpng fills a png_text structure it
       combines	these members with the key member,  and	 png_free_data()  will
       free  only text_ptr.key.	 Similarly, if you transfer responsibility for
       free'ing	text_ptr from libpng to	 your  application,  your  application
       must not	separately free	those members.

       The  png_free_data()  function  will turn off the "valid" flag for any-
       thing it	frees.	If you need to turn the	flag off for a chunk that  was
       freed by	your application instead of by libpng, you can use

	   png_set_invalid(png_ptr, info_ptr, mask);

	   mask	- identifies the chunks	to be made invalid,
		  containing the bitwise OR of one or
		  more of
		    PNG_INFO_gAMA, PNG_INFO_sBIT,
		    PNG_INFO_cHRM, PNG_INFO_PLTE,
		    PNG_INFO_tRNS, PNG_INFO_bKGD,
		    PNG_INFO_hIST, PNG_INFO_pHYs,
		    PNG_INFO_oFFs, PNG_INFO_tIME,
		    PNG_INFO_pCAL, PNG_INFO_sRGB,
		    PNG_INFO_iCCP, PNG_INFO_sPLT,
		    PNG_INFO_sCAL, PNG_INFO_IDAT

       For  a  more compact example of reading a PNG image, see	the file exam-
       ple.c.

   Reading PNG files progressively
       The progressive reader is slightly different from  the  non-progressive
       reader.	 Instead  of  calling  png_read_info(),	 png_read_rows(),  and
       png_read_end(), you make	one call to  png_process_data(),  which	 calls
       callbacks  when	it  has	the info, a row, or the	end of the image.  You
       set up these callbacks with png_set_progressive_read_fn().   You	 don't
       have  to	 worry	about the input/output functions of libpng, as you are
       giving the library the data directly in png_process_data().  I will as-
       sume  that  you	have read the section on reading PNG files above, so I
       will only highlight the differences (although I will show  all  of  the
       code).

       png_structp png_ptr; png_infop info_ptr;

	/*  An example code fragment of	how you	would
	    initialize the progressive reader in your
	    application. */
	int
	initialize_png_reader()
	{
	   png_ptr = png_create_read_struct
	       (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,
		user_error_fn, user_warning_fn);

	   if (!png_ptr)
	       return (ERROR);

	   info_ptr = png_create_info_struct(png_ptr);

	   if (!info_ptr)
	   {
	      png_destroy_read_struct(&png_ptr,
		 (png_infopp)NULL, (png_infopp)NULL);
	      return (ERROR);
	   }

	   if (setjmp(png_jmpbuf(png_ptr)))
	   {
	      png_destroy_read_struct(&png_ptr,	&info_ptr,
		 (png_infopp)NULL);
	      return (ERROR);
	   }

	   /* This one's new.  You can provide functions
	      to be called when	the header info	is valid,
	      when each	row is completed, and when the image
	      is finished.  If you aren't using	all functions,
	      you can specify NULL parameters.	Even when all
	      three functions are NULL,	you need to call
	      png_set_progressive_read_fn().  You can use
	      any struct as the	user_ptr (cast to a void pointer
	      for the function call), and retrieve the pointer
	      from inside the callbacks	using the function

		 png_get_progressive_ptr(png_ptr);

	      which will return	a void pointer,	which you have
	      to cast appropriately.
	    */
	   png_set_progressive_read_fn(png_ptr,	(void *)user_ptr,
	       info_callback, row_callback, end_callback);

	   return 0;
	}

	/* A code fragment that	you call as you	receive	blocks
	  of data */
	int
	process_data(png_bytep buffer, png_uint_32 length)
	{
	   if (setjmp(png_jmpbuf(png_ptr)))
	   {
	      png_destroy_read_struct(&png_ptr,	&info_ptr,
		  (png_infopp)NULL);
	      return (ERROR);
	   }

	   /* This one's new also.  Simply give	it a chunk
	      of data from the file stream (in order, of
	      course).	On machines with segmented memory
	      models machines, don't give it any more than
	      64K.  The	library	seems to run fine with sizes
	      of 4K. Although you can give it much less	if
	      necessary	(I assume you can give it chunks of
	      1	byte, I	haven't	tried less than	256 bytes
	      yet).  When this function	returns, you may
	      want to display any rows that were generated
	      in the row callback if you don't already do
	      so there.
	    */
	   png_process_data(png_ptr, info_ptr, buffer, length);

	   /* At this point you	can call png_process_data_skip if
	      you want to handle data the library will skip yourself;
	      it simply	returns	the number of bytes to skip (and stops
	      libpng skipping that number of bytes on the next
	      png_process_data call).
	   return 0;
	}

	/* This	function is called (as set by
	   png_set_progressive_read_fn() above)	when enough data
	   has been supplied so	all of the header has been
	   read.
	*/
	void
	info_callback(png_structp png_ptr, png_infop info)
	{
	   /* Do any setup here, including setting any of
	      the transformations mentioned in the Reading
	      PNG files	section.  For now, you _must_ call
	      either png_start_read_image() or
	      png_read_update_info() after all the
	      transformations are set (even if you don't set
	      any).  You may start getting rows	before
	      png_process_data() returns, so this is your
	      last chance to prepare for that.

	      This is where you	turn on	interlace handling,
	      assuming you don't want to do it yourself.

	      If you need to you can stop the processing of
	      your original input data at this point by	calling
	      png_process_data_pause.  This returns the	number
	      of unprocessed bytes from	the last png_process_data
	      call - it	is up to you to	ensure that the	next call
	      sees these bytes again.  If you don't want to bother
	      with this	you can	get libpng to cache the	unread
	      bytes by setting the 'save' parameter (see png.h)	but
	      then libpng will have to copy the	data internally.
	    */
	}

	/* This	function is called when	each row of image
	   data	is complete */
	void
	row_callback(png_structp png_ptr, png_bytep new_row,
	   png_uint_32 row_num,	int pass)
	{
	   /* If the image is interlaced, and you turned
	      on the interlace handler,	this function will
	      be called	for every row in every pass.  Some
	      of these rows will not be	changed	from the
	      previous pass.  When the row is not changed,
	      the new_row variable will	be NULL.  The rows
	      and passes are called in order, so you don't
	      really need the row_num and pass,	but I'm
	      supplying	them because it	may make your life
	      easier.

	      If you did not turn on interlace handling	then
	      the callback is called for each row of each
	      sub-image	when the image is interlaced.  In this
	      case 'row_num' is	the row	in the sub-image, not
	      the row in the output image as it	is in all other
	      cases.

	      For the non-NULL rows of interlaced images when
	      you have switched	on libpng interlace handling,
	      you must call png_progressive_combine_row()
	      passing in the row and the old row.  You can
	      call this	function for NULL rows (it will	just
	      return) and for non-interlaced images (it	just
	      does the memcpy for you) if it will make the
	      code easier.  Thus, you can just do this for
	      all cases	if you switch on interlace handling;
	    */

	       png_progressive_combine_row(png_ptr, old_row,
		 new_row);

	   /* where old_row is what was	displayed
	      previously for the row.  Note that the first
	      pass (pass == 0, really) will completely cover
	      the old row, so the rows do not have to be
	      initialized.  After the first pass (and only
	      for interlaced images), you will have to pass
	      the current row, and the function	will combine
	      the old row and the new row.

	      You can also call	png_process_data_pause in this
	      callback - see above.
	   */
	}

	void
	end_callback(png_structp png_ptr, png_infop info)
	{
	   /* This function is called after the	whole image
	      has been read, including any chunks after	the
	      image (up	to and including the IEND).  You
	      will usually have	the same info chunk as you
	      had in the header, although some data may	have
	      been added to the	comments and time fields.

	      Most people won't	do much	here, perhaps setting
	      a	flag that marks	the image as finished.
	    */
	}

IV. Writing
       Much of this is very similar to reading.	 However, everything of	impor-
       tance is	repeated here, so you won't have to constantly look back up in
       the reading section to understand writing.

   Setup
       You  will want to do the	I/O initialization before you get into libpng,
       so if it	doesn't	work, you don't	have anything to undo. If you are  not
       using  the  standard  I/O functions, you	will need to replace them with
       custom writing functions.  See the discussion under Customizing libpng.

	   FILE	*fp = fopen(file_name, "wb");

	   if (!fp)
	      return (ERROR);

       Next, png_struct	and png_info need to be	allocated and initialized.  As
       these  can be both relatively large, you	may not	want to	store these on
       the stack, unless you have stack	space to spare.	 Of course,  you  will
       want  to	check if they return NULL.  If you are also reading, you won't
       want to	name  your  read  structure  and  your	write  structure  both
       "png_ptr";  you can call	them anything you like,	such as	"read_ptr" and
       "write_ptr".  Look at pngtest.c,	for example.

	   png_structp png_ptr = png_create_write_struct
	      (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,
	       user_error_fn, user_warning_fn);

	   if (!png_ptr)
	      return (ERROR);

	   png_infop info_ptr =	png_create_info_struct(png_ptr);
	   if (!info_ptr)
	   {
	      png_destroy_write_struct(&png_ptr,
		  (png_infopp)NULL);
	      return (ERROR);
	   }

       If you  want  to	 use  your  own	 memory	 allocation  routines,	define
       PNG_USER_MEM_SUPPORTED  and  use	png_create_write_struct_2() instead of
       png_create_write_struct():

	   png_structp png_ptr = png_create_write_struct_2
	      (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr,
	       user_error_fn, user_warning_fn, (png_voidp)
	       user_mem_ptr, user_malloc_fn, user_free_fn);

       After you have these structures,	you will need to set up	the error han-
       dling.	When  libpng encounters	an error, it expects to	longjmp() back
       to your routine.	 Therefore, you	will need to call  setjmp()  and  pass
       the  png_jmpbuf(png_ptr).   If  you  write the file from	different rou-
       tines, you will need to update the png_jmpbuf(png_ptr) every  time  you
       enter  a	new routine that will call a png_*() function.	See your docu-
       mentation of setjmp/longjmp for your compiler for more  information  on
       setjmp/longjmp.	 See  the  discussion  on libpng error handling	in the
       Customizing Libpng section below	for more information on	the libpng er-
       ror handling.

	   if (setjmp(png_jmpbuf(png_ptr)))
	   {
	   png_destroy_write_struct(&png_ptr, &info_ptr);
	      fclose(fp);
	      return (ERROR);
	   }
	   ...
	   return;

       If  you would rather avoid the complexity of setjmp/longjmp issues, you
       can compile libpng with PNG_NO_SETJMP, in which case errors will	result
       in a call to PNG_ABORT()	which defaults to abort().

       You can #define PNG_ABORT() to a	function that does something more use-
       ful than	abort(), as long as your function does not return.

       Checking	for invalid palette index on write was added at	libpng 1.5.10.
       If a pixel contains an invalid (out-of-range) index libpng issues a be-
       nign error.  This is enabled by default because this  condition	is  an
       error  according	to the PNG specification, Clause 11.3.2, but the error
       can be ignored in each png_ptr with

	  png_set_check_for_invalid_index(png_ptr, 0);

       If the error is ignored,	or if png_benign_error() treats	it as a	 warn-
       ing,  any invalid pixels	are written as-is by the encoder, resulting in
       an invalid PNG datastream as output.  In	this case the  application  is
       responsible  for	 ensuring  that	the pixel indexes are in range when it
       writes a	PLTE chunk with	fewer entries than the bit depth would allow.

       Now you need to set up the output code.	The default for	libpng	is  to
       use  the	C function fwrite().  If you use this, you will	need to	pass a
       valid FILE * in the function png_init_io().  Be sure that the  file  is
       opened  in  binary  mode.  Again, if you	wish to	handle writing data in
       another way, see	the discussion on libpng I/O handling in the Customiz-
       ing Libpng section below.

	   png_init_io(png_ptr,	fp);

       If  you are embedding your PNG into a datastream	such as	MNG, and don't
       want libpng to write the	8-byte signature, or if	you have already writ-
       ten the signature in your application, use

	   png_set_sig_bytes(png_ptr, 8);

       to inform libpng	that it	should not write a signature.

   Write callbacks
       At  this	 point,	you can	set up a callback function that	will be	called
       after each row has been	written,  which	 you  can  use	to  control  a
       progress	 meter or the like.  It's demonstrated in pngtest.c.  You must
       supply a	function

	   void	write_row_callback(png_structp png_ptr,	png_uint_32 row,
	      int pass);
	   {
	     /*	put your code here */
	   }

       (You can	give it	another	name that you like instead of "write_row_call-
       back")

       To inform libpng	about your function, use

	   png_set_write_status_fn(png_ptr, write_row_callback);

       When  this  function is called the row has already been completely pro-
       cessed and it has also been written out.	 The 'row' and 'pass' refer to
       the  next  row to be handled.  For the non-interlaced case the row that
       was just	handled	is simply one less than	the passed in row number,  and
       pass will always	be 0.  For the interlaced case the same	applies	unless
       the row value is	0, in which case the row just handled was the last one
       from  one of the	preceding passes.  Because interlacing may skip	a pass
       you cannot be sure that the preceding pass is just 'pass-1', if you re-
       ally  need  to  know  what  the last pass is record (row,pass) from the
       callback	and use	the last recorded value	each time.

       As with the user	transform you  can  find  the  output  row  using  the
       PNG_ROW_FROM_PASS_ROW macro.

       You  now	 have the option of modifying how the compression library will
       run.  The following functions are mainly	for testing, but may be	useful
       in  some	 cases,	like if	you need to write PNG files extremely fast and
       are willing to give up some compression,	or if you want to get the max-
       imum  possible  compression  at	the expense of slower writing.	If you
       have no special needs in	this area, let the library do what it wants by
       not  calling  this  function  at	all, as	it has been tuned to deliver a
       good speed/compression ratio. The second	parameter to  png_set_filter()
       is  the filter method, for which	the only valid values are 0 (as	of the
       July 1999 PNG specification, version 1.2) or 64 (if you are  writing  a
       PNG  datastream that is to be embedded in a MNG datastream).  The third
       parameter is a flag that	indicates  which  filter  type(s)  are	to  be
       tested for each scanline.  See the PNG specification for	details	on the
       specific	filter types.

	   /* turn on or off filtering,	and/or choose
	      specific filters.	 You can use either a single
	      PNG_FILTER_VALUE_NAME or the bitwise OR of one
	      or more PNG_FILTER_NAME masks.
	    */
	   png_set_filter(png_ptr, 0,
	      PNG_FILTER_NONE  | PNG_FILTER_VALUE_NONE |
	      PNG_FILTER_SUB   | PNG_FILTER_VALUE_SUB  |
	      PNG_FILTER_UP    | PNG_FILTER_VALUE_UP   |
	      PNG_FILTER_AVG   | PNG_FILTER_VALUE_AVG  |
	      PNG_FILTER_PAETH | PNG_FILTER_VALUE_PAETH|
	      PNG_ALL_FILTERS  | PNG_FAST_FILTERS);

       If an application wants to start	and stop using particular filters dur-
       ing compression,	it should start	out with all of	the filters (to	ensure
       that the	previous row of	pixels will be	stored	in  case  it's	needed
       later), and then	add and	remove them after the start of compression.

       If  you	are  writing  a	PNG datastream that is to be embedded in a MNG
       datastream, the second parameter	can be either 0	or 64.

       The png_set_compression_*() functions interface to the zlib compression
       library,	 and  should mostly be ignored unless you really know what you
       are  doing.   The  only	generally  useful  call	 is   png_set_compres-
       sion_level()  which changes how much time zlib spends on	trying to com-
       press the image data.  See the Compression Library  (zlib.h  and	 algo-
       rithm.txt,  distributed	with zlib) for details on the compression lev-
       els.

	   #include zlib.h

	   /* Set the zlib compression level */
	   png_set_compression_level(png_ptr,
	       Z_BEST_COMPRESSION);

	   /* Set other	zlib parameters	for compressing	IDAT */
	   png_set_compression_mem_level(png_ptr, 8);
	   png_set_compression_strategy(png_ptr,
	       Z_DEFAULT_STRATEGY);
	   png_set_compression_window_bits(png_ptr, 15);
	   png_set_compression_method(png_ptr, 8);
	   png_set_compression_buffer_size(png_ptr, 8192)

	   /* Set zlib parameters for text compression
	    * If you don't call	these, the parameters
	    * fall back	on those defined for IDAT chunks
	    */
	   png_set_text_compression_mem_level(png_ptr, 8);
	   png_set_text_compression_strategy(png_ptr,
	       Z_DEFAULT_STRATEGY);
	   png_set_text_compression_window_bits(png_ptr, 15);
	   png_set_text_compression_method(png_ptr, 8);

   Setting the contents	of info	for output
       You now need to fill in the png_info structure with all	the  data  you
       wish  to	 write	before the actual image.  Note that the	only thing you
       are allowed to write after the image is the text	chunks	and  the  time
       chunk  (as  of PNG Specification	1.2, anyway).  See png_write_end() and
       the latest PNG specification for	more information on that.  If you wish
       to write	them before the	image, fill them in now, and flag that data as
       being valid.  If	you want to wait until after the data, don't fill them
       until  png_write_end().	 For all the fields in png_info	and their data
       types, see png.h.  For explanations of what the fields contain, see the
       PNG specification.

       Some of the more	important parts	of the png_info	are:

	   png_set_IHDR(png_ptr, info_ptr, width, height,
	      bit_depth, color_type, interlace_type,
	      compression_type,	filter_method)

	   width	  - holds the width of the image
			    in pixels (up to 2^31).

	   height	  - holds the height of	the image
			    in pixels (up to 2^31).

	   bit_depth	  - holds the bit depth	of one of the
			    image channels.
			    (valid values are 1, 2, 4, 8, 16
			    and	depend also on the
			    color_type.	 See also significant
			    bits (sBIT)	below).

	   color_type	  - describes which color/alpha
			    channels are present.
			    PNG_COLOR_TYPE_GRAY
			       (bit depths 1, 2, 4, 8, 16)
			    PNG_COLOR_TYPE_GRAY_ALPHA
			       (bit depths 8, 16)
			    PNG_COLOR_TYPE_PALETTE
			       (bit depths 1, 2, 4, 8)
			    PNG_COLOR_TYPE_RGB
			       (bit_depths 8, 16)
			    PNG_COLOR_TYPE_RGB_ALPHA
			       (bit_depths 8, 16)

			    PNG_COLOR_MASK_PALETTE
			    PNG_COLOR_MASK_COLOR
			    PNG_COLOR_MASK_ALPHA

	   interlace_type - PNG_INTERLACE_NONE or
			    PNG_INTERLACE_ADAM7

	   compression_type - (must be
			    PNG_COMPRESSION_TYPE_DEFAULT)

	   filter_method  - (must be PNG_FILTER_TYPE_DEFAULT
			    or,	if you are writing a PNG to
			    be embedded	in a MNG datastream,
			    can	also be
			    PNG_INTRAPIXEL_DIFFERENCING)

       If  you	call  png_set_IHDR(),  the  call must appear before any	of the
       other png_set_*() functions, because they might require access to  some
       of  the	IHDR  settings.	  The  remaining  png_set_*() functions	can be
       called in any order.

       If you wish, you	can reset  the	compression_type,  interlace_type,  or
       filter_method  later  by	 calling png_set_IHDR()	again; if you do this,
       the width, height, bit_depth, and color_type must be the	same  in  each
       call.

	   png_set_PLTE(png_ptr, info_ptr, palette,
	      num_palette);

	   palette	  - the	palette	for the	file
			    (array of png_color)
	   num_palette	  - number of entries in the palette

	   png_set_gAMA(png_ptr, info_ptr, file_gamma);
	   png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma);

	   file_gamma	  - the	gamma at which the image was
			    created (PNG_INFO_gAMA)

	   int_file_gamma - 100,000 times the gamma at which
			    the	image was created

	   png_set_cHRM(png_ptr, info_ptr,  white_x, white_y, red_x, red_y,
			    green_x, green_y, blue_x, blue_y)
	   png_set_cHRM_XYZ(png_ptr, info_ptr, red_X, red_Y, red_Z, green_X,
			    green_Y, green_Z, blue_X, blue_Y, blue_Z)
	   png_set_cHRM_fixed(png_ptr, info_ptr, int_white_x, int_white_y,
			    int_red_x, int_red_y, int_green_x, int_green_y,
			    int_blue_x,	int_blue_y)
	   png_set_cHRM_XYZ_fixed(png_ptr, info_ptr, int_red_X,	int_red_Y,
			    int_red_Z, int_green_X, int_green_Y, int_green_Z,
			    int_blue_X,	int_blue_Y, int_blue_Z)

	   {white,red,green,blue}_{x,y}
			    A  color  space encoding specified using the chro-
       maticities
			    of the end points and the white point.

	   {red,green,blue}_{X,Y,Z}
			    A color space encoding specified using the	encod-
       ing end
			    points  - the CIE tristimulus specification	of the
       intended
			    color of the red, green and	blue channels  in  the
       PNG RGB
			    data.   The	 white	point is simply	the sum	of the
       three end
			    points.

	   png_set_sRGB(png_ptr, info_ptr, srgb_intent);

	   srgb_intent	  - the	rendering intent
			    (PNG_INFO_sRGB) The	presence of
			    the	sRGB chunk means that the pixel
			    data is in the sRGB	color space.
			    This chunk also implies specific
			    values of gAMA and cHRM.  Rendering
			    intent is the CSS-1	property that
			    has	been defined by	the International
			    Color Consortium
			    (http://www.color.org).
			    It can be one of
			    PNG_sRGB_INTENT_SATURATION,
			    PNG_sRGB_INTENT_PERCEPTUAL,
			    PNG_sRGB_INTENT_ABSOLUTE, or
			    PNG_sRGB_INTENT_RELATIVE.

	   png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr,
	      srgb_intent);

	   srgb_intent	  - the	rendering intent
			    (PNG_INFO_sRGB) The	presence of the
			    sRGB chunk means that the pixel
			    data is in the sRGB	color space.
			    This function also causes gAMA and
			    cHRM chunks	with the specific values
			    that are consistent	with sRGB to be
			    written.

	   png_set_iCCP(png_ptr, info_ptr, name, compression_type,
			      profile, proflen);

	   name		    - The profile name.

	   compression_type - The compression type; always
			      PNG_COMPRESSION_TYPE_BASE	for PNG	1.0.
			      You may give NULL	to this	argument to
			      ignore it.

	   profile	    - International Color Consortium color
			      profile data. May	contain	NULs.

	   proflen	    - length of	profile	data in	bytes.

	   png_set_sBIT(png_ptr, info_ptr, sig_bit);

	   sig_bit	  - the	number of significant bits for
			    (PNG_INFO_sBIT) each of the	gray, red,
			    green, and blue channels, whichever	are
			    appropriate	for the	given color type
			    (png_color_16)

	   png_set_tRNS(png_ptr, info_ptr, trans_alpha,
	      num_trans, trans_color);

	   trans_alpha	  - array of alpha (transparency)
			    entries for	palette	(PNG_INFO_tRNS)

	   num_trans	  - number of transparent entries
			    (PNG_INFO_tRNS)

	   trans_color	  - graylevel or color sample values
			    (in	order red, green, blue)	of the
			    single transparent color for
			    non-paletted images	(PNG_INFO_tRNS)

	   png_set_hIST(png_ptr, info_ptr, hist);

	   hist		  - histogram of palette (array	of
			    png_uint_16) (PNG_INFO_hIST)

	   png_set_tIME(png_ptr, info_ptr, mod_time);

	   mod_time	  - time image was last	modified
			    (PNG_VALID_tIME)

	   png_set_bKGD(png_ptr, info_ptr, background);

	   background	  - background color (of type
			    png_color_16p) (PNG_VALID_bKGD)

	   png_set_text(png_ptr, info_ptr, text_ptr, num_text);

	   text_ptr	  - array of png_text holding image
			    comments

	   text_ptr[i].compression - type of compression used
			on "text" PNG_TEXT_COMPRESSION_NONE
				  PNG_TEXT_COMPRESSION_zTXt
				  PNG_ITXT_COMPRESSION_NONE
				  PNG_ITXT_COMPRESSION_zTXt
	   text_ptr[i].key   - keyword for comment.  Must contain
			1-79 characters.
	   text_ptr[i].text  - text comments for current
				keyword.  Can be NULL or empty.
	   text_ptr[i].text_length - length of text string,
			after decompression, 0 for iTXt
	   text_ptr[i].itxt_length - length of itxt string,
			after decompression, 0 for tEXt/zTXt
	   text_ptr[i].lang  - language	of comment (NULL or
				empty for unknown).
	   text_ptr[i].translated_keyword  - keyword in	UTF-8 (NULL
				or empty for unknown).

	   Note	that the itxt_length, lang, and	lang_key
	   members of the text_ptr structure only exist	when the
	   library is built with iTXt chunk support.  Prior to
	   libpng-1.4.0	the library was	built by default without
	   iTXt	support. Also note that	when iTXt is supported,
	   they	contain	NULL pointers when the "compression"
	   field contains PNG_TEXT_COMPRESSION_NONE or
	   PNG_TEXT_COMPRESSION_zTXt.

	   num_text	  - number of comments

	   png_set_sPLT(png_ptr, info_ptr, &palette_ptr,
	      num_spalettes);

	   palette_ptr	  - array of png_sPLT_struct structures
			    to be added	to the list of palettes
			    in the info	structure.
	   num_spalettes  - number of palette structures to be
			    added.

	   png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y,
	       unit_type);

	   offset_x  - positive	offset from the	left
			    edge of the	screen

	   offset_y  - positive	offset from the	top
			    edge of the	screen

	   unit_type - PNG_OFFSET_PIXEL, PNG_OFFSET_MICROMETER

	   png_set_pHYs(png_ptr, info_ptr, res_x, res_y,
	       unit_type);

	   res_x       - pixels/unit physical resolution
			 in x direction

	   res_y       - pixels/unit physical resolution
			 in y direction

	   unit_type   - PNG_RESOLUTION_UNKNOWN,
			 PNG_RESOLUTION_METER

	   png_set_sCAL(png_ptr, info_ptr, unit, width,	height)

	   unit	       - physical scale	units (an integer)

	   width       - width of a pixel in physical scale units

	   height      - height	of a pixel in physical scale units
			 (width	and height are doubles)

	   png_set_sCAL_s(png_ptr, info_ptr, unit, width, height)

	   unit	       - physical scale	units (an integer)

	   width       - width of a pixel in physical scale units
			 expressed as a	string

	   height      - height	of a pixel in physical scale units
			(width and height are strings like "2.54")

	   png_set_unknown_chunks(png_ptr, info_ptr, &unknowns,
	      num_unknowns)

	   unknowns	     - array of	png_unknown_chunk
			       structures holding unknown chunks
	   unknowns[i].name  - name of unknown chunk
	   unknowns[i].data  - data of unknown chunk
	   unknowns[i].size  - size of unknown chunk's data
	   unknowns[i].location	- position to write chunk in file
				  0: do	not write chunk
				  PNG_HAVE_IHDR: before	PLTE
				  PNG_HAVE_PLTE: before	IDAT
				  PNG_AFTER_IDAT: after	IDAT

       The "location" member is	set automatically according to	what  part  of
       the output file has already been	written.  You can change its value af-
       ter calling  png_set_unknown_chunks()  as  demonstrated	in  pngtest.c.
       Within  each  of	the "locations", the chunks are	sequenced according to
       their position in the structure (that is, the value of  "i",  which  is
       the order in which the chunk was	either read from the input file	or de-
       fined with png_set_unknown_chunks).

       A quick word about text and num_text.  text is  an  array  of  png_text
       structures.   num_text  is the number of	valid structures in the	array.
       Each png_text structure holds a language	code, a	keyword, a text	value,
       and a compression type.

       The  compression	 types	have the same valid numbers as the compression
       types of	the image data.	 Currently, the	only  valid  number  is	 zero.
       However,	 you  can store	text either compressed or uncompressed,	unlike
       images, which always have to be compressed.  So if you don't  want  the
       text compressed,	set the	compression type to PNG_TEXT_COMPRESSION_NONE.
       Because tEXt and	zTXt chunks don't have a language field, if you	 spec-
       ify PNG_TEXT_COMPRESSION_NONE or	PNG_TEXT_COMPRESSION_zTXt any language
       code or translated keyword will not be written out.

       Until text gets around a	few hundred bytes, it is not worth compressing
       it.   After  the	text has been written out to the file, the compression
       type  is	 set  to  PNG_TEXT_COMPRESSION_NONE_WR	or   PNG_TEXT_COMPRES-
       SION_zTXt_WR,  so  that	it isn't written out again at the end (in case
       you are calling png_write_end() with the	same struct).

       The keywords that are given in the PNG Specification are:

	   Title	    Short (one line) title or
			    caption for	image

	   Author	    Name of image's creator

	   Description	    Description	of image (possibly long)

	   Copyright	    Copyright notice

	   Creation Time    Time of original image creation
			    (usually RFC 1123 format, see below)

	   Software	    Software used to create the	image

	   Disclaimer	    Legal disclaimer

	   Warning	    Warning of nature of content

	   Source	    Device used	to create the image

	   Comment	    Miscellaneous comment; conversion
			    from other image format

       The keyword-text	pairs work like	this.  Keywords	should be short	simple
       descriptions  of	 what the comment is about.  Some typical keywords are
       found in	the PNG	specification, as is some recommendations on keywords.
       You can repeat keywords in a file.  You can even	write some text	before
       the image and some after.  For example, you may want to put a  descrip-
       tion  of	the image before the image, but	leave the disclaimer until af-
       ter, so viewers working over modem connections don't have to  wait  for
       the disclaimer to go over the modem before they start seeing the	image.
       Finally,	keywords should	be full	words,	not  abbreviations.   Keywords
       and  text  are in the ISO 8859-1	(Latin-1) character set	(a superset of
       regular ASCII) and can not contain NUL characters, and should not  con-
       tain  control  or  other	 unprintable characters.  To make the comments
       widely readable,	stick with basic ASCII,	 and  avoid  machine  specific
       character  set  extensions  like	the IBM-PC character set.  The keyword
       must be present,	but you	can leave off  the  text  string  on  non-com-
       pressed	pairs.	 Compressed pairs must have a text string, as only the
       text string is compressed anyway, so the	compression would be  meaning-
       less.

       PNG supports modification time via the png_time structure.  Two conver-
       sion routines are provided, png_convert_from_time_t()  for  time_t  and
       png_convert_from_struct_tm()  for  struct  tm.  The time_t routine uses
       gmtime().  You don't have to use	either of these, but if	 you  wish  to
       fill in the png_time structure directly,	you should provide the time in
       universal time (GMT) if possible	instead	of your	local time.  Note that
       the  year  number  is the full year (e.g. 1998, rather than 98 -	PNG is
       year 2000 compliant!), and that months start with 1.

       If you want to store the	time  of  the  original	 image	creation,  you
       should  use  a plain tEXt chunk with the	"Creation Time"	keyword.  This
       is necessary because the	"creation time"	of a  PNG  image  is  somewhat
       vague,  depending  on whether you mean the PNG file, the	time the image
       was created in a	non-PNG	format,	a still	photo from which the image was
       scanned,	or possibly the	subject	matter itself.	In order to facilitate
       machine-readable	dates, it is recommended that the "Creation Time" tEXt
       chunk  use RFC 1123 format dates	(e.g. "22 May 1997 18:07:10 GMT"), al-
       though this isn't a requirement.	 Unlike	the tIME chunk,	the  "Creation
       Time"  tEXt  chunk  is  not expected to be automatically	changed	by the
       software.  To facilitate	the use	of RFC 1123 dates, a function png_con-
       vert_to_rfc1123_buffer(buffer,  png_timep)  is provided to convert from
       PNG time	to an RFC 1123 format  string.	 The  caller  must  provide  a
       writeable buffer	of at least 29 bytes.

   Writing unknown chunks
       You  can	 use  the  png_set_unknown_chunks function to queue up private
       chunks for writing.  You	give it	a chunk	name, location,	raw data,  and
       a size.	You also must use png_set_keep_unknown_chunks()	to ensure that
       libpng will handle them.	 That's	all there is to	it.  The  chunks  will
       be   written   by   the	 next	following  png_write_info_before_PLTE,
       png_write_info, or png_write_end	function, depending upon the specified
       location.   Any	chunks	previously  read into the info structure's un-
       known-chunk list	will also be written out in a sequence that  satisfies
       the PNG specification's ordering	rules.

       Here is an example of writing two private chunks, prVt and miNE:

	   #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
	   /* Set unknown chunk	data */
	   png_unknown_chunk unk_chunk[2];
	   strcpy((char	*) unk_chunk[0].name, "prVt";
	   unk_chunk[0].data = (unsigned char *) "PRIVATE DATA";
	   unk_chunk[0].size = strlen(unk_chunk[0].data)+1;
	   unk_chunk[0].location = PNG_HAVE_IHDR;
	   strcpy((char	*) unk_chunk[1].name, "miNE";
	   unk_chunk[1].data = (unsigned char *) "MY CHUNK DATA";
	   unk_chunk[1].size = strlen(unk_chunk[0].data)+1;
	   unk_chunk[1].location = PNG_AFTER_IDAT;
	   png_set_unknown_chunks(write_ptr, write_info_ptr,
	       unk_chunk, 2);
	   /* Needed because miNE is not safe-to-copy */
	   png_set_keep_unknown_chunks(png, PNG_HANDLE_CHUNK_ALWAYS,
	      (png_bytep) "miNE", 1);
	   # if	PNG_LIBPNG_VER < 10600
	     /*	Deal with unknown chunk	location bug in	1.5.x and earlier */
	     png_set_unknown_chunk_location(png, info, 0, PNG_HAVE_IHDR);
	     png_set_unknown_chunk_location(png, info, 1, PNG_AFTER_IDAT);
	   # endif
	   # if	PNG_LIBPNG_VER < 10500
	     /*	 PNG_AFTER_IDAT	 writes	 two  copies  of  the  chunk  prior to
       libpng-1.5.0,
	      *	one before IDAT	and another after IDAT,	so don't use it;  only
       use
	      *	 PNG_HAVE_IHDR location.  This call resets the location	previ-
       ously
	      *	set by	assignment  and	 png_set_unknown_chunk_location()  for
       chunk 1.
	      */
	     png_set_unknown_chunk_location(png, info, 1, PNG_HAVE_IHDR);
	   # endif
	   #endif

   The high-level write	interface
       At  this	 point	there  are two ways to proceed;	through	the high-level
       write interface,	or through a sequence of low-level  write  operations.
       You  can	 use the high-level interface if your image data is present in
       the info	structure.  All	defined	output transformations are  permitted,
       enabled by the following	masks.

	   PNG_TRANSFORM_IDENTITY      No transformation
	   PNG_TRANSFORM_PACKING       Pack 1, 2 and 4-bit samples
	   PNG_TRANSFORM_PACKSWAP      Change order of packed
				       pixels to LSB first
	   PNG_TRANSFORM_INVERT_MONO   Invert monochrome images
	   PNG_TRANSFORM_SHIFT	       Normalize pixels	to the
				       sBIT depth
	   PNG_TRANSFORM_BGR	       Flip RGB	to BGR,	RGBA
				       to BGRA
	   PNG_TRANSFORM_SWAP_ALPHA    Flip RGBA to ARGB or GA
				       to AG
	   PNG_TRANSFORM_INVERT_ALPHA  Change alpha from opacity
				       to transparency
	   PNG_TRANSFORM_SWAP_ENDIAN   Byte-swap 16-bit	samples
	   PNG_TRANSFORM_STRIP_FILLER	     Strip out filler
					     bytes (deprecated).
	   PNG_TRANSFORM_STRIP_FILLER_BEFORE Strip out leading
					     filler bytes
	   PNG_TRANSFORM_STRIP_FILLER_AFTER  Strip out trailing
					     filler bytes

       If  you	have  valid  image  data  in  the  info	structure (you can use
       png_set_rows() to put image data	in  the	 info  structure),  simply  do
       this:

	   png_write_png(png_ptr, info_ptr, png_transforms, NULL)

       where  png_transforms  is  an integer containing	the bitwise OR of some
       set  of	 transformation	  flags.    This   call	  is   equivalent   to
       png_write_info(),  followed the set of transformations indicated	by the
       transform mask, then png_write_image(), and finally png_write_end().

       (The final parameter of this call is not	yet used.   Someday  it	 might
       point  to  transformation  parameters  required	by  some future	output
       transform.)

       You must	use png_transforms and not call	any png_set_transform()	 func-
       tions when you use png_write_png().

   The low-level write interface
       If  you	are  going  the	 low-level route instead, you are now ready to
       write all the file information up to the	actual	image  data.   You  do
       this with a call	to png_write_info().

	   png_write_info(png_ptr, info_ptr);

       Note  that  there  is  one  transformation  you	may  need to do	before
       png_write_info().  In PNG files,	the alpha channel in an	image  is  the
       level of	opacity.  If your data is supplied as a	level of transparency,
       you can invert the alpha	channel	before you write  it,  so  that	 0  is
       fully  transparent  and	255 (in	8-bit or paletted images) or 65535 (in
       16-bit images) is fully opaque, with

	   png_set_invert_alpha(png_ptr);

       This must appear	before png_write_info()	 instead  of  later  with  the
       other  transformations  because in the case of paletted images the tRNS
       chunk data has to be inverted before the	tRNS  chunk  is	 written.   If
       your  image is not a paletted image, the	tRNS data (which in such cases
       represents a single color to be rendered	as transparent)	won't need  to
       be  changed,  and  you  can  safely  do	this transformation after your
       png_write_info()	call.

       If you need to write a private chunk that you want to appear before the
       PLTE  chunk  when  PLTE	is  present, you can write the PNG info	in two
       steps, and insert code to write your own	chunk between them:

	   png_write_info_before_PLTE(png_ptr, info_ptr);
	   png_set_unknown_chunks(png_ptr, info_ptr, ...);
	   png_write_info(png_ptr, info_ptr);

       After you've written the	file information, you can set up  the  library
       to  handle  any special transformations of the image data.  The various
       ways to transform the data will be described in	the  order  that  they
       should  occur.	This  is  important, as	some of	these change the color
       type and/or bit depth of	the data, and some others only work on certain
       color  types and	bit depths.  Even though each transformation checks to
       see if it has data that it can do something with, you should make  sure
       to  only	enable a transformation	if it will be valid for	the data.  For
       example,	don't swap red and blue	on grayscale data.

       PNG files store RGB pixels packed into 3	or 6 bytes.  This  code	 tells
       the library to strip input data that has	4 or 8 bytes per pixel down to
       3 or 6 bytes (or	strip 2	or 4-byte grayscale+filler  data  to  1	 or  2
       bytes per pixel).

	   png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);

       where  the 0 is unused, and the location	is either PNG_FILLER_BEFORE or
       PNG_FILLER_AFTER, depending upon	whether	the filler byte	in  the	 pixel
       is stored XRGB or RGBX.

       PNG  files pack pixels of bit depths 1, 2, and 4	into bytes as small as
       they can, resulting in, for example, 8 pixels per byte for 1 bit	files.
       If  the data is supplied	at 1 pixel per byte, use this code, which will
       correctly pack the pixels into a	single byte:

	   png_set_packing(png_ptr);

       PNG files reduce	possible bit depths to 1, 2, 4,	8, and	16.   If  your
       data is of another bit depth, you can write an sBIT chunk into the file
       so that decoders	can recover the	original data if desired.

	   /* Set the true bit depth of	the image data */
	   if (color_type & PNG_COLOR_MASK_COLOR)
	   {
	      sig_bit.red = true_bit_depth;
	      sig_bit.green = true_bit_depth;
	      sig_bit.blue = true_bit_depth;
	   }

	   else
	   {
	      sig_bit.gray = true_bit_depth;
	   }

	   if (color_type & PNG_COLOR_MASK_ALPHA)
	   {
	      sig_bit.alpha = true_bit_depth;
	   }

	   png_set_sBIT(png_ptr, info_ptr, &sig_bit);

       If the data is stored in	the row	buffer in a bit	depth other  than  one
       supported  by  PNG  (e.g. 3 bit data in the range 0-7 for a 4-bit PNG),
       this will scale the values to appear to be the correct bit depth	as  is
       required	by PNG.

	   png_set_shift(png_ptr, &sig_bit);

       PNG  files  store  16-bit pixels	in network byte	order (big-endian, ie.
       most significant	bits first).  This code	would be used if they are sup-
       plied  the other	way (little-endian, i.e. least significant bits	first,
       the way PCs store them):

	   if (bit_depth > 8)
	      png_set_swap(png_ptr);

       If you are using	packed-pixel images (1,	2, or 4	bits/pixel),  and  you
       need to change the order	the pixels are packed into bytes, you can use:

	   if (bit_depth < 8)
	      png_set_packswap(png_ptr);

       PNG  files  store  3 color pixels in red, green,	blue order.  This code
       would be	used if	they are supplied as blue, green, red:

	   png_set_bgr(png_ptr);

       PNG files describe monochrome as	black being zero and white being  one.
       This  code  would be used if the	pixels are supplied with this reversed
       (black being one	and white being	zero):

	   png_set_invert_mono(png_ptr);

       Finally,	you can	write your own transformation function if none of  the
       existing	 ones  meets  your  needs.  This is done by setting a callback
       with

	   png_set_write_user_transform_fn(png_ptr,
	      write_transform_fn);

       You must	supply the function

	   void	write_transform_fn(png_structp png_ptr,	png_row_infop
	      row_info,	png_bytep data)

       See pngtest.c for a working example.  Your function will	be called  be-
       fore  any  of  the  other  transformations are processed.  If supported
       libpng also supplies an information routine that	 may  be  called  from
       your callback:

	  png_get_current_row_number(png_ptr);
	  png_get_current_pass_number(png_ptr);

       This  returns the current row passed to the transform.  With interlaced
       images the value	returned is the	row in the input sub-image image.  Use
       PNG_ROW_FROM_PASS_ROW(row,  pass)  and PNG_COL_FROM_PASS_COL(col, pass)
       to find the output pixel	(x,y)  given  an  interlaced  sub-image	 pixel
       (row,col,pass).

       The discussion of interlace handling above contains more	information on
       how to use these	values.

       You can also set	up a pointer to	a user structure for use by your call-
       back function.

	   png_set_user_transform_info(png_ptr,	user_ptr, 0, 0);

       The  user_channels  and	user_depth parameters of this function are ig-
       nored when writing; you can set them to zero as shown.

       You can retrieve	 the  pointer  via  the	 function  png_get_user_trans-
       form_ptr().  For	example:

	   voidp write_user_transform_ptr =
	      png_get_user_transform_ptr(png_ptr);

       It  is  possible	 to have libpng	flush any pending output, either manu-
       ally, or	automatically after a certain number of	lines have been	 writ-
       ten.  To	flush the output stream	a single time call:

	   png_write_flush(png_ptr);

       and to have libpng flush	the output stream periodically after a certain
       number of scanlines have	been written, call:

	   png_set_flush(png_ptr, nrows);

       Note  that  the	distance  between  rows	 is   from   the   last	  time
       png_write_flush()  was  called, or the first row	of the image if	it has
       never been called.  So if you write 50 lines,  and  then	 png_set_flush
       25,  it	will flush the output on the next scanline, and	every 25 lines
       thereafter, unless png_write_flush() is called  before  25  more	 lines
       have been written.  If nrows is too small (less than about 10 lines for
       a 640 pixel wide	RGB image) the image compression may decrease  notice-
       ably (although this may be acceptable for real-time applications).  In-
       frequent	flushing will only degrade the compression  performance	 by  a
       few percent over	images that do not use flushing.

   Writing the image data
       That's  it  for the transformations.  Now you can write the image data.
       The simplest way	to do this is in one function call.  If	you  have  the
       whole  image  in	memory,	you can	just call png_write_image() and	libpng
       will write the image.  You will need to pass in an array	of pointers to
       each  row.   This  function  automatically  handles interlacing,	so you
       don't need to call png_set_interlace_handling() or call	this  function
       multiple	  times,   or	any   of   that	 other	stuff  necessary  with
       png_write_rows().

	   png_write_image(png_ptr, row_pointers);

       where row_pointers is:

	   png_byte *row_pointers[height];

       You can point to	void or	char or	whatever you use for pixels.

       If you don't want to write  the	whole  image  at  once,	 you  can  use
       png_write_rows()	 instead.  If the file is not interlaced, this is sim-
       ple:

	   png_write_rows(png_ptr, row_pointers,
	      number_of_rows);

       row_pointers is the same	as in the png_write_image() call.

       If you are just writing one row at a time, you can do this with a  sin-
       gle row_pointer instead of an array of row_pointers:

	   png_bytep row_pointer = row;

	   png_write_row(png_ptr, row_pointer);

       When  the  file	is interlaced, things can get a	good deal more compli-
       cated.  The only	currently (as of the PNG  Specification	 version  1.2,
       dated  July  1999)  defined  interlacing	 scheme	 for  PNG files	is the
       "Adam7" interlace scheme, that breaks down an image into	seven  smaller
       images of varying size.	libpng will build these	images for you,	or you
       can do them yourself.  If you want to build them	yourself, see the  PNG
       specification for details of which pixels to write when.

       If  you	don't  want libpng to handle the interlacing details, just use
       png_set_interlace_handling() and	call png_write_rows() the correct num-
       ber  of times to	write all the sub-images (png_set_interlace_handling()
       returns the number of sub-images.)

       If you want libpng to build the sub-images, call	this before you	 start
       writing any rows:

	   number_of_passes = png_set_interlace_handling(png_ptr);

       This  will  return  the	number	of  passes needed.  Currently, this is
       seven, but may change if	another	interlace type is added.

       Then write the complete image number_of_passes times.

	   png_write_rows(png_ptr, row_pointers, number_of_rows);

       Think carefully before you write	an interlaced image.   Typically  code
       that  reads  such  images  reads	all the	image data into	memory,	uncom-
       pressed,	before doing any processing.  Only code	that  can  display  an
       image  on  the  fly can take advantage of the interlacing and even then
       the image has to	be exactly the correct size for	the output device, be-
       cause  scaling  an  image  requires  adjacent  pixels and these are not
       available until all the passes have been	read.

       If you do write an interlaced image you will hardly ever	need to	handle
       the  interlacing	 yourself.   Call png_set_interlace_handling() and use
       the approach described above.

       The only	time it	is conceivable that you	will really need to  write  an
       interlaced  image  pass-by-pass	is when	you have read one pass by pass
       and made	some pixel-by-pixel transformation to it, as described in  the
       read  code above.  In this case use the PNG_PASS_ROWS and PNG_PASS_COLS
       macros to determine the size of each sub-image in turn and simply write
       the rows	you obtained from the read code.

   Finishing a sequential write
       After you are finished writing the image, you should finish writing the
       file.  If you are interested in writing comments	or  time,  you	should
       pass  an	 appropriately filled png_info pointer.	 If you	are not	inter-
       ested, you can pass NULL.

	   png_write_end(png_ptr, info_ptr);

       When you	are done, you can free all memory used by libpng like this:

	   png_destroy_write_struct(&png_ptr, &info_ptr);

       It is also possible to individually  free  the  info_ptr	 members  that
       point to	libpng-allocated storage with the following function:

	   png_free_data(png_ptr, info_ptr, mask, seq)

	   mask	 - identifies data to be freed,	a mask
		   containing the bitwise OR of	one or
		   more	of
		     PNG_FREE_PLTE, PNG_FREE_TRNS,
		     PNG_FREE_HIST, PNG_FREE_ICCP,
		     PNG_FREE_PCAL, PNG_FREE_ROWS,
		     PNG_FREE_SCAL, PNG_FREE_SPLT,
		     PNG_FREE_TEXT, PNG_FREE_UNKN,
		   or simply PNG_FREE_ALL

	   seq	 - sequence number of item to be freed
		   (-1 for all items)

       This  function  may  be safely called when the relevant storage has al-
       ready been freed, or has	not yet	been allocated,	or  was	 allocated  by
       the  user  and not by libpng,  and will in those	cases do nothing.  The
       "seq" parameter is ignored if only one item of the selected data	 type,
       such  as	 PLTE, is allowed.  If "seq" is	not -1,	and multiple items are
       allowed for the data type identified in the mask, such as text or sPLT,
       only the	n'th item in the structure is freed, where n is	"seq".

       If  you	allocated  data	such as	a palette that you passed in to	libpng
       with png_set_*, you must	not free it until  just	 before	 the  call  to
       png_destroy_write_struct().

       The default behavior is only to free data that was allocated internally
       by libpng.  This	can be changed,	so that	libpng will not	free the data,
       or  so  that  it	 will  free  data  that	was allocated by the user with
       png_malloc() or png_calloc() and	passed in via a	png_set_*()  function,
       with

	   png_data_freer(png_ptr, info_ptr, freer, mask)

	   freer  - one	of
		      PNG_DESTROY_WILL_FREE_DATA
		      PNG_SET_WILL_FREE_DATA
		      PNG_USER_WILL_FREE_DATA

	   mask	  - which data elements	are affected
		    same choices as in png_free_data()

       For  example,  to  transfer  responsibility  for	 some data from	a read
       structure to a write structure, you could use

	   png_data_freer(read_ptr, read_info_ptr,
	      PNG_USER_WILL_FREE_DATA,
	      PNG_FREE_PLTE|PNG_FREE_tRNS|PNG_FREE_hIST)

	   png_data_freer(write_ptr, write_info_ptr,
	      PNG_DESTROY_WILL_FREE_DATA,
	      PNG_FREE_PLTE|PNG_FREE_tRNS|PNG_FREE_hIST)

       thereby briefly reassigning responsibility for freeing to the user  but
       immediately  afterwards	reassigning  it	once more to the write_destroy
       function.  Having done this, it would then be safe to destroy the  read
       structure  and  continue	 to  use  the PLTE, tRNS, and hIST data	in the
       write structure.

       This function only affects data that has	already	been  allocated.   You
       can  call  this function	before calling after the png_set_*() functions
       to control whether the user or png_destroy_*() is supposed to free  the
       data.   When the	user assumes responsibility for	libpng-allocated data,
       the application must use	png_free() to  free  it,  and  when  the  user
       transfers  responsibility  to  libpng  for data that the	user has allo-
       cated, the user must have used png_malloc() or png_calloc() to allocate
       it.

       If  you	allocated  text_ptr.text,  text_ptr.lang,  and text_ptr.trans-
       lated_keyword separately, do not	transfer  responsibility  for  freeing
       text_ptr	 to  libpng, because when libpng fills a png_text structure it
       combines	these members with the key member,  and	 png_free_data()  will
       free  only text_ptr.key.	 Similarly, if you transfer responsibility for
       free'ing	text_ptr from libpng to	 your  application,  your  application
       must  not separately free those members.	 For a more compact example of
       writing a PNG image, see	the file example.c.

V. Simplified API
       The simplified API, which became	available in libpng-1.6.0,  hides  the
       details	of  both libpng	and the	PNG file format	itself.	 It allows PNG
       files to	be read	into a very limited number of in-memory	bitmap formats
       or to be	written	from the same formats.	If these formats do not	accom-
       modate your needs then you can, and should, use the more	 sophisticated
       APIs  above  -  these support a wide variety of in-memory formats and a
       wide variety of sophisticated transformations to	those formats as  well
       as a wide variety of APIs to manipulate ancilliary information.

       To read a PNG file using	the simplified API:

	 1) Declare a 'png_image' structure (see below)	on the stack, set the
	    version  field  to	PNG_IMAGE_VERSION  and the 'opaque' pointer to
       NULL
	    (this is REQUIRED, your program may	crash if you don't do it.)

	 2) Call the appropriate png_image_begin_read... function.

	 3) Set	the png_image 'format' member to the required sample format.

	 4) Allocate a buffer for the image and, if required, the color-map.

	 5) Call png_image_finish_read to read the image and, if required, the
	    color-map into your	buffers.

       There are no restrictions on the	format of the PNG  input  itself;  all
       valid  color  types,  bit depths, and interlace methods are acceptable,
       and the input image is transformed as necessary to  the	requested  in-
       memory format during the	png_image_finish_read()	step.  The only	caveat
       is that if you request a	color-mapped image from	a PNG  that  is	 full-
       color  or  makes	 complex use of	an alpha channel the transformation is
       extremely lossy and the result may look terrible.

       To write	a PNG file using the simplified	API:

	 1) Declare a 'png_image' structure on the stack and memset()
	    it to all zero.

	 2) Initialize the members of the structure that describe the
	    image, setting the 'format'	member to the format of	the
	    image samples.

	 3) Call the appropriate png_image_write... function with a
	    pointer to the image and, if necessary, the	color-map to write
	    the	PNG data.

       png_image is a structure	that describes the in-memory format of an  im-
       age  when  it is	being read or defines the in-memory format of an image
       that you	need to	write.	The "png_image"	structure contains the follow-
       ing members:

	  png_controlp opaque  Initialize to NULL, free	with png_image_free
	  png_uint_32  version Set to PNG_IMAGE_VERSION
	  png_uint_32  width   Image width in pixels (columns)
	  png_uint_32  height  Image height in pixels (rows)
	  png_uint_32  format  Image format as defined below
	  png_uint_32  flags   A bit mask containing informational flags
	  png_uint_32  colormap_entries; Number	of entries in the color-map
	  png_uint_32  warning_or_error;
	  char	       message[64];

       In  the	event of an error or warning the "warning_or_error" field will
       be set to a non-zero value and the 'message' field will contain	a  ' '
       terminated  string  with	 the libpng error or warning message.  If both
       warnings	and an error were encountered, only the	error is recorded.  If
       there are multiple warnings, only the first one is recorded.

       The upper 30 bits of the	"warning_or_error" value are reserved; the low
       two bits	contain	a two bit code such that a value more than 1 indicates
       a failure in the	API just called:

	  0 - no warning or error
	  1 - warning
	  2 - error
	  3 - error preceded by	warning

       The  pixels (samples) of	the image have one to four channels whose com-
       ponents have original values in the range 0 to 1.0:

	 1: A single gray or luminance channel (G).
	 2: A gray/luminance channel and an alpha channel (GA).
	 3: Three red, green, blue color channels (RGB).
	 4: Three color	channels and an	alpha channel (RGBA).

       The channels are	encoded	in one of two ways:

	 a) As a small integer,	value 0..255, contained	in a single byte.  For
       the  alpha  channel  the	 original  value is simply value/255.  For the
       color or	luminance channels the value is	encoded	according to the  sRGB
       specification  and matches the 8-bit format expected by typical display
       devices.

       The color/gray channels are not scaled (pre-multiplied)	by  the	 alpha
       channel and are suitable	for passing to color management	software.

	 b)  As	 a value in the	range 0..65535,	contained in a 2-byte integer,
       in the native byte order	of the platform	on which  the  application  is
       running.	 All channels can be converted to the original value by	divid-
       ing by 65535; all channels are linear.  Color channels use the RGB  en-
       coding  (RGB  end-points)  of the sRGB specification.  This encoding is
       identified by the PNG_FORMAT_FLAG_LINEAR	flag below.

       When the	simplified API needs to	convert	between	sRGB and  linear  col-
       orspaces, the actual sRGB transfer curve	defined	in the sRGB specifica-
       tion (see the article at	 http://en.wikipedia.org/wiki/SRGB)  is	 used,
       not the gamma=1/2.2 approximation used elsewhere	in libpng.

       When  an	alpha channel is present it is expected	to denote pixel	cover-
       age of the color	or luminance channels and is returned as an associated
       alpha  channel:	the color/gray channels	are scaled (pre-multiplied) by
       the alpha value.

       The samples are either contained	directly in the	image data, between  1
       and  8  bytes  per  pixel  according  to	the encoding, or are held in a
       color-map indexed by bytes in the image data.  In the case of a	color-
       map the color-map entries are individual	samples, encoded as above, and
       the image data has one byte per pixel to	 select	 the  relevant	sample
       from the	color-map.

       PNG_FORMAT_*

       The  #defines to	be used	in png_image::format.  Each #define identifies
       a particular layout of channel data  and,  if  present,	alpha  values.
       There are separate defines for each of the two component	encodings.

       A  format  is  built up using single bit	flag values.  All combinations
       are valid.  Formats can be built	up from	the flag values	or you can use
       one  of	the  predefined	values below.  When testing formats always use
       the FORMAT_FLAG macros to test for individual features  -  future  ver-
       sions of	the library may	add new	flags.

       When reading or writing color-mapped images the format should be	set to
       the  format  of	 the   entries	 in   the   color-map	then   png_im-
       age_{read,write}_colormap called	to read	or write the color-map and set
       the format correctly for	the image  data.   Do  not  set	 the  PNG_FOR-
       MAT_FLAG_COLORMAP bit directly!

       NOTE: libpng can	be built with particular features disabled. If you see
       compiler	errors because the definition of one of	 the  following	 flags
       has  been  compiled out it is because libpng does not have the required
       support.	 It is possible, however, for the libpng configuration to  en-
       able the	format on just read or just write; in that case	you may	see an
       error at	run time.  You can guard against this by checking for the def-
       inition of the appropriate "_SUPPORTED" macro, one of:

	  PNG_SIMPLIFIED_{READ,WRITE}_{BGR,AFIRST}_SUPPORTED

	  PNG_FORMAT_FLAG_ALPHA	   format with an alpha	channel
	  PNG_FORMAT_FLAG_COLOR	   color format: otherwise grayscale
	  PNG_FORMAT_FLAG_LINEAR   2-byte channels else	1-byte
	  PNG_FORMAT_FLAG_COLORMAP image data is color-mapped
	  PNG_FORMAT_FLAG_BGR	   BGR colors, else order is RGB
	  PNG_FORMAT_FLAG_AFIRST   alpha channel comes first

       Supported  formats  are as follows.  Future versions of libpng may sup-
       port more formats; for compatibility with older versions	 simply	 check
       if  the	format	macro is defined using #ifdef.	These defines describe
       the in-memory layout of the components of the pixels of the image.

       First the single	byte (sRGB) formats:

	  PNG_FORMAT_GRAY
	  PNG_FORMAT_GA
	  PNG_FORMAT_AG
	  PNG_FORMAT_RGB
	  PNG_FORMAT_BGR
	  PNG_FORMAT_RGBA
	  PNG_FORMAT_ARGB
	  PNG_FORMAT_BGRA
	  PNG_FORMAT_ABGR

       Then the	linear 2-byte formats.	When naming these "Y" is used to indi-
       cate  a luminance (gray)	channel.  The component	order within the pixel
       is always the same - there is no	provision for swapping	the  order  of
       the  components	in the linear format.  The components are 16-bit inte-
       gers in the native byte order for your platform,	and there is no	provi-
       sion for	swapping the bytes to a	different endian condition.

	  PNG_FORMAT_LINEAR_Y
	  PNG_FORMAT_LINEAR_Y_ALPHA
	  PNG_FORMAT_LINEAR_RGB
	  PNG_FORMAT_LINEAR_RGB_ALPHA

       With  color-mapped  formats  the	image data is one byte for each	pixel.
       The byte	is an index into the color-map which is	 formatted  as	above.
       To  obtain  a  color-mapped  format  it	is  sufficient just to add the
       PNG_FOMAT_FLAG_COLORMAP to one of the above definitions,	or you can use
       one of the definitions below.

	  PNG_FORMAT_RGB_COLORMAP
	  PNG_FORMAT_BGR_COLORMAP
	  PNG_FORMAT_RGBA_COLORMAP
	  PNG_FORMAT_ARGB_COLORMAP
	  PNG_FORMAT_BGRA_COLORMAP
	  PNG_FORMAT_ABGR_COLORMAP

       PNG_IMAGE macros

       These  are  convenience	macros	to derive information from a png_image
       structure.  The PNG_IMAGE_SAMPLE_ macros	return values  appropriate  to
       the actual image	sample values -	either the entries in the color-map or
       the pixels in the image.	 The  PNG_IMAGE_PIXEL_	macros	return	corre-
       sponding	 values	 for  the  pixels  and will always return 1 for	color-
       mapped formats.	The remaining macros return information	about the rows
       in the image and	the complete image.

       NOTE:  All  the macros that take	a png_image::format parameter are com-
       pile time constants if the format parameter  is,	 itself,  a  constant.
       Therefore  these	 macros	can be used in array declarations and case la-
       bels where required.  Similarly the macros are also pre-processor  con-
       stants (sizeof is not used) so they can be used in #if tests.

	 PNG_IMAGE_SAMPLE_CHANNELS(fmt)
	   Returns the total number of channels	in a given format: 1..4

	 PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt)
	   Returns  the	 size  in  bytes  of  a	single component of a pixel or
       color-map
	   entry (as appropriate) in the image:	1 or 2.

	 PNG_IMAGE_SAMPLE_SIZE(fmt)
	   This	is the size of the sample data for one sample.	If  the	 image
       is
	   color-mapped	 it is the size	of one color-map entry (and image pix-
       els are
	   one byte in size), otherwise	it is the size of one image pixel.

	 PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(fmt)
	   The maximum size of the color-map required by the format  expressed
       in a
	   count of components.	 This can be used to compile-time allocate a
	   color-map:

	   png_uint_16	   colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(lin-
       ear_fmt)];

	   png_byte colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(sRGB_fmt)];

	   Alternatively use the PNG_IMAGE_COLORMAP_SIZE macro	below  to  use
       the
	   information	from one of the	png_image_begin_read_ APIs and dynami-
       cally
	   allocate the	required memory.

	 PNG_IMAGE_COLORMAP_SIZE(fmt)
	  The size of the color-map required by	the format; this is  the  size
       of the
	  color-map buffer passed to the png_image_{read,write}_colormap APIs.
       It is
	  a fixed number determined by the format so can easily	 be  allocated
       on the
	  stack	if necessary.

       Corresponding information about the pixels

	 PNG_IMAGE_PIXEL_CHANNELS(fmt)
	  The number of	separate channels (components) in a pixel; 1 for a
	  color-mapped image.

	 PNG_IMAGE_PIXEL_COMPONENT_SIZE(fmt)	The  size,  in	bytes, of each
       component in a pixel; 1 for a color-mapped
	  image.

	 PNG_IMAGE_PIXEL_SIZE(fmt)
	  The size, in bytes, of a complete pixel; 1 for a color-mapped	image.

       Information about the whole row,	or whole image

	 PNG_IMAGE_ROW_STRIDE(image)
	  Returns the total number of components in a single row of the	image;
       this
	  is the minimum 'row stride', the minimum count of components between
       each
	  row.	For a color-mapped image this is the minimum number  of	 bytes
       in a
	  row.

	  If you need the stride measured in bytes, row_stride_bytes is
	  PNG_IMAGE_ROW_STRIDE(image) *	PNG_IMAGE_PIXEL_COMPONENT_SIZE(fmt)
	  plus any padding bytes that your application might need, for example
	  to start the next row	on a 4-byte boundary.

	 PNG_IMAGE_BUFFER_SIZE(image, row_stride)
	  Return  the size, in bytes, of an image buffer given a png_image and
       a row
	  stride - the number of components to leave space for in each row.

	 PNG_IMAGE_SIZE(image)
	  Return the size, in bytes, of	the  image  in	memory	given  just  a
       png_image;
	  the row stride is the	minimum	stride required	for the	image.

	 PNG_IMAGE_COLORMAP_SIZE(image)
	  Return  the  size, in	bytes, of the color-map	of this	image.	If the
       image
	  format is not	a color-map format this	will return a size  sufficient
       for
	  256 entries in the given format; check PNG_FORMAT_FLAG_COLORMAP if
	  you don't want to allocate a color-map in this case.

       PNG_IMAGE_FLAG_*

       Flags containing	additional information about the image are held	in the
       'flags' field of	png_image.

	 PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB == 0x01
	   This	indicates the the RGB values of	the in-memory bitmap do	not
	   correspond to the red, green	and blue end-points defined by sRGB.

	 PNG_IMAGE_FLAG_FAST ==	0x02
	  On write emphasise speed over	compression; the  resultant  PNG  file
       will be
	  larger  but  will  be	 produced significantly	faster,	particular for
       large
	  images.  Do not use this option for images which  will  be  distrib-
       uted, only
	  used it when producing intermediate files that will be read back in
	  repeatedly.	For  a typical 24-bit image the	option will double the
       read
	  speed	at the cost of increasing the image size by 25%,  however  for
       many
	  more	compressible  images  the PNG file can be 10 times larger with
       only a
	  slight speed gain.

	 PNG_IMAGE_FLAG_16BIT_sRGB == 0x04
	   On read if the image	is a 16-bit per	component image	and  there  is
       no gAMA
	   or  sRGB chunk assume that the components are sRGB encoded.	Notice
       that
	   images output by the	simplified API always have gamma  information;
       setting
	   this	flag only affects the interpretation of	16-bit images from an
	   external  source.   It  is  recommended that	the application	expose
       this flag
	   to the user;	the user can normally easily recognize the  difference
       between
	   linear  and	sRGB encoding.	This flag has no effect	on write - the
       data
	   passed to the write APIs must have the correct encoding (as defined
	   above.)

	   If the flag is not set (the default)	 input	16-bit	per  component
       data is
	   assumed to be linear.

	   NOTE:  the  flag  can  only	be set after the png_image_begin_read_
       call,
	   because that	call initializes the 'flags' field.

       READ APIs

	  The png_image	passed to the read APIs	must have been initialized  by
       setting
	  the  png_controlp  field  'opaque'  to  NULL (or, better, memset the
       whole thing.)

	  int png_image_begin_read_from_file( png_imagep image,
	    const char *file_name)

	    The	named file is opened for read and the image header
	    is filled in from the PNG header in	the file.

	  int png_image_begin_read_from_stdio (png_imagep image,
	    FILE* file)

	     The PNG header is read from the stdio FILE	object.

	  int png_image_begin_read_from_memory(png_imagep image,
	     png_const_voidp memory, png_size_t	size)

	     The PNG header is read from the given memory buffer.

	  int png_image_finish_read(png_imagep image,
	     png_colorp	background, void *buffer,
	     png_int_32	row_stride, void *colormap));

	     Finish reading the	image into the supplied	buffer and
	     clean up the png_image structure.

	     row_stride	is the step, in	png_byte or png_uint_16	units
	     as	appropriate, between adjacent rows.  A positive	stride
	     indicates that the	top-most row is	first in the buffer -
	     the normal	top-down arrangement.  A negative stride
	     indicates that the	bottom-most row	is first in the	buffer.

	     background	need only be supplied if an alpha channel must
	     be	removed	from a png_byte	format and the removal is to be
	     done by compositing on a solid color; otherwise it	may be
	     NULL and any composition will be done directly onto the
	     buffer.  The value	is an sRGB color to use	for the
	     background, for grayscale output the green	channel	is used.

	     For linear	output removing	the alpha channel is always done
	     by	compositing on black.

	  void png_image_free(png_imagep image)

	     Free any data allocated by	libpng in image->opaque,
	     setting the pointer to NULL.  May be called at any	time
	     after the structure is initialized.

       When the	simplified API needs to	convert	between	sRGB and  linear  col-
       orspaces, the actual sRGB transfer curve	defined	in the sRGB specifica-
       tion (see the article at	 http://en.wikipedia.org/wiki/SRGB)  is	 used,
       not the gamma=1/2.2 approximation used elsewhere	in libpng.

       WRITE APIS

       For write you must initialize a png_image structure to describe the im-
       age to be written:

	  version: must	be set to PNG_IMAGE_VERSION
	  opaque: must be initialized to NULL
	  width: image width in	pixels
	  height: image	height in rows
	  format: the format of	the data you wish to write
	  flags: set to	0 unless one of	the defined flags applies; set
	     PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB	for color format images
	     where the RGB values do not correspond to the colors in sRGB.
	  colormap_entries: set	to the number of entries in the	 color-map  (0
       to 256)

	  int png_image_write_to_file, (png_imagep image,
	     const char	*file, int convert_to_8bit, const void *buffer,
	     png_int_32	row_stride, const void *colormap));

	     Write the image to	the named file.

	  int png_image_write_to_memory	(png_imagep image, void	*memory,
	     png_alloc_size_t *	PNG_RESTRICT memory_bytes,
	     int convert_to_8_bit, const void *buffer, ptrdiff_t row_stride,
	     const void	*colormap));

	     Write the image to	memory.

	  int png_image_write_to_stdio(png_imagep image, FILE *file,
	     int convert_to_8_bit, const void *buffer,
	     png_int_32	row_stride, const void *colormap)

	     Write the image to	the given (FILE*).

       With  all  write	 APIs  if  image  is in	one of the linear formats with
       (png_uint_16) data then setting convert_to_8_bit	will cause the	output
       to  be  a (png_byte) PNG	gamma encoded according	to the sRGB specifica-
       tion, otherwise a 16-bit	linear encoded PNG file	is written.

       With all	APIs row_stride	is handled as in the read APIs	-  it  is  the
       spacing	from  one row to the next in component sized units (float) and
       if negative indicates a bottom-up row layout in	the  buffer.   If  you
       pass  zero, libpng will calculate the row_stride	for you	from the width
       and number of channels.

       Note that the write API does not	support	interlacing, sub-8-bit pixels,
       indexed (paletted) images, or most ancillary chunks.

VI. Modifying/Customizing libpng
       There are two issues here.  The first is	changing how libpng does stan-
       dard things like	memory allocation, input/output, and  error  handling.
       The  second  deals with more complicated	things like adding new chunks,
       adding new transformations, and generally changing  how	libpng	works.
       Both  of	those are compile-time issues; that is,	they are generally de-
       termined	at the time the	code is	written, and there is rarely a need to
       provide the user	with a means of	changing them.

       Memory allocation, input/output,	and error handling

       All  of	the  memory  allocation,  input/output,	 and error handling in
       libpng goes through callbacks that are user-settable.  The default rou-
       tines  are  in  pngmem.c,  pngrio.c,  pngwio.c, and pngerror.c, respec-
       tively.	To change these	functions, call	the appropriate	png_set_*_fn()
       function.

       Memory  allocation is done through the functions	png_malloc(), png_cal-
       loc(), and png_free().  The png_malloc()	and png_free() functions  cur-
       rently  just  call  the	standard  C  functions	and png_calloc() calls
       png_malloc() and	then clears the	newly allocated	memory to  zero;  note
       that  png_calloc(png_ptr,  size)	 is not	the same as the	calloc(number,
       size) function provided by stdlib.h.  There is limited support for cer-
       tain  systems  with  segmented  memory  architectures  and the types of
       pointers	declared by png.h match	this; you will have to use appropriate
       pointers	 in your application.  If you prefer to	use a different	method
       of allocating and freeing data, you can use  png_create_read_struct_2()
       or  png_create_write_struct_2()	to  register your own functions	as de-
       scribed above.  These functions also provide a void pointer that	can be
       retrieved via

	   mem_ptr=png_get_mem_ptr(png_ptr);

       Your replacement	memory functions must have prototypes as follows:

	   png_voidp malloc_fn(png_structp png_ptr,
	      png_alloc_size_t size);

	   void	free_fn(png_structp png_ptr, png_voidp ptr);

       Your malloc_fn()	must return NULL in case of failure.  The png_malloc()
       function	will normally call png_error() if it receives a	NULL from  the
       system memory allocator or from your replacement	malloc_fn().

       Your  free_fn()	will  never  be	called with a NULL ptr,	since libpng's
       png_free() checks for NULL before calling free_fn().

       Input/Output in libpng is  done	through	 png_read()  and  png_write(),
       which  currently	 just call fread() and fwrite().  The FILE * is	stored
       in png_struct and is initialized	via png_init_io().   If	 you  wish  to
       change  the  method of I/O, the library supplies	callbacks that you can
       set through the function	png_set_read_fn()  and	png_set_write_fn()  at
       run  time,  instead of calling the png_init_io()	function.  These func-
       tions also provide a void pointer that can be retrieved via  the	 func-
       tion png_get_io_ptr().  For example:

	   png_set_read_fn(png_structp read_ptr,
	       voidp read_io_ptr, png_rw_ptr read_data_fn)

	   png_set_write_fn(png_structp	write_ptr,
	       voidp write_io_ptr, png_rw_ptr write_data_fn,
	       png_flush_ptr output_flush_fn);

	   voidp read_io_ptr = png_get_io_ptr(read_ptr);
	   voidp write_io_ptr =	png_get_io_ptr(write_ptr);

       The replacement I/O functions must have prototypes as follows:

	   void	user_read_data(png_structp png_ptr,
	       png_bytep data, png_size_t length);

	   void	user_write_data(png_structp png_ptr,
	       png_bytep data, png_size_t length);

	   void	user_flush_data(png_structp png_ptr);

       The user_read_data() function is	responsible for	detecting and handling
       end-of-data errors.

       Supplying NULL for the read, write, or flush functions sets  them  back
       to  using  the  default	C stream functions, which expect the io_ptr to
       point to	a standard *FILE structure.  It	is probably a mistake  to  use
       NULL for	one of write_data_fn and output_flush_fn but not both of them,
       unless you have built libpng with PNG_NO_WRITE_FLUSH defined.  It is an
       error to	read from a write stream, and vice versa.

       Error handling in libpng	is done	through	png_error() and	png_warning().
       Errors handled through png_error() are fatal, meaning that  png_error()
       should  never  return  to  its  caller.	Currently, this	is handled via
       setjmp()	 and  longjmp()	 (unless  you  have   compiled	 libpng	  with
       PNG_NO_SETJMP,  in  which  case it is handled via PNG_ABORT()), but you
       could change this to do things like exit() if you should	wish, as  long
       as your function	does not return.

       On  non-fatal  errors,  png_warning() is	called to print	a warning mes-
       sage, and then control returns to the calling code.  By default png_er-
       ror()  and png_warning()	print a	message	on stderr via fprintf()	unless
       the library is compiled with  PNG_NO_CONSOLE_IO	defined	 (because  you
       don't  want  the	 messages)  or PNG_NO_STDIO defined (because fprintf()
       isn't available).  If you wish to change	 the  behavior	of  the	 error
       functions,  you	will need to set up your own message callbacks.	 These
       functions are normally supplied at the time that	the png_struct is cre-
       ated.   It is also possible to redirect errors and warnings to your own
       replacement functions after png_create_*_struct() has  been  called  by
       calling:

	   png_set_error_fn(png_structp	png_ptr,
	       png_voidp error_ptr, png_error_ptr error_fn,
	       png_error_ptr warning_fn);

	   png_voidp error_ptr = png_get_error_ptr(png_ptr);

       If  NULL	is supplied for	either error_fn	or warning_fn, then the	libpng
       default function	will be	used, calling fprintf()	and/or longjmp() if  a
       problem	is  encountered.   The replacement error functions should have
       parameters as follows:

	   void	user_error_fn(png_structp png_ptr,
	       png_const_charp error_msg);

	   void	user_warning_fn(png_structp png_ptr,
	       png_const_charp warning_msg);

       The motivation behind using setjmp() and	longjmp() is the C++ throw and
       catch  exception	 handling methods.  This makes the code	much easier to
       write, as there is no need to check every return	code of	every function
       call.   However,	there are some uncertainties about the status of local
       variables after a longjmp, so the user may want to be careful about do-
       ing  anything  after  setjmp returns non-zero besides returning itself.
       Consult your compiler documentation for more details.  For an  alterna-
       tive  approach,	you  may  wish	to  use	 the  "cexcept"	 facility (see
       http://cexcept.sourceforge.net),	which is illustrated in	pngvalid.c and
       in contrib/visupng.

       Beginning  in  libpng-1.4.0,  the  png_set_benign_errors()  API	became
       available.  You can use this to handle certain errors (normally handled
       as errors) as warnings.

	   png_set_benign_errors (png_ptr, int allowed);

	   allowed: 0: treat png_benign_error()	as an error.
		    1: treat png_benign_error()	as a warning.

       As  of libpng-1.6.0, the	default	condition is to	treat benign errors as
       warnings	while reading and as errors while writing.

   Custom chunks
       If you need to read or write custom chunks, you may need	to get	deeper
       into  the  libpng code.	The library now	has mechanisms for storing and
       writing chunks of unknown type; you can even declare callbacks for cus-
       tom  chunks.   However, this may	not be good enough if the library code
       itself needs to know about interactions between your chunk and existing
       `intrinsic' chunks.

       If you need to write a new intrinsic chunk, first read the PNG specifi-
       cation. Acquire a first level of	understanding of how  it  works.   Pay
       particular  attention  to  the  sections	that describe chunk names, and
       look at how other chunks	were designed, so you can do things similarly.
       Second,	check  out  the	sections of libpng that	read and write chunks.
       Try to find a chunk that	is similar to yours and	use it as a  template.
       More  details can be found in the comments inside the code.  It is best
       to handle private or unknown chunks in a	generic	method,	 via  callback
       functions,  instead  of	by  modifying libpng functions.	This is	illus-
       trated in pngtest.c, which uses a callback function to handle a private
       "vpAg"  chunk  and  the	new  "sTER"  chunk,  which are both unknown to
       libpng.

       If you wish to write your own transformation for	the data, look through
       the  part of the	code that does the transformations, and	check out some
       of the simpler ones to get an idea of how they work.   Try  to  find  a
       similar	transformation	to the one you want to add and copy off	of it.
       More details can	be found in the	comments inside	the code itself.

   Configuring for gui/windowing platforms:
       You will	need to	write new error	and warning functions that use the GUI
       interface,  as  described  previously, and set them to be the error and
       warning functions at the	time that png_create_*_struct()	is called,  in
       order to	have them available during the structure initialization.  They
       can be changed later via	png_set_error_fn().  On	 some  compilers,  you
       may also	have to	change the memory allocators (png_malloc, etc.).

   Configuring zlib:
       There  are special functions to configure the compression.  Perhaps the
       most useful one changes the compression level, which currently uses in-
       put  compression	 values	in the range 0 - 9.  The library normally uses
       the default compression level (Z_DEFAULT_COMPRESSION = 6).  Tests  have
       shown  that  for	 a large majority of images, compression values	in the
       range 3-6 compress nearly as well as higher  levels,  and  do  so  much
       faster.	 For  online  applications it may be desirable to have maximum
       speed (Z_BEST_SPEED = 1).  With versions	of zlib	after v0.99,  you  can
       also specify no compression (Z_NO_COMPRESSION = 0), but this would cre-
       ate files larger	than just storing the raw bitmap.  You can specify the
       compression level by calling:

	   #include zlib.h
	   png_set_compression_level(png_ptr, level);

       Another	useful	one is to reduce the memory level used by the library.
       The memory level	defaults to 8, but it can be lowered if	you are	 short
       on  memory  (running DOS, for example, where you	only have 640K).  Note
       that the	memory level does have an effect on compression;  among	 other
       things, lower levels will result	in sections of incompressible data be-
       ing emitted in smaller stored blocks,  with  a  correspondingly	larger
       relative	overhead of up to 15% in the worst case.

	   #include zlib.h
	   png_set_compression_mem_level(png_ptr, level);

       The other functions are for configuring zlib.  They are not recommended
       for normal use and may result in	writing	 an  invalid  PNG  file.   See
       zlib.h for more information on what these mean.

	   #include zlib.h
	   png_set_compression_strategy(png_ptr,
	       strategy);

	   png_set_compression_window_bits(png_ptr,
	       window_bits);

	   png_set_compression_method(png_ptr, method);

       This controls the size of the IDAT chunks (default 8192):

	   png_set_compression_buffer_size(png_ptr, size);

       As  of  libpng  version	1.5.4, additional APIs became available	to set
       these separately	for non-IDAT compressed	chunks such as zTXt, iTXt, and
       iCCP:

	   #include zlib.h
	   #if PNG_LIBPNG_VER >= 10504
	   png_set_text_compression_level(png_ptr, level);

	   png_set_text_compression_mem_level(png_ptr, level);

	   png_set_text_compression_strategy(png_ptr,
	       strategy);

	   png_set_text_compression_window_bits(png_ptr,
	       window_bits);

	   png_set_text_compression_method(png_ptr, method);
	   #endif

   Controlling row filtering
       If you want to control whether libpng uses filtering or not, which fil-
       ters are	used, and how it goes about picking row	filters, you can  call
       one of these functions.	The selection and configuration	of row filters
       can have	a significant impact on	the size  and  encoding	 speed	and  a
       somewhat	lesser impact on the decoding speed of an image.  Filtering is
       enabled by default for RGB and grayscale	images (with and  without  al-
       pha),  but  not	for paletted images nor	for any	images with bit	depths
       less than 8 bits/pixel.

       The 'method' parameter sets the main filtering method,  which  is  cur-
       rently  only '0'	in the PNG 1.2 specification.  The 'filters' parameter
       sets which filter(s), if	any, should be used for	each scanline.	Possi-
       ble  values are PNG_ALL_FILTERS,	PNG_NO_FILTERS,	or PNG_FAST_FILTERS to
       turn filtering on and off, or to	turn on	just the fast-decoding	subset
       of filters, respectively.

       Individual  filter  types are PNG_FILTER_NONE, PNG_FILTER_SUB, PNG_FIL-
       TER_UP, PNG_FILTER_AVG, PNG_FILTER_PAETH, which can be bitwise ORed to-
       gether  with  '|' to specify one	or more	filters	to use.	 These filters
       are described in	more detail in the PNG specification.  If  you	intend
       to  change  the filter type during the course of	writing	the image, you
       should start with flags set for all of the filters you intend to	use so
       that  libpng  can  initialize its internal structures appropriately for
       all of the filter types.	 (Note that this means the first row must  al-
       ways be adaptively filtered, because libpng currently does not allocate
       the filter buffers until	png_write_row()	is called for the first	time.)

	   filters = PNG_NO_FILTERS;
	   filters = PNG_ALL_FILTERS;
	   filters = PNG_FAST_FILTERS;

	   or

	   filters = PNG_FILTER_NONE | PNG_FILTER_SUB |
		     PNG_FILTER_UP | PNG_FILTER_AVG |
		     PNG_FILTER_PAETH;

	   png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE,
	      filters);

		     The second	parameter can also be
		     PNG_INTRAPIXEL_DIFFERENCING if you	are
		     writing a PNG to be embedded in a MNG
		     datastream.  This parameter must be the
		     same as the value of filter_method	used
		     in	png_set_IHDR().

   Requesting debug printout
       The macro definition PNG_DEBUG can be used to request debugging	print-
       out.   Set  it to an integer value in the range 0 to 3.	Higher numbers
       result in increasing amounts of debugging information.  The information
       is  printed to the "stderr" file, unless	another	file name is specified
       in the PNG_DEBUG_FILE macro definition.

       When PNG_DEBUG >	0, the following functions (macros) become available:

	  png_debug(level, message)
	  png_debug1(level, message, p1)
	  png_debug2(level, message, p1, p2)

       in which	"level"	is compared to PNG_DEBUG to decide  whether  to	 print
       the  message,  "message"	 is the	formatted string to be printed,	and p1
       and p2 are parameters that are to be embedded in	the  string  according
       to printf-style formatting directives.  For example,

	  png_debug1(2,	"foo=%d", foo);

       is expanded to

	  if (PNG_DEBUG	> 2)
	     fprintf(PNG_DEBUG_FILE, "foo=%d\n", foo);

       When  PNG_DEBUG	is defined but is zero,	the macros aren't defined, but
       you can still use PNG_DEBUG to control your own debugging:

	  #ifdef PNG_DEBUG
	      fprintf(stderr, ...
	  #endif

       When PNG_DEBUG =	1, the macros are defined, but only  png_debug	state-
       ments  having  level = 0	will be	printed.  There	aren't any such	state-
       ments in	this version of	libpng,	but if you insert some	they  will  be
       printed.

VII. MNG support
       The  MNG	specification (available at http://www.libpng.org/pub/mng) al-
       lows certain extensions to PNG for PNG images that are embedded in  MNG
       datastreams.   Libpng  can support some of these	extensions.  To	enable
       them, use the png_permit_mng_features() function:

	  feature_set =	png_permit_mng_features(png_ptr, mask)

	  mask is a png_uint_32	containing the bitwise OR of the
	       features	you want to enable.  These include
	       PNG_FLAG_MNG_EMPTY_PLTE
	       PNG_FLAG_MNG_FILTER_64
	       PNG_ALL_MNG_FEATURES

	  feature_set is a png_uint_32 that is the bitwise AND of
	     your mask with the	set of MNG features that is
	     supported by the version of libpng	that you are using.

       It is an	error to use this function when	reading	or  writing  a	stand-
       alone  PNG file with the	PNG 8-byte signature.  The PNG datastream must
       be wrapped in a MNG datastream.	As a minimum, it  must	have  the  MNG
       8-byte signature	and the	MHDR and MEND chunks.  Libpng does not provide
       support for these or any	other MNG chunks; your application  must  pro-
       vide  its  own support for them.	 You may wish to consider using	libmng
       (available at http://www.libmng.com) instead.

VIII. Changes to Libpng	from version 0.88
       It should be noted that versions	of libpng later	than 0.96 are not dis-
       tributed	 by  the  original libpng author, Guy Schalnat,	nor by Andreas
       Dilger, who had taken over from Guy during 1996 and 1997, and  distrib-
       uted  versions  0.89  through 0.96, but rather by another member	of the
       original	PNG Group, Glenn Randers-Pehrson.  Guy and Andreas  are	 still
       alive and well, but they	have moved on to other things.

       The    old    libpng   functions	  png_read_init(),   png_write_init(),
       png_info_init(),	png_read_destroy(), and	png_write_destroy() have  been
       moved  to  PNG_INTERNAL in version 0.95 to discourage their use.	 These
       functions will be removed from libpng version 1.4.0.

       The preferred method of creating	and initializing the libpng structures
       is  via	the  png_create_read_struct(),	png_create_write_struct(), and
       png_create_info_struct()	because	they isolate the size  of  the	struc-
       tures  from the application, allow version error	checking, and also al-
       low the use of custom error handling routines  during  the  initializa-
       tion, which the old functions do	not.  The functions png_read_destroy()
       and png_write_destroy() do not actually free the	memory that libpng al-
       located	for these structs, but just reset the data structures, so they
       can  be	used  instead	of   png_destroy_read_struct()	 and   png_de-
       stroy_write_struct()  if	you feel there is too much system overhead al-
       locating	and freeing the	png_struct for each image read.

       Setting	 the   error   callbacks   via	 png_set_message_fn()	before
       png_read_init()	as was suggested in libpng-0.88	is no longer supported
       because this caused applications	that do	not use	custom error functions
       to fail if the png_ptr was not initialized to zero.  It is still	possi-
       ble to set the error callbacks AFTER png_read_init(), or	to change them
       with  png_set_error_fn(),  which	 is essentially	the same function, but
       with a new name to force	compilation errors with	applications that  try
       to use the old method.

       Support	for  the  sCAL,	 iCCP,	iTXt,  and  sPLT  chunks  was added at
       libpng-1.0.6; however, iTXt support was not enabled by default.

       Starting	with version 1.0.7, you	can find out which version of the  li-
       brary you are using at run-time:

	  png_uint_32 libpng_vn	= png_access_version_number();

       The  number libpng_vn is	constructed from the major version, minor ver-
       sion with leading zero, and release number with	leading	 zero,	(e.g.,
       libpng_vn for version 1.0.7 is 10007).

       Note that this function does not	take a png_ptr,	so you can call	it be-
       fore you've created one.

       You can also check which	version	of png.h you used when compiling  your
       application:

	  png_uint_32 application_vn = PNG_LIBPNG_VER;

IX. Changes to Libpng from version 1.0.x to 1.2.x
       Support	for  user memory management was	enabled	by default.  To	accom-
       plish  this,   the   functions	png_create_read_struct_2(),   png_cre-
       ate_write_struct_2(),   png_set_mem_fn(),  png_get_mem_ptr(),  png_mal-
       loc_default(), and png_free_default() were added.

       Support for the iTXt chunk has been enabled by default  as  of  version
       1.2.41.

       Support for certain MNG features	was enabled.

       Support	for  numbered error messages was added.	 However, we never got
       around  to  actually  numbering	the  error  messages.	The   function
       png_set_strip_error_numbers()  was  added (Note:	the prototype for this
       function	was inadvertently removed from png.h in	 PNG_NO_ASSEMBLER_CODE
       builds of libpng-1.2.15.	 It was	restored in libpng-1.2.36).

       The  png_malloc_warn() function was added at libpng-1.2.3.  This	issues
       a png_warning and returns NULL instead of aborting when it fails	to ac-
       quire the requested memory allocation.

       Support	for  setting user limits on image width	and height was enabled
       by      default.	      The	functions	png_set_user_limits(),
       png_get_user_width_max(),  and  png_get_user_height_max() were added at
       libpng-1.2.6.

       The png_set_add_alpha() function	was added at libpng-1.2.7.

       The   function	png_set_expand_gray_1_2_4_to_8()    was	   added    at
       libpng-1.2.9.   Unlike png_set_gray_1_2_4_to_8(), the new function does
       not expand the tRNS chunk to alpha. The png_set_gray_1_2_4_to_8() func-
       tion is deprecated.

       A number	of macro definitions in	support	of runtime selection of	assem-
       bler code features (especially Intel MMX	code support)  were  added  at
       libpng-1.2.0:

	   PNG_ASM_FLAG_MMX_SUPPORT_COMPILED
	   PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU
	   PNG_ASM_FLAG_MMX_READ_COMBINE_ROW
	   PNG_ASM_FLAG_MMX_READ_INTERLACE
	   PNG_ASM_FLAG_MMX_READ_FILTER_SUB
	   PNG_ASM_FLAG_MMX_READ_FILTER_UP
	   PNG_ASM_FLAG_MMX_READ_FILTER_AVG
	   PNG_ASM_FLAG_MMX_READ_FILTER_PAETH
	   PNG_ASM_FLAGS_INITIALIZED
	   PNG_MMX_READ_FLAGS
	   PNG_MMX_FLAGS
	   PNG_MMX_WRITE_FLAGS
	   PNG_MMX_FLAGS

       We added	the following functions	in support of runtime selection	of as-
       sembler code features:

	   png_get_mmx_flagmask()
	   png_set_mmx_thresholds()
	   png_get_asm_flags()
	   png_get_mmx_bitdepth_threshold()
	   png_get_mmx_rowbytes_threshold()
	   png_set_asm_flags()

       We replaced all of these	functions with simple stubs in	libpng-1.2.20,
       when the	Intel assembler	code was removed due to	a licensing issue.

       These macros are	deprecated:

	   PNG_READ_TRANSFORMS_NOT_SUPPORTED
	   PNG_PROGRESSIVE_READ_NOT_SUPPORTED
	   PNG_NO_SEQUENTIAL_READ_SUPPORTED
	   PNG_WRITE_TRANSFORMS_NOT_SUPPORTED
	   PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED
	   PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED

       They have been replaced,	respectively, by:

	   PNG_NO_READ_TRANSFORMS
	   PNG_NO_PROGRESSIVE_READ
	   PNG_NO_SEQUENTIAL_READ
	   PNG_NO_WRITE_TRANSFORMS
	   PNG_NO_READ_ANCILLARY_CHUNKS
	   PNG_NO_WRITE_ANCILLARY_CHUNKS

       PNG_MAX_UINT was	replaced with PNG_UINT_31_MAX.	It has been deprecated
       since libpng-1.0.16 and libpng-1.2.6.

       The function
	   png_check_sig(sig, num) was replaced	with
	   !png_sig_cmp(sig, 0,	num) It	has been deprecated since libpng-0.90.

       The function
	   png_set_gray_1_2_4_to_8() which also	expands	tRNS to	alpha was  re-
       placed with
	   png_set_expand_gray_1_2_4_to_8() which does not. It has been	depre-
       cated since libpng-1.0.18 and 1.2.9.

X. Changes to Libpng from version 1.0.x/1.2.x to 1.4.x
       Private libpng prototypes and macro definitions were moved  from	 png.h
       and pngconf.h into a new	pngpriv.h header file.

       Functions      png_set_benign_errors(),	   png_benign_error(),	   and
       png_chunk_benign_error()	were added.

       Support for setting the maximum amount of memory	that  the  application
       will allocate for reading chunks	was added, as a	security measure.  The
       functions png_set_chunk_cache_max() and png_get_chunk_cache_max()  were
       added to	the library.

       We implemented support for I/O states by	adding png_ptr member io_state
       and  functions  png_get_io_chunk_name()	 and   png_get_io_state()   in
       pngget.c

       We  added  PNG_TRANSFORM_GRAY_TO_RGB  to	the available high-level input
       transforms.

       Checking	for and	reporting of errors in the IHDR	chunk  is  more	 thor-
       ough.

       Support for global arrays was removed, to improve thread	safety.

       Some obsolete/deprecated	macros and functions have been removed.

       Typecasted NULL definitions such	as
	  #define  png_voidp_NULL	      (png_voidp)NULL were eliminated.
       If you used these in your application, just use NULL instead.

       The png_struct and info_struct members "trans" and "trans_values"  were
       changed to "trans_alpha"	and "trans_color", respectively.

       The  obsolete,  unused pnggccrd.c and pngvcrd.c files and related make-
       files were removed.

       The PNG_1_0_X and PNG_1_2_X macros were eliminated.

       The PNG_LEGACY_SUPPORTED	macro was eliminated.

       Many WIN32_WCE #ifdefs were removed.

       The   functions	 png_read_init(info_ptr),    png_write_init(info_ptr),
       png_info_init(info_ptr),	 png_read_destroy(),  and  png_write_destroy()
       have been removed.  They	have been deprecated since libpng-0.95.

       The png_permit_empty_plte() was removed.	It has been  deprecated	 since
       libpng-1.0.9.  Use png_permit_mng_features() instead.

       We   removed   the   obsolete  stub  functions  png_get_mmx_flagmask(),
       png_set_mmx_thresholds(),     png_get_asm_flags(),     png_get_mmx_bit-
       depth_threshold(),		     png_get_mmx_rowbytes_threshold(),
       png_set_asm_flags(), and	png_mmx_supported()

       We  removed  the	 obsolete  png_check_sig(),  png_memcpy_check(),   and
       png_memset_check()  functions.	Instead	 use !png_sig_cmp(), memcpy(),
       and memset(), respectively.

       The function png_set_gray_1_2_4_to_8() was removed. It has been	depre-
       cated  since  libpng-1.0.18  and	 1.2.9,	 when  it  was	replaced  with
       png_set_expand_gray_1_2_4_to_8()	because	the former function  also  ex-
       panded any tRNS chunk to	an alpha channel.

       Macros  for  png_get_uint_16,  png_get_uint_32, and png_get_int_32 were
       added and are used by default instead of	the  corresponding  functions.
       Unfortunately, from libpng-1.4.0	until 1.4.4, the png_get_uint_16 macro
       (but  not  the  function)  incorrectly  returned	 a   value   of	  type
       png_uint_32.

       We changed the prototype	for png_malloc() from
	   png_malloc(png_structp png_ptr, png_uint_32 size) to
	   png_malloc(png_structp png_ptr, png_alloc_size_t size)

       This  also  applies  to	the  prototype	for  the user replacement mal-
       loc_fn().

       The png_calloc()	function  was  added  and  is  used  in	 place	of  of
       "png_malloc();  memset();"  except  in the case in png_read_png() where
       the array consists of pointers; in this case a "for" loop is used after
       the png_malloc()	to set the pointers to NULL, to	give robust.  behavior
       in case the  application	 runs  out  of	memory	part-way  through  the
       process.

       We  changed  the	 prototypes  of	 png_get_compression_buffer_size() and
       png_set_compression_buffer_size() to work with  png_size_t  instead  of
       png_uint_32.

       Support	for  numbered  error messages was removed by default, since we
       never got around	to actually numbering the error	messages. The function
       png_set_strip_error_numbers() was removed from the library by default.

       The png_zalloc()	and png_zfree()	functions are no longer	exported.  The
       png_zalloc() function no	longer zeroes out the  memory  that  it	 allo-
       cates.	Applications that called png_zalloc(png_ptr, number, size) can
       call png_calloc(png_ptr,	number*size) instead, and can call  png_free()
       instead of png_zfree().

       Support	for dithering was disabled by default in libpng-1.4.0, because
       it has not been well tested and doesn't actually	 "dither".   The  code
       was  not	removed, however, and could be enabled by building libpng with
       PNG_READ_DITHER_SUPPORTED defined.  In libpng-1.4.2, this  support  was
       re-enabled,  but	the function was renamed png_set_quantize() to reflect
       more  accurately	 what  it  actually  does.   At	 the  same  time,  the
       PNG_DITHER_[RED,GREEN_BLUE]_BITS	 macros	were also renamed to PNG_QUAN-
       TIZE_[RED,GREEN,BLUE]_BITS, and PNG_READ_DITHER_SUPPORTED  was  renamed
       to PNG_READ_QUANTIZE_SUPPORTED.

       We removed the trailing '.' from	the warning and	error messages.

XI. Changes to Libpng from version 1.4.x to 1.5.x
       From  libpng-1.4.0  until 1.4.4,	the png_get_uint_16 macro (but not the
       function) incorrectly returned a	value of type png_uint_32.  The	incor-
       rect macro was removed from libpng-1.4.5.

       Checking	for invalid palette index on write was added at	libpng 1.5.10.
       If a pixel contains an invalid (out-of-range) index libpng issues a be-
       nign  error.   This  is enabled by default because this condition is an
       error according to the PNG specification, Clause	11.3.2,	but the	 error
       can be ignored in each png_ptr with

	  png_set_check_for_invalid_index(png_ptr, allowed);

	     allowed  -	one of
			0: disable benign error	(accept	the
			   invalid data	without	warning).
			1: enable benign error (treat the
			   invalid data	as an error or a
			   warning).

       If  the error is	ignored, or if png_benign_error() treats it as a warn-
       ing, any	invalid	pixels are decoded as opaque black by the decoder  and
       written as-is by	the encoder.

       Retrieving  the maximum palette index found was added at	libpng-1.5.15.
       This statement must appear  after  png_read_png()  or  png_read_image()
       while  reading,	and  after  png_write_png() or png_write_image() while
       writing.

	  int max_palette = png_get_palette_max(png_ptr, info_ptr);

       This will return	the maximum palette index found	in the image, or  "-1"
       if  the	palette	was not	checked, or "0"	if no palette was found.  Note
       that this does not account for any  palette  index  used	 by  ancillary
       chunks  such  as	the bKGD chunk;	you must check those separately	to de-
       termine the maximum palette index actually used.

       There are no substantial	API changes between the	 non-deprecated	 parts
       of  the	1.4.5  API and the 1.5.0 API; however, the ability to directly
       access members of the main libpng control  structures,  png_struct  and
       png_info, deprecated in earlier versions	of libpng, has been completely
       removed from libpng 1.5,	and new	 private  "pngstruct.h",  "pnginfo.h",
       and "pngdebug.h"	header files were created.

       We  no  longer include zlib.h in	png.h.	The include statement has been
       moved to	pngstruct.h, where it is not accessible	by  applications.  Ap-
       plications  that	 need access to	information in zlib.h will need	to add
       the '#include "zlib.h"' directive.  It does not matter whether this  is
       placed prior to or after	the '"#include png.h"' directive.

       The png_sprintf(), png_strcpy(),	and png_strncpy() macros are no	longer
       used and	were removed.

       We moved	the png_strlen(), png_memcpy(),	png_memset(), and png_memcmp()
       macros into a private header file (pngpriv.h) that is not accessible to
       applications.

       In png_get_iCCP,	the type of "profile" was changed from	png_charpp  to
       png_bytepp, and in png_set_iCCP,	from png_charp to png_const_bytep.

       There are changes of form in png.h, including new and changed macros to
       declare parts of	the API.  Some API functions with arguments  that  are
       pointers	 to  data not modified within the function have	been corrected
       to declare these	arguments with PNG_CONST.

       Much of the internal use	of C macros to control the library  build  has
       also  changed and some of this is visible in the	exported header	files,
       in particular the use of	macros to control data and API elements	 visi-
       ble  during application compilation may require significant revision to
       application code.  (It is extremely  rare  for  an  application	to  do
       this.)

       Any program that	compiled against libpng	1.4 and	did not	use deprecated
       features	or access internal library structures should compile and  work
       against	libpng	1.5,  except  for  the	change	in  the	 prototype for
       png_get_iCCP() and png_set_iCCP() API functions mentioned above.

       libpng 1.5.0 adds PNG_ PASS macros to help in the reading  and  writing
       of interlaced images.  The macros return	the number of rows and columns
       in each pass and	information that can be	used to	de-interlace  and  (if
       absolutely necessary) interlace an image.

       libpng  1.5.0  adds an API png_longjmp(png_ptr, value).	This API calls
       the application-provided	png_longjmp_ptr	on the internal, but  applica-
       tion  initialized,  longjmp buffer.  It is provided as a	convenience to
       avoid the need to use the png_jmpbuf macro, which had  the  unnecessary
       side effect of resetting	the internal png_longjmp_ptr value.

       libpng  1.5.0  includes a complete fixed	point API.  By default this is
       present along with the corresponding floating point  API.   In  general
       the  fixed  point API is	faster and smaller than	the floating point one
       because the PNG file format used	fixed point, not floating point.  This
       applies	even  if  the library uses floating point in internal calcula-
       tions.  A new macro, PNG_FLOATING_ARITHMETIC_SUPPORTED, reveals whether
       the library uses	floating point arithmetic (the default)	or fixed point
       arithmetic internally for performance  critical	calculations  such  as
       gamma  correction.   In	some cases, the	gamma calculations may produce
       slightly	 different  results.   This  has  changed   the	  results   in
       png_rgb_to_gray	and in alpha composition (png_set_background for exam-
       ple). This applies even if the original image was already linear	(gamma
       ==  1.0)	 and,  therefore,  it is not necessary to linearize the	image.
       This is because libpng has *not*	been changed  to  optimize  that  case
       correctly, yet.

       Fixed  point support for	the sCAL chunk comes with an important caveat;
       the sCAL	specification uses a decimal encoding of floating point	values
       and  the	 accuracy of PNG fixed point values is insufficient for	repre-
       sentation of these values. Consequently a "string" API  (png_get_sCAL_s
       and  png_set_sCAL_s) is the only	reliable way of	reading	arbitrary sCAL
       chunks in the absence of	either the  floating  point  API  or  internal
       floating	point calculations.  Starting with libpng-1.5.0, both of these
       functions are present when PNG_sCAL_SUPPORTED  is  defined.   Prior  to
       libpng-1.5.0,  their  presence  also depended upon PNG_FIXED_POINT_SUP-
       PORTED being defined and	 PNG_FLOATING_POINT_SUPPORTED  not  being  de-
       fined.

       Applications no longer need to include the optional distribution	header
       file pngusr.h or	define the  corresponding  macros  during  application
       build  in  order	 to  see  the correct variant of the libpng API.  From
       1.5.0 application code  can  check  for	the  corresponding  _SUPPORTED
       macro:

       #ifdef PNG_INCH_CONVERSIONS_SUPPORTED
	  /* code that uses the	inch conversion	APIs. */ #endif

       This  macro  will only be defined if the	inch conversion	functions have
       been compiled into libpng.  The full set	of macros, and whether or  not
       support	has been compiled in, are available in the header file pnglib-
       conf.h.	This header file is specific to	the libpng build.  Notice that
       prior to	1.5.0 the _SUPPORTED macros would always have the default def-
       inition unless reset by pngusr.h	or by explicit settings	 on  the  com-
       piler  command  line.   These settings may produce compiler warnings or
       errors in 1.5.0 because of macro	redefinition.

       Applications can	now choose whether to use these	macros or to call  the
       corresponding	function    by	  defining    PNG_USE_READ_MACROS   or
       PNG_NO_USE_READ_MACROS before including png.h.	Notice	that  this  is
       only  supported	from  1.5.0;  defining PNG_NO_USE_READ_MACROS prior to
       1.5.0 will lead to a link failure.

       Prior to	libpng-1.5.4, the zlib compressor used the same	set of parame-
       ters  when  compressing the IDAT	data and textual data such as zTXt and
       iCCP.  In libpng-1.5.4 we reinitialized the zlib	stream for  each  type
       of  data.  We added five	png_set_text_*() functions for setting the pa-
       rameters	to use with textual data.

       Prior to	 libpng-1.5.4,	the  PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED
       option  was  off	 by default, and slightly inaccurate scaling occurred.
       This option can no longer be turned off,	and the	choice of accurate  or
       inaccurate  16-to-8 scaling is by using the new png_set_scale_16_to_8()
       API for accurate	scaling	or the	old  png_set_strip_16_to_8()  API  for
       simple	chopping.    In	  libpng-1.5.4,	  the	PNG_READ_16_TO_8_ACCU-
       RATE_SCALE_SUPPORTED macro became PNG_READ_SCALE_16_TO_8_SUPPORTED, and
       the  PNG_READ_16_TO_8 macro became PNG_READ_STRIP_16_TO_8_SUPPORTED, to
       enable the two png_set_*_16_to_8() functions separately.

       Prior to	libpng-1.5.4, the png_set_user_limits()	function could only be
       used  to	 reduce	 the  width  and  height  limits  from	the  value  of
       PNG_USER_WIDTH_MAX and PNG_USER_HEIGHT_MAX, although this document said
       that  it	could be used to override them.	 Now this function will	reduce
       or increase the limits.

       Starting	in libpng-1.5.10, the user limits can be set en	masse with the
       configuration  option PNG_SAFE_LIMITS_SUPPORTED.	 If this option	is en-
       abled, a	set of "safe" limits is	applied	in pngpriv.h.	These  can  be
       overridden    by	   application	  calls	   to	png_set_user_limits(),
       png_set_user_chunk_cache_max(), and/or  png_set_user_malloc_max()  that
       increase	 or  decrease  the limits.  Also, in libpng-1.5.10 the default
       width and height	limits were increased  from  1,000,000	to  0x7fffffff
       (i.e., made unlimited).	Therefore, the limits are now
				      default	   safe
	  png_user_width_max	    0x7fffffff	  1,000,000
	  png_user_height_max	    0x7fffffff	  1,000,000
	  png_user_chunk_cache_max  0 (unlimited)   128
	  png_user_chunk_malloc_max 0 (unlimited) 8,000,000

       The  png_set_option()  function	(and  the  "options" member of the png
       struct) was added to libpng-1.5.15, with	option PNG_ARM_NEON.

       The library now supports	a complete fixed point implementation and  can
       thus  be	 used  on  systems that	have no	floating point support or very
       limited or slow support.	 Previously  gamma  correction,	 an  essential
       part of complete	PNG support, required reasonably fast floating point.

       As part of this the choice of internal implementation has been made in-
       dependent of the	choice of fixed	versus floating	point APIs and all the
       missing fixed point APIs	have been implemented.

       The  exact  mechanism  used  to control attributes of API functions has
       changed,	as described in	the INSTALL file.

       A new test program, pngvalid, is	provided in addition to	pngtest.  png-
       valid  validates	the arithmetic accuracy	of the gamma correction	calcu-
       lations and includes a number of	validations of	the  file  format.   A
       subset  of the full range of tests is run when "make check" is done (in
       the 'configure' build.)	pngvalid also allows  total  allocated	memory
       usage  to be evaluated and performs additional memory overwrite valida-
       tion.

       Many changes to individual feature macros have been made. The following
       are  the	changes	most likely to be noticed by library builders who con-
       figure libpng:

       1) All feature macros now have consistent naming:

       #define PNG_NO_feature turns the	feature	off  #define  PNG_feature_SUP-
       PORTED turns the	feature	on

       pnglibconf.h contains one line for each feature macro which is either:

       #define PNG_feature_SUPPORTED

       if the feature is supported or:

       /*#undef	PNG_feature_SUPPORTED*/

       if  it  is  not.	  Library code consistently checks for the 'SUPPORTED'
       macro.  It does not, and	libpng applications should not,	check for  the
       'NO'  macro  which  will	not normally be	defined	even if	the feature is
       not supported.  The 'NO'	macros are only	used internally	for setting or
       not setting the corresponding 'SUPPORTED' macros.

       Compatibility with the old names	is provided as follows:

       PNG_INCH_CONVERSIONS turns on PNG_INCH_CONVERSIONS_SUPPORTED

       And the following definitions disable the corresponding feature:

       PNG_SETJMP_NOT_SUPPORTED	 disables  SETJMP PNG_READ_TRANSFORMS_NOT_SUP-
       PORTED disables READ_TRANSFORMS	PNG_NO_READ_COMPOSITED_NODIV  disables
       READ_COMPOSITE_NODIV	PNG_WRITE_TRANSFORMS_NOT_SUPPORTED    disables
       WRITE_TRANSFORMS	   PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED    disables
       READ_ANCILLARY_CHUNKS PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED disables
       WRITE_ANCILLARY_CHUNKS

       Library builders	should remove use of the above,	inconsistent, names.

       2) Warning and error message formatting was previously  conditional  on
       the  STDIO  feature. The	library	has been changed to use	the CONSOLE_IO
       feature instead.	This means that	if CONSOLE_IO is disabled the  library
       no  longer  uses	 the  printf(3)	 functions,  even  though  the default
       read/write implementations use (FILE) style stdio.h functions.

       3) Three	feature	macros now control the fixed/floating point decisions:

       PNG_FLOATING_POINT_SUPPORTED enables the	floating point APIs

       PNG_FIXED_POINT_SUPPORTED enables the fixed  point  APIs;  however,  in
       practice	these are normally required internally anyway (because the PNG
       file format is fixed point), therefore in most cases PNG_NO_FIXED_POINT
       merely stops the	function from being exported.

       PNG_FLOATING_ARITHMETIC_SUPPORTED chooses between the internal floating
       point implementation or the fixed point one.  Typically the fixed point
       implementation is larger	and slower than	the floating point implementa-
       tion on a system	that supports  floating	 point;	 however,  it  may  be
       faster  on  a  system which lacks floating point	hardware and therefore
       uses a software emulation.

       4) Added	 PNG_{READ,WRITE}_INT_FUNCTIONS_SUPPORTED.   This  allows  the
       functions  to  read  and	 write	ints  to  be disabled independently of
       PNG_USE_READ_MACROS, which allows libpng	to be built with the functions
       even though the default is to use the macros - this allows applications
       to choose at app	buildtime whether or not to use	macros (previously im-
       possible	because	the functions weren't in the default build.)

XII. Changes to	Libpng from version 1.5.x to 1.6.x
       A  "simplified  API"  has  been added (see documentation	in png.h and a
       simple example in contrib/examples/pngtopng.c).	The new	publicly visi-
       ble API includes	the following:

	  macros:
	    PNG_FORMAT_*
	    PNG_IMAGE_*
	  structures:
	    png_control
	    png_image
	  read functions
	    png_image_begin_read_from_file()
	    png_image_begin_read_from_stdio()
	    png_image_begin_read_from_memory()
	    png_image_finish_read()
	    png_image_free()
	  write	functions
	    png_image_write_to_file()
	    png_image_write_to_memory()
	    png_image_write_to_stdio()

       Starting	 with libpng-1.6.0, you	can configure libpng to	prefix all ex-
       ported symbols, using the PNG_PREFIX macro.

       We no longer include string.h in	png.h.	The include statement has been
       moved to	pngpriv.h, where it is not accessible by applications.	Appli-
       cations that need access	to information in string.h must	add  an	 '#in-
       clude <string.h>' directive.  It	does not matter	whether	this is	placed
       prior to	or after the '#include "png.h"'	directive.

       The following API are now DEPRECATED:
	  png_info_init_3()
	  png_convert_to_rfc1123() which has been replaced
	    with png_convert_to_rfc1123_buffer()
	  png_malloc_default()
	  png_free_default()
	  png_reset_zstream()

       The following have been removed:
	  png_get_io_chunk_name(), which has been replaced
	    with png_get_io_chunk_type().  The new
	    function returns a 32-bit integer instead of
	    a string.
	  The png_sizeof(), png_strlen(), png_memcpy(),	png_memcmp(), and
	    png_memset() macros	are no longer used in the libpng sources and
	    have been removed.	These had already been made invisible  to  ap-
       plications
	    (i.e.,  defined  in	 the  private  pngpriv.h  header  file)	 since
       libpng-1.5.0.

       The signatures of many exported functions were changed, such that
	  png_structp became png_structrp or png_const_structrp
	  png_infop became png_inforp or png_const_inforp where	"rp" indicates
       a "restricted pointer".

       Dropped support for 16-bit platforms. The support for FAR/far types has
       been eliminated and the definition  of  png_alloc_size_t	 is  now  con-
       trolled	by a flag so that 'small size_t' systems can select it if nec-
       essary.

       Error detection in some chunks has improved;  in	 particular  the  iCCP
       chunk  reader  now does pretty complete validation of the basic format.
       Some bad	profiles that were previously accepted are now accepted	with a
       warning	or  rejected,  depending upon the png_set_benign_errors() set-
       ting, in	particular the very old	 broken	 Microsoft/HP  3144-byte  sRGB
       profile.	  Starting  with  libpng-1.6.11, recognizing and checking sRGB
       profiles	can be avoided by means	of

	   #if	   defined(PNG_SKIP_sRGB_CHECK_PROFILE)	    &&		   de-
       fined(PNG_SET_OPTION_SUPPORTED)
	      png_set_option(png_ptr, PNG_SKIP_sRGB_CHECK_PROFILE,
		  PNG_OPTION_ON);
	   #endif

       It's  not a good	idea to	do this	if you are using the "simplified API",
       which needs to be able to recognize sRGB	profiles conveyed via the iCCP
       chunk.

       The PNG spec requirement	that only grayscale profiles may appear	in im-
       ages with color type 0 or 4 and that even if the	 image	only  contains
       gray  pixels, only RGB profiles may appear in images with color type 2,
       3, or 6,	is now enforced.  The sRGB chunk is allowed to appear  in  im-
       ages  with any color type and is	interpreted by libpng to convey	a one-
       tracer-curve gray profile or a three-tracer-curve RGB profile as	appro-
       priate.

       Libpng 1.5.x erroneously	used /MD for Debug DLL builds; if you used the
       debug builds in your app	and you	changed	your app to use	/MD  you  will
       need to change it back to /MDd for libpng 1.6.x.

       Prior  to libpng-1.6.0 a	warning	would be issued	if the iTXt chunk con-
       tained an empty language	field or an empty translated keyword.  Both of
       these  are  allowed  by the PNG specification, so these warnings	are no
       longer issued.

       The library now issues an error if the application attempts  to	set  a
       transform  after	 it  calls png_read_update_info() or if	it attempts to
       call both png_read_update_info()	and png_start_read_image() or to  call
       either of them more than	once.

       The  default  condition for benign_errors is now	to treat benign	errors
       as warnings while reading and as	errors while writing.

       The library now issues a	warning	if both	background processing and  RGB
       to  gray	 are used when gamma correction	happens. As with previous ver-
       sions of	the library the	results	are numerically	very incorrect in this
       case.

       There  are  some	 minor	arithmetic  changes in some transforms such as
       png_set_background(), that might	 be  detected  by  certain  regression
       tests.

       Unknown	chunk  handling	 has been improved internally, without any API
       change.	This adds more correct option control of the unknown handling,
       corrects	 a  pre-existing bug where the per-chunk 'keep'	setting	is ig-
       nored, and makes	it possible to skip  IDAT  chunks  in  the  sequential
       reader.

       The  machine-generated  configure  files	 are  no  longer  included  in
       branches	libpng16 and later of the GIT repository.  They	continue to be
       included	in the tarball releases, however.

       Libpng-1.6.0  through  1.6.2 used the CMF bytes at the beginning	of the
       IDAT stream to set the size of the sliding window for  reading  instead
       of  using  the default 32-kbyte sliding window size.  It	was discovered
       that there are hundreds of PNG files in the wild	 that  have  incorrect
       CMF bytes that caused zlib to issue the "invalid	distance too far back"
       error and reject	the file.  Libpng-1.6.3	and later calculate their  own
       safe  CMF  from	the  image  dimensions,	provide	a way to revert	to the
       libpng-1.5.x behavior (ignoring the CMF	bytes  and  using  a  32-kbyte
       sliding window),	by using

	   png_set_option(png_ptr, PNG_MAXIMUM_INFLATE_WINDOW,
	       PNG_OPTION_ON);

       and  provide  a	tool  (contrib/tools/pngfix)  for rewriting a PNG file
       while optimizing	the CMF	bytes in its IDAT chunk	correctly.

       Libpng-1.6.0 and	libpng-1.6.1 wrote uncompressed	iTXt chunks  with  the
       wrong  length,  which  resulted in PNG files that cannot	be read	beyond
       the bad iTXt chunk.  This error was fixed in libpng-1.6.3, and  a  tool
       (called	contrib/tools/png-fix-itxt)  has been added to the libpng dis-
       tribution.

       Starting	with libpng-1.6.17, the	PNG_SAFE_LIMITS	macro  was  eliminated
       and  safe  limits are used by default (users who	need larger limits can
       still override them at compile time or run time,	as described above).

       The new limits are
				       default	 spec limit
	  png_user_width_max	     1,000,000	2,147,483,647
	  png_user_height_max	     1,000,000	2,147,483,647
	  png_user_chunk_cache_max	   128	unlimited
	  png_user_chunk_malloc_max  8,000,000	unlimited

       Starting	with libpng-1.6.18, a PNG_RELEASE_BUILD	macro was added, which
       allows  library builders	to control compilation for an installed	system
       (a release build).  It can be set for testing debug or beta  builds  to
       ensure  that they will compile when the build type is switched to RC or
       STABLE. In essence this overrides the PNG_LIBPNG_BUILD_BASE_TYPE	 defi-
       nition which is not directly user controllable.

       Starting	 with  libpng-1.6.19,  attempting  to  set an over-length PLTE
       chunk is	an error. Previously this requirement of the PNG specification
       was not enforced, and the palette was always limited to 256 entries. An
       over-length PLTE	chunk found in an input	PNG is silently	truncated.

XIII. Detecting	libpng
       The png_get_io_ptr() function has been present since  libpng-0.88,  has
       never changed, and is unaffected	by conditional compilation macros.  It
       is the best choice for use in configure scripts for detecting the pres-
       ence  of	 any libpng version since 0.88.	 In an autoconf	"configure.in"
       you could use

	   AC_CHECK_LIB(png, png_get_io_ptr, ...

XV. Source code	repository
       Since about February 2009, version 1.2.34, libpng has been under	 "git"
       source  control.	  The  git  repository	was  built  from  old  libpng-
       x.y.z.tar.gz files going	back to	version	0.70.  You can access the  git
       repository (read	only) at

	   git://git.code.sf.net/p/libpng/code

       or  you can browse it with a web	browser	by selecting the "code"	button
       at

	   https://sourceforge.net/projects/libpng

       Patches can be sent to glennrp at users.sourceforge.net or to  png-mng-
       implement at lists.sourceforge.net or you can upload them to the	libpng
       bug tracker at

	   http://libpng.sourceforge.net

       We also accept patches built from the tar  or  zip  distributions,  and
       simple verbal discriptions of bug fixes,	reported either	to the Source-
       Forge bug tracker, to the  png-mng-implement  at	 lists.sf.net  mailing
       list, or	directly to glennrp.

XV. Coding style
       Our   coding   style   is   similar   to	  the	"Allman"   style  (See
       http://en.wikipedia.org/wiki/Indent_style#Allman_style),	  with	 curly
       braces on separate lines:

	   if (condition)
	   {
	      action;
	   }

	   else	if (another condition)
	   {
	      another action;
	   }

       The braces can be omitted from simple one-line actions:

	   if (condition)
	      return (0);

       We  use	3-space	indentation, except for	continued statements which are
       usually indented	the same as the	first line of the statement plus  four
       more spaces.

       For  macro  definitions	we use 2-space indentation, always leaving the
       "#" in the first	column.

	   #ifndef PNG_NO_FEATURE
	   #  ifndef PNG_FEATURE_SUPPORTED
	   #	define PNG_FEATURE_SUPPORTED
	   #  endif
	   #endif

       Comments	appear with the	leading	"/*" at	the same  indentation  as  the
       statement that follows the comment:

	   /* Single-line comment */
	   statement;

	   /* This is a	multiple-line
	    * comment.
	    */
	   statement;

       Very  short  comments  can  be placed after the end of the statement to
       which they pertain:

	   statement;	 /* comment */

       We don't	use C++	style ("//") comments. We have,	however, used them  in
       the past	in some	now-abandoned MMX assembler code.

       Functions  and  their curly braces are not indented, and	exported func-
       tions are marked	with PNGAPI:

	/* This	is a public function that is visible to
	 * application programmers. It does thus-and-so.
	 */
	void PNGAPI
	png_exported_function(png_ptr, png_info, foo)
	{
	   body;
	}

       The return type and decorations are placed on a separate	line ahead  of
       the function name, as illustrated above.

       The  prototypes	for  all exported functions appear in png.h, above the
       comment that says

	   /* Maintainer: Put new public prototypes here ... */

       We mark all non-exported	functions with "/* PRIVATE */"":

	void /*	PRIVATE	*/
	png_non_exported_function(png_ptr, png_info, foo)
	{
	   body;
	}

       The prototypes for non-exported functions (except for those in pngtest)
       appear in pngpriv.h above the comment that says

	 /* Maintainer:	Put new	private	prototypes here	^ */

       To  avoid  polluting  the  global  namespace, the names of all exported
       functions and variables begin with "png_", and all publicly  visible  C
       preprocessor  macros  begin  with  "PNG".  We request that applications
       that use	libpng *not* begin any of their	own  symbols  with  either  of
       these strings.

       We  put	a  space  after	the "sizeof" operator and we omit the optional
       parentheses around its argument when the	argument is an expression, not
       a  type name, and we always enclose the sizeof operator,	with its argu-
       ment, in	parentheses:

	 (sizeof (png_uint_32))
	 (sizeof array)

       Prior to	libpng-1.6.0 we	used  a	 "png_sizeof()"	 macro,	 formatted  as
       though it were a	function.

       Control	keywords  if,  for, while, and switch are always followed by a
       space to	distinguish them from function calls, which have  no  trailing
       space.

       We  put	a  space  after	 each  comma and after each semicolon in "for"
       statements, and we put spaces before and	after each C  binary  operator
       and  after  "for" or "while", and before	"?".  We don't put a space be-
       tween a typecast	and the	expression being cast, nor do we put  one  be-
       tween a function	name and the left parenthesis that follows it:

	   for (i = 2; i > 0; --i)
	      y[i] = a(x) + (int)b;

       We  prefer  #ifdef and #ifndef to #if defined() and #if !defined() when
       there is	only one macro being tested.  We always	use  parentheses  with
       "defined".

       We  express integer constants that are used as bit masks	in hex format,
       with an even number of lower-case hex digits, and to make them unsigned
       (e.g.,  0x00U, 0xffU, 0x0100U) and long if they are greater than	0x7fff
       (e.g., 0xffffUL).

       We prefer to use	underscores rather than	camelCase in names, except for
       a few type names	that we	inherit	from zlib.h.

       We  prefer  "if	(something  !=	0)" and	"if (something == 0)" over "if
       (something)" and	if "(!something)", respectively, and for  pointers  we
       prefer "if (some_pointer	!= NULL)" or "if (some_pointer == NULL)".

       We do not use the TAB character for indentation in the C	sources.

       Lines do	not exceed 80 characters.

       Other rules can be inferred by inspecting the libpng source.

XVI. Y2K Compliance in libpng
       Since the PNG Development group is an ad-hoc body, we can't make	an of-
       ficial declaration.

       This is your unofficial assurance that libpng from version 0.71 and up-
       ward  through  1.6.29  are Y2K compliant.  It is	my belief that earlier
       versions	were also Y2K compliant.

       Libpng only has two year	fields.	 One is	a 2-byte unsigned integer that
       will hold years up to 65535.  The other,	which is deprecated, holds the
       date in text format, and	will hold years	up to 9999.

       The integer is
	   "png_uint_16	year" in png_time_struct.

       The string is
	   "char time_buffer[29]" in png_struct.  This is no  longer  used  in
       libpng-1.6.x and	will be	removed	from libpng-1.7.0.

       There are seven time-related functions:

	   png_convert_to_rfc_1123_buffer() in png.c
	     (formerly png_convert_to_rfc_1152() in error, and
	     also formerly png_convert_to_rfc_1123())
	   png_convert_from_struct_tm()	in pngwrite.c, called
	     in	pngwrite.c
	   png_convert_from_time_t() in	pngwrite.c
	   png_get_tIME() in pngget.c
	   png_handle_tIME() in	pngrutil.c, called in pngread.c
	   png_set_tIME() in pngset.c
	   png_write_tIME() in pngwutil.c, called in pngwrite.c

       All appear to handle dates properly in a	Y2K environment.  The png_con-
       vert_from_time_t() function calls gmtime() to convert from system clock
       time,  which  returns  (year  - 1900), which we properly	convert	to the
       full 4-digit year.  There is  a	possibility  that  applications	 using
       libpng are not passing 4-digit years into the png_convert_to_rfc_1123()
       function, or that they are incorrectly passing only a 2-digit year  in-
       stead  of "year - 1900" into the	png_convert_from_struct_tm() function,
       but this	is not under our control.  The libpng documentation has	always
       stated  that  it	works with 4-digit years, and the APIs have been docu-
       mented as such.

       The tIME	chunk itself is	also Y2K compliant.  It	uses a 2-byte unsigned
       integer to hold the year, and can hold years as large as	65535.

       zlib, upon which	libpng depends,	is also	Y2K compliant.	It contains no
       date-related code.

	  Glenn	Randers-Pehrson
	  libpng maintainer
	  PNG Development Group

NOTE
       Note about libpng version numbers:

       Due to various miscommunications, unforeseen code incompatibilities and
       occasional  factors  outside the	authors' control, version numbering on
       the library has not always been consistent  and	straightforward.   The
       following  table	 summarizes matters since version 0.89c, which was the
       first widely used release:

	source		   png.h  png.h	 shared-lib
	version		   string   int	 version
	-------		   ------  ----- ----------
	0.89c "1.0 beta	3"     0.89	 89  1.0.89
	0.90  "1.0 beta	4"     0.90	 90  0.90  [should have	been 2.0.90]
	0.95  "1.0 beta	5"     0.95	 95  0.95  [should have	been 2.0.95]
	0.96  "1.0 beta	6"     0.96	 96  0.96  [should have	been 2.0.96]
	0.97b "1.00.97 beta 7" 1.00.97	 97  1.0.1 [should have	been 2.0.97]
	0.97c		       0.97	 97  2.0.97
	0.98		       0.98	 98  2.0.98
	0.99		       0.99	 98  2.0.99
	0.99a-m		       0.99	 99  2.0.99
	1.00		       1.00	100  2.1.0 [100	should be 10000]
	1.0.0	   (from here on, the	100  2.1.0 [100	should be 10000]
	1.0.1	    png.h string is   10001  2.1.0
	1.0.1a-e    identical to the  10002  from here on, the shared library
	1.0.2	    source version)   10002  is	2.V where V is the source code
	1.0.2a-b		      10003  version, except as	noted.
	1.0.3			      10003
	1.0.3a-d		      10004
	1.0.4			      10004
	1.0.4a-f		      10005
	1.0.5 (+ 2 patches)	      10005
	1.0.5a-d		      10006
	1.0.5e-r		      10100 (not source	compatible)
	1.0.5s-v		      10006 (not binary	compatible)
	1.0.6 (+ 3 patches)	      10006 (still binary incompatible)
	1.0.6d-f		      10007 (still binary incompatible)
	1.0.6g			      10007
	1.0.6h			      10007  10.6h (testing xy.z so-numbering)
	1.0.6i			      10007  10.6i
	1.0.6j			       10007   2.1.0.6j	  (incompatible	  with
       1.0.0)
	1.0.7beta11-14	      DLLNUM  10007  2.1.0.7beta11-14 (binary compati-
       ble)
	1.0.7beta15-18		 1    10007  2.1.0.7beta15-18 (binary compati-
       ble)
	1.0.7rc1-2		 1    10007  2.1.0.7rc1-2 (binary compatible)
	1.0.7			 1    10007  (still compatible)
	...
	1.0.19			10    10019  10.so.0.19[.0]
	...
	1.2.57			13    10257  12.so.0.56[.0]
	...
	1.5.28			15    10528  15.so.15.28[.0]
	...
	1.6.29			16    10629  16.so.16.29[.0]

       Henceforth  the	source version will match the shared-library minor and
       patch numbers; the shared-library major version number will be used for
       changes	 in   backward	 compatibility,	  as   it  is  intended.   The
       PNG_PNGLIB_VER macro, which is not used within libpng but is  available
       for  applications, is an	unsigned integer of the	form xyyzz correspond-
       ing to the source version x.y.z (leading	zeros in y and z).  Beta  ver-
       sions  were given the previous public release number plus a letter, un-
       til version 1.0.6j; from	then on	they were given	 the  upcoming	public
       release number plus "betaNN" or "rcNN".

SEE ALSO
       libpngpf(3), png(5)

       libpng:

	      http://libpng.sourceforge.net   (follow	the  [DOWNLOAD]	 link)
	      http://www.libpng.org/pub/png

       zlib:

	      (generally) at the same location as libpng or at
	      ftp://ftp.info-zip.org/pub/infozip/zlib

       PNGspecification:RFC2083

	      (generally) at the same location as libpng or at
	      ftp://ftp.rfc-editor.org:/in-notes/rfc2083.txt
	      or (as a W3C Recommendation) at
	      http://www.w3.org/TR/REC-png.html

       In the case of any inconsistency	between	the PNG	specification and this
       library,	the specification takes	precedence.

AUTHORS
       This man	page: Glenn Randers-Pehrson <glennrp at	users.sourceforge.net>

       The  contributing authors would like to thank all those who helped with
       testing,	bug fixes, and patience.  This	wouldn't  have	been  possible
       without all of you.

       Thanks to Frank J. T. Wojcik for	helping	with the documentation.

       Libpng  version	1.6.29	- March	16, 2017: Initially created in 1995 by
       Guy Eric	Schalnat, then of Group	 42,  Inc.   Currently	maintained  by
       Glenn Randers-Pehrson (glennrp at users.sourceforge.net).

       Supported by the	PNG development	group
       png-mng-implement  at  lists.sf.net  (subscription required; visit png-
       mng-implement at	lists.sourceforge.net  (subscription  required;	 visit
       https://lists.sourceforge.net/lists/listinfo/png-mng-implement  to sub-
       scribe).

NOTICES:
       This copy of the	libpng notices is provided for your  convenience.   In
       case  of	 any discrepancy between this copy and the notices in the file
       png.h that is included in the libpng  distribution,  the	 latter	 shall
       prevail.

       COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:

       If you modify libpng you	may insert additional notices immediately fol-
       lowing this sentence.

       This code is released under the libpng license.

       libpng versions 1.0.7, July 1, 2000 through 1.6.29, March 16, 2017  are
       Copyright (c) 2000-2002,	2004, 2006-2017	Glenn Randers-Pehrson, are de-
       rived from libpng-1.0.6,	and are	distributed according to the same dis-
       claimer	and  license  as  libpng-1.0.6	with the following individuals
       added to	the list of Contributing Authors:

	  Simon-Pierre Cadieux
	  Eric S. Raymond
	  Mans Rullgard
	  Cosmin Truta
	  Gilles Vollant
	  James	Yu
	  Mandar Sahastrabuddhe
	  Google Inc.
	  Vadim	Barkov

       and with	the following additions	to the disclaimer:

	  There	is no warranty against interference with your enjoyment	of the
	  library or against infringement.  There is no	warranty that our
	  efforts or the library will fulfill any of your particular purposes
	  or needs.  This library is provided with all faults, and the entire
	  risk of satisfactory quality,	performance, accuracy, and  effort  is
       with
	  the user.

       Some  files  in	the  "contrib"	directory and some configure-generated
       files that are distributed with libpng have other copyright owners  and
       are released under other	open source licenses.

       libpng  versions	0.97, January 1998, through 1.0.6, March 20, 2000, are
       Copyright  (c)  1998-2000  Glenn	 Randers-Pehrson,  are	derived	  from
       libpng-0.96,  and  are distributed according to the same	disclaimer and
       license as libpng-0.96, with the	following  individuals	added  to  the
       list of Contributing Authors:

	  Tom Lane
	  Glenn	Randers-Pehrson
	  Willem van Schaik

       libpng  versions	0.89, June 1996, through 0.96, May 1997, are Copyright
       (c) 1996-1997 Andreas Dilger, are derived  from	libpng-0.88,  and  are
       distributed   according	 to   the   same  disclaimer  and  license  as
       libpng-0.88, with the following individuals added to the	list  of  Con-
       tributing Authors:

	  John Bowler
	  Kevin	Bracey
	  Sam Bushell
	  Magnus Holmgren
	  Greg Roelofs
	  Tom Tanner

       Some  files  in the "scripts" directory have other copyright owners but
       are released under this license.

       libpng versions 0.5, May	1995, through 0.88, January  1996,  are	 Copy-
       right (c) 1995-1996 Guy Eric Schalnat, Group 42,	Inc.

       For  the	purposes of this copyright and license,	"Contributing Authors"
       is defined as the following set of individuals:

	  Andreas Dilger
	  Dave Martindale
	  Guy Eric Schalnat
	  Paul Schmidt
	  Tim Wegner

       The PNG Reference Library is supplied "AS IS".	The  Contributing  Au-
       thors and Group 42, Inc.	disclaim all warranties, expressed or implied,
       including, without limitation, the warranties of	merchantability	and of
       fitness	for  any purpose.  The Contributing Authors and	Group 42, Inc.
       assume no liability for direct, indirect,  incidental,  special,	 exem-
       plary,  or  consequential damages, which	may result from	the use	of the
       PNG Reference Library, even if advised of the possibility of such  dam-
       age.

       Permission  is hereby granted to	use, copy, modify, and distribute this
       source code, or portions	hereof,	for any	purpose, without fee,  subject
       to the following	restrictions:

	 1. The	origin of this source code must	not be misrepresented.

	 2. Altered versions must be plainly marked as such and	must not
	    be misrepresented as being the original source.

	 3. This Copyright notice may not be removed or	altered	from any
	    source or altered source distribution.

       The  Contributing Authors and Group 42, Inc. specifically permit, with-
       out fee,	and encourage the use of this source code as  a	 component  to
       supporting the PNG file format in commercial products.  If you use this
       source code in a	product, acknowledgment	is not required	but  would  be
       appreciated.

       END OF COPYRIGHT	NOTICE,	DISCLAIMER, and	LICENSE.

       TRADEMARK:

       The  name  "libpng" has not been	registered by the Copyright owner as a
       trademark in any	jurisdiction.  However,	because	libpng has  been  dis-
       tributed	 and  maintained world-wide, continually since 1995, the Copy-
       right owner claims "common-law trademark	protection" in	any  jurisdic-
       tion where common-law trademark is recognized.

       OSI CERTIFICATION:

       Libpng  is  OSI	Certified  Open	 Source	 Software.  OSI	Certified Open
       Source is a certification mark of the Open Source Initiative.  OSI  has
       not addressed the additional disclaimers	inserted at version 1.0.7.

       EXPORT CONTROL:

       The  Copyright  owner  believes	that the Export	Control	Classification
       Number (ECCN) for libpng	is EAR99, which	means not  subject  to	export
       controls	or International Traffic in Arms Regulations (ITAR) because it
       is open source, publicly	available software, that does not contain  any
       encryption software.  See the EAR, paragraphs 734.3(b)(3) and 734.7(b).

       A  "png_get_copyright"  function	 is  available,	 for convenient	use in
       "about" boxes and the like:

	  printf("%s", png_get_copyright(NULL));

       Also, the PNG logo (in PNG format, of course) is	supplied in the	 files
       "pngbar.png" and	"pngbar.jpg (88x31) and	"pngnow.png" (98x31).

       Glenn Randers-Pehrson glennrp at	users.sourceforge.net March 16,	2017

				March 16, 2017			     LIBPNG(3)

NAME | SYNOPSIS | DESCRIPTION | LIBPNG.TXT | I. Introduction | II. Structures | III. Reading | IV. Writing | V. Simplified API | VI. Modifying/Customizing libpng | VII. MNG support | VIII. Changes to Libpng from version 0.88 | IX. Changes to Libpng from version 1.0.x to 1.2.x | X. Changes to Libpng from version 1.0.x/1.2.x to 1.4.x | XI. Changes to Libpng from version 1.4.x to 1.5.x | XII. Changes to Libpng from version 1.5.x to 1.6.x | XIII. Detecting libpng | XV. Source code repository | XV. Coding style | XVI. Y2K Compliance in libpng | NOTE | SEE ALSO | AUTHORS | NOTICES:

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=libpng&sektion=3&manpath=FreeBSD+12.0-RELEASE+and+Ports>

home | help