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.47

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_eXIf  (png_const_structp  png_ptr, png_const_infop
       info_ptr, png_bytep *exif);

       png_uint_32 png_get_eXIf_1 (png_const_structp png_ptr,  png_const_infop
       info_ptr, png_unit_32 *num_exif,	png_bytep *exif);

       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, 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,	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, size_t	buffer_size);

       size_t png_process_data_pause (png_structp png_ptr, int save);

       png_uint_32 png_process_data_skip (png_structp png_ptr);

       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_eXIf  (png_structp	png_ptr, png_infop info_ptr, png_bytep
       exif);

       void   png_set_eXIf_1   (png_structp   png_ptr,	 png_infop   info_ptr,
       png_uint_32 num_exif, png_bytep exif);

       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, size_t start, 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, size_t length);

       void png_write_chunk_data (png_structp png_ptr, png_bytep data,	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

	Copyright (c) 2018-2025	Cosmin Truta
	Copyright (c) 1998-2018	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 version 1.6.36, December	2018, through 1.6.47 - February	2025
	Updated	and distributed	by Cosmin Truta
	Copyright (c) 2018-2025	Cosmin Truta

	libpng versions	0.97, January 1998, through 1.6.35 - July 2018
	Updated	and distributed	by Glenn Randers-Pehrson
	Copyright (c) 1998-2018	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

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
       <https://www.w3.org/TR/2003/REC-PNG-20031110/>.	 The W3C and ISO docu-
       ments have identical technical content.

       The PNG-1.2  specification  is  available  at  <https://png-mng.source-
       forge.io/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  at	 <https://png-
       mng.sourceforge.io/pub/png/spec/1.0/>  and  as  a W3C Recommendation at
       <https://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, <https://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) == 0);
	   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,	NULL, 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  NULL instead of &end_info if you didn't create an end_info	struc-
       ture.

       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;
		  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
       processed 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
       columns.	 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 any chunk	other than IDAT	can occupy, originally or when
       decompressed (prior to libpng-1.6.32 the	limit was only applied to com-
       pressed chunks after decompression). 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);

       Choices for the alpha_mode are

	   PNG_ALPHA_PNG	   0 /*	according to the PNG standard */
	   PNG_ALPHA_STANDARD	   1 /*	according to Porter/Duff */
	   PNG_ALPHA_ASSOCIATED	    1 /* as above; this	is the normal practice
       */
	   PNG_ALPHA_PREMULTIPLIED 1 /*	as above */
	   PNG_ALPHA_OPTIMIZED	   2 /*	'PNG' for opaque pixels,  else	'STAN-
       DARD' */
	   PNG_ALPHA_BROKEN	   3 /*	the alpha channel is gamma encoded */

       PNG_ALPHA_PNG  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 preceded 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 were	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 output 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_alpha_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_bytep)))
	     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,  but
       first  be  sure	that  your  platform  is able to allocate such a large
       buffer:

	  /* Guard against integer overflow */
	  if (height > PNG_SIZE_MAX/(width*pixel_size))
	     png_error(png_ptr,	"image_data buffer would be too	large");

	  png_bytep buffer = png_malloc(png_ptr,
	     height*width*pixel_size);

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

	  png_set_rows(png_ptr,	info_ptr, &row_pointers);

       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
			    This value,	the bit_depth, color_type,
			    and	the number of channels can change
			    if you use transforms such as
			    png_set_expand(). See
			    png_read_update_info(), below.

	   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_eXIf_1(png_ptr, info_ptr, &num_exif,	&exif);

	   exif		  - Exif profile (array	of png_byte)
			    (PNG_INFO_eXIf)

	   png_get_hIST(png_ptr, info_ptr, &hist);

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

	   png_get_tIME(png_ptr, info_ptr, &mod_time);

	   mod_time	  - time image was last	modified
			    (PNG_INFO_tIME)

	   png_get_bKGD(png_ptr, info_ptr, &background);

	   background	  - background color (of type
			    png_color_16p) (PNG_INFO_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 omissions 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	trans-
       parency	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.

       Be sure that your platform can allocate the buffer  that	 you'll	 need.
       libpng internally checks	for oversize width, but	you'll need to do your
       own check for number_of_rows*width*pixel_size if	you are	using a	multi-
       ple-row buffer:

	  /* Guard against integer overflow */
	  if (number_of_rows > PNG_SIZE_MAX/(width*pixel_size))
	     png_error(png_ptr,	"image_data buffer would be too	large");

       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, 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,	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, 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_eXIf,
		    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,	NULL, NULL);
	      return ERROR;
	   }

	   if (setjmp(png_jmpbuf(png_ptr)))
	   {
	      png_destroy_read_struct(&png_ptr,	&info_ptr, 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, 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, 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
       processed 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	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.

       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_eXIf_1(png_ptr, info_ptr, num_exif, exif);

	   exif		  - Exif profile (array	of png_byte)
			    (PNG_INFO_eXIf)

	   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_INFO_tIME)

	   png_set_bKGD(png_ptr, info_ptr, background);

	   background	  - background color (of type
			    png_color_16p) (PNG_INFO_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 ancillary 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	color-
       spaces, the actual sRGB transfer	curve defined in the  sRGB  specifica-
       tion  (see  the article at https://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 that 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, 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	color-
       spaces, the actual sRGB transfer	curve defined in the  sRGB  specifica-
       tion  (see  the article at https://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, size_t length);

	   void	user_write_data(png_structp png_ptr,
	       png_bytep data, 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);

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

       Then,  within  your  user_error_fn or user_warning_fn, you can retrieve
       the error_ptr if	you need it, by	calling

	   png_voidp error_ptr = png_get_error_ptr(png_ptr);

       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
       https://cexcept.sourceforge.io/),  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 https://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)  ==  0  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() == 0, mem-
       cpy(), 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  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 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.22, default user limits were established.	 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().   The
       limits are now
				    max	possible  default
	  png_user_width_max	    0x7fffffff	  1,000,000
	  png_user_height_max	    0x7fffffff	  1,000,000
	  png_user_chunk_cache_max  0 (unlimited) 1000
	  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	libpng17 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	defin-
       ition 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.

       Starting	with libpng-1.6.31, the	eXIf chunk is supported.  Libpng  does
       not  attempt to decode the Exif profile;	it simply returns a byte array
       containing the profile to the calling application which must do its own
       decoding.

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

	   https://github.com/pnggroup/libpng or
	   https://git.code.sf.net/p/libpng/code.git

       or you can browse it with a web browser at

	   https://github.com/pnggroup/libpng or
	   https://sourceforge.net/p/libpng/code/ci/libpng16/tree/

       Patches	can  be	 sent to png-mng-implement at lists.sourceforge.net or
       uploaded	to the libpng bug tracker at

	   https://libpng.sourceforge.io/

       or as a "pull request" to

	   https://github.com/pnggroup/libpng/pulls

       We also accept patches built from the tar  or  zip  distributions,  and
       simple verbal descriptions of bug fixes,	reported either	to the Source-
       Forge  bug  tracker,  to	 the png-mng-implement at lists.sf.net mailing
       list, as	github issues.

XV. Coding style
       Our  coding   style   is	  similar   to	 the   "Allman"	  style	  (See
       https://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.

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.69			10    10069  10.so.0.69[.0]
	...
	1.2.59			13    10259  12.so.0.59[.0]
	...
	1.4.20			14    10420  14.so.0.20[.0]
	...
	1.5.30			15    10530  15.so.15.30[.0]
	...
	1.6.35			16    10635  16.so.16.35[.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
       png(5)

	      The PNG (Portable	Network	Graphics) format specification.

       libpng

	      http://www.libpng.org/pub/png/libpng.html	(canonical home	page)
	      https://github.com/pnggroup/libpng (canonical Git	repository)
	      https://libpng.sourceforge.io (downloadable archives)

       zlib

	      https://zlib.net (canonical home page)
	      https://github.com/madler/zlib (canonical	Git repository)
	      A	copy of	zlib may also be found at the same location as libpng.

       In the case of any inconsistency	between	the PNG	specification and this
       library,	the specification takes	precedence.

AUTHORS
       This  man page: Initially created by Glenn Randers-Pehrson.  Maintained
       by Cosmin Truta.

       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: Initially created in 1995 by Guy	Eric Schalnat, then  of	 Group
       42, Inc.	 Maintained by Cosmin Truta.

       Supported by the	PNG development	group.
       png-mng-implement  at lists.sourceforge.net. (Subscription is required;
       visit https://lists.sourceforge.net/lists/listinfo/png-mng-implement to
       subscribe.)

			       February	18, 2025		     LIBPNG(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=libpng&sektion=3&manpath=FreeBSD+Ports+14.3.quarterly>

home | help