
/* png.h - header file for png reference library
   libpng 1.0 beta 1 - version 0.71
   June 26, 1995

   Note: This is a beta version.  It reads and writes valid files
   on the platforms I have, but it has had limited portability
   testing.  Furthermore, you will probably have to modify the
   includes below to get it to work on your system, and you
   may have to supply the correct compiler flags in the makefile.
   Read the readme.txt for more information, and how to contact
   me if you have any problems, or if you want your compiler/
   platform to be supported in the next official libpng release.

   See readme.txt for more information

   Copyright (c) 1995 Guy Eric Schalnat, Group 42, Inc.
   Contributing Authors:
      Guy Eric Schalnat

   The PNG Reference Library is supplied "AS IS". The Contributing Authors
   and Group 42, Inc. disclaim all warranties, expressed or implied,
   including, without limitation, the warranties of merchantability and of
   fitness for any purpose. The Contributing Authors and Group 42, Inc.
   assume no liability for damages, direct or consequential, which may
   result from the use of the PNG Reference Library.

   Permission is hereby granted to use, copy, modify, and distribute this
   source code, or portions hereof, for any purpose, without fee, subject
   to the following restrictions:
   1. The origin of this source code must not be misrepresented.
   2. Altered versions must be plainly marked as such and must not be
     misrepresented as being the original source.
   3. This Copyright notice may not be removed or altered from any source or
     altered source distribution.

   The Contributing Authors and Group 42, Inc. specifically permit, without
   fee, and encourage the use of this source code as a component to
   supporting the PNG file format in commercial products. If you use this
   source code in a product, acknowledgment is not required but would be
   appreciated.
   */

#ifndef _PNG_H
#define _PNG_H

/* This is not the place to learn how to use libpng.  The file libpng.txt
   describes how to use libpng, and the file example.c summarizes it
   with some code to build around.  This file is useful for looking
   at the actual function definitions and structure components. */

/* This file is arranged in several sections.  The first section contains
   all the definitions for libpng.  The second section details the functions
   most users will use.  The third section describes the stub files that
   users will most likely need to change.  The last section contains
   functions used internally by the code.

   Any machine specific code is near the front of this file, so if you
   are configuring libpng for a machine, you may want to read the section
   starting here down to where it starts to typedef png_color, png_text,
   and png_info */

/* this is the size of the compression buffer, and thus the size of
   an IDAT chunk.  Make this whatever size you feel is best for your
   machine.  One of these will be allocated per png_struct.  When this
   is full, it writes the data to the disk, and does some other
   calculations.  Making this an extreamly small size will slow
   the library down, but you may want to experiment to determine
   where it becomes significant, if you are concerned with memory
   usage.  Note that zlib allocates at least 32Kb also.  For readers,
   this describes the size of the buffer available to read the data in.
   Unless this gets smaller then the size of a row (compressed),
   it should not make much difference how big this is.  */

#define PNG_ZBUF_SIZE 8192;

/* include the compression library's header */
#include "zlib.h"

/* While libpng currently uses zlib for it's compression, it has been designed
   to stand on it's own.  Towards this end, there are two defines that are
   used to help portability between machines.  To make it simpler to
   setup libpng on a machine, this currently uses zlib's definitions, so
   any changes should be made in zlib.  Libpng will check zlib's settings
   and adjust it's own accordingly. */

/* if you are running on a machine where you cannot allocate more then
   64K of memory, uncomment this.  While libpng will not normally need
   that much memory in a chunk (unless you load up a very large file),
   zlib needs to know how big of a chunk it can use, and libpng thus
   makes sure to check any memory allocation to verify it will fit
   into memory.
#define PNG_MAX_ALLOC_64K
*/
#ifdef MAXSEG_64K
#define PNG_MAX_ALLOC_64K
#endif

/* this macro protects us against machines that don't have function
   prototypes.  If your compiler does not handle function prototypes,
   define this macro.  I've always been able to use _NO_PROTO as the
   indicator, but you may need to drag the empty declaration out in
   front of here, or change the ifdef to suit your own needs. */
#ifndef PNGARG

#ifdef __P
#define PNGARG(arglist) __P(arglist)
#else

#ifdef _NO_PROTO
#define PNGARG(arglist)
#else
#define PNGARG(arglist) arglist
#endif /* _NO_PROTO */

#endif /* __P(arglist) */

#endif /* PNGARG */

/* enough people need this for various reasons to include it here */
#include <sys/types.h>
/* need the time information for reading tIME chunks */
#include <time.h>

/* for FILE.  If you are not using standard io, you don't need this */
#include <stdio.h>

/* include setjmp.h for error handling */
#include <setjmp.h>

/* other defines for things like memory and the like can go here.  These
   are the only files included in libpng, so if you need to change them,
   change them here.  They are only included if PNG_INTERNAL is defined. */
#ifdef PNG_INTERNAL
#include <stdlib.h>
#include <ctype.h>
#ifdef BSD
#include <strings.h>
#else
#include <string.h>
#endif
#include <math.h>

/* other defines specific to compilers can go here.  Try to keep
   them inside an appropriate ifdef/endif pair for portability */

/* for some reason, Borland C++ defines memcmp, etc. in mem.h, not
   stdlib.h like it should (I think).  Or perhaps this is a C++
   feature */
#ifdef __TURBOC__
#include <mem.h>
#include "alloc.h"
#endif

#ifdef _MSC_VER
#include <malloc.h>
#endif

/* this controls how fine the dithering gets.  As this allocates
   a largish chunk of memory (32K), those who are not as concerned
   with dithering quality can decrease some or all of these */
#define PNG_DITHER_RED_BITS 5
#define PNG_DITHER_GREEN_BITS 5
#define PNG_DITHER_BLUE_BITS 5

/* this controls how fine the gamma correction becomes when you
   are only interested in 8 bits anyway.  Increasing this value
   results in more memory being used, and more pow() functions
   being called to fill in the gamma tables.  Don't get this
   value less then 8, and even that may not work (I haven't tested
   it). */

#define PNG_MAX_GAMMA_8 11

#endif /* PNG_INTERNAL */

/* some typedefs to get us started.  These should be safe on most of the
   common platforms.  The typedefs should be at least as large
   as the numbers suggest (a png_uint_32 must be at least 32 bits long),
   but they don't have to be exactly that size. */

typedef unsigned long png_uint_32;
typedef long png_int_32;
typedef unsigned short png_uint_16;
typedef short png_int_16;
typedef unsigned char png_byte;

/* this is usually size_t. it is typedef'ed just in case you need it to
   change (I'm not sure if you will or not, so I thought I'd be safe) */
typedef size_t png_size_t;

/* three color definitions.  The order of the red, green, and blue, (and the
   exact size) is not important, although the size of the fields need to
   be png_byte or png_uint_16 (as defined below).  While png_color_8 and
   png_color_16 have more fields then they need, they are never used in
   arrays, so the size isn't that important.  I thought about using
   unions, but it looked too clumsy, so I left it. If you're using C++,
   you can union red, index, and gray, if you want. */
typedef struct png_color_struct
{
   png_byte red;
   png_byte green;
   png_byte blue;
} png_color;

typedef struct png_color_16_struct
{
   png_byte index; /* used for palette files */
   png_uint_16 red; /* for use in red green blue files */
   png_uint_16 green;
   png_uint_16 blue;
   png_uint_16 gray; /* for use in grayscale files */
} png_color_16;

typedef struct png_color_8_struct
{
   png_byte red; /* for use in red green blue files */
   png_byte green;
   png_byte blue;
   png_byte gray; /* for use in grayscale files */
   png_byte alpha; /* for alpha channel files */
} png_color_8;

/* png_text holds the text in a png file, and whether they are compressed
   or not.  If compression is -1, the text is not compressed.  */
typedef struct png_text_struct
{
   int compression; /* compression value, -1 if uncompressed */
   char *key; /* keyword */
   char *text; /* comment */
   png_uint_32 text_length; /* length of text field */
} png_text;

/* png_time is a way to hold the time in an machine independent way.
   Two conversions are provided, both from time_t and struct tm.  There
   is no portable way to convert to either of these structures, as far
   as I know.  If you know of a portable way, send it to me. */
typedef struct png_time_struct
{
   png_uint_16 year; /* full year, as in, 1995 */
   png_byte month; /* month of year, 1 - 12 */
   png_byte day; /* day of month, 1 - 31 */
   png_byte hour; /* hour of day, 0 - 23 */
   png_byte minute; /* minute of hour, 0 - 59 */
   png_byte second; /* second of minute, 0 - 60 (for leap seconds) */
} png_time;

/* png_info is a structure that holds the information in a png file.
   If you are reading the file, This structure will tell you what is
   in the png file.  If you are writing the file, fill in the information
   you want to put into the png file, then call png_write_info().
   The names chosen should be very close to the PNG
   specification, so consult that document for information
   about the meaning of each field. */
typedef struct png_info_struct
{
   /* the following are necessary for every png file */
   png_uint_32 width; /* with of file */
   png_uint_32 height; /* height of file */
   png_byte bit_depth; /* 1, 2, 4, 8, or 16 */
   png_byte color_type; /* use the PNG_COLOR_TYPE_ defines */
   png_byte compression_type; /* must be 0 */
   png_byte filter_type; /* must be 0 */
   png_byte interlace_type; /* 0 for non-interlaced, 1 for interlaced */
   png_uint_32 valid; /* the PNG_INFO_ defines, OR'd together */
   /* the following is informational only on read, and not used on
      writes */
   png_byte channels; /* number of channels of data per pixel */
   png_byte pixel_depth; /* number of bits per pixel */
   png_uint_32 rowbytes; /* bytes needed for untransformed row */
   /* the rest are optional.  If you are reading, check the valid
      field to see if the information in these are valid.  If you
      are writing, set the valid field to those chunks you want
      written, and initialize the appropriate fields below */
   float gamma; /* gamma value of file, if gAMA chunk is valid */
   png_color_8 sig_bit; /* significant bits */
   float x_white; /* cHRM chunk values */
   float y_white;
   float x_red;
   float y_red;
   float x_green;
   float y_green;
   float x_blue;
   float y_blue;
   png_color *palette; /* palette of file */
   png_uint_16 num_palette; /* number of values in palette */
   png_byte *trans; /* tRNS values for palette image */
    png_uint_16 num_trans; /* number of trans values */
   png_color_16 trans_values; /* tRNS values for non-palette image */
   png_color_16 background; /* background color of image */
   png_uint_16 *hist; /* histogram of palette usage */
   png_uint_32 x_pixels_per_unit; /* x resolution */
   png_uint_32 y_pixels_per_unit; /* y resolution */
   png_byte phys_unit_type; /* resolution type */
   png_uint_32 x_offset; /* x offset on page */
   png_uint_32 y_offset; /* y offset on page */
   png_byte offset_unit_type; /* offset units type */
   png_time mod_time; /* modification time */
   int num_text; /* number of comments */
   int max_text; /* size of text array */
   png_text *text; /* array of comments */
} png_info;

#define PNG_RESOLUTION_UNKNOWN 0
#define PNG_RESOLUTION_METER 1

#define PNG_OFFSET_PIXEL 0
#define PNG_OFFSET_MICROMETER 1

/* these describe the color_type field in png_info */

/* color type masks */
#define PNG_COLOR_MASK_PALETTE 1
#define PNG_COLOR_MASK_COLOR 2
#define PNG_COLOR_MASK_ALPHA 4

/* color types.  Note that not all combinations are legal */
#define PNG_COLOR_TYPE_PALETTE \
   (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)
#define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR)
#define PNG_COLOR_TYPE_GRAY 0
#define PNG_COLOR_TYPE_RGB_ALPHA \
   (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)
#define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA)

/* These determine if a chunks information is present in a read operation, or
   if the chunk should be written in a write operation.  */
#define PNG_INFO_gAMA 0x0001
#define PNG_INFO_sBIT 0x0002
#define PNG_INFO_cHRM 0x0004
#define PNG_INFO_PLTE 0x0008
#define PNG_INFO_tRNS 0x0010
#define PNG_INFO_bKGD 0x0020
#define PNG_INFO_hIST 0x0040
#define PNG_INFO_pHYs 0x0080
#define PNG_INFO_oFFs 0x0100
#define PNG_INFO_tIME 0x0200

/* this is used for the transformation routines, as some of them
   change these values for the row.  It also should enable using
   the routines for other uses. */
typedef struct png_row_info_struct
{
   png_uint_32 width; /* width of row */
   png_uint_32 rowbytes; /* number of bytes in row */
   png_byte color_type; /* color type of row */
   png_byte bit_depth; /* bit depth of row */
   png_byte channels; /* number of channels (1, 2, 3, or 4) */
   png_byte pixel_depth; /* bits per pixel (depth * channels) */
} png_row_info;

/* The structure that holds the information to read and write png files.
   The only people who need to care about what is inside of this are the
   people who will be modifying the library for their own special needs.
   */
typedef struct png_struct_def
{
   jmp_buf jmpbuf; /* used in png_error */
   png_byte mode; /* used to determine where we are in the png file */
   png_byte color_type; /* color type of file */
   png_byte bit_depth; /* bit depth of file */
   png_byte interlaced; /* interlace type of file */
   png_byte compession; /* compression type of file */
   png_byte filter; /* filter type */
   png_byte channels; /* number of channels in file */
   png_byte pixel_depth; /* number of bits per pixel */
   png_byte usr_bit_depth; /* bit depth of users row */
   png_byte usr_channels; /* channels at start of write */
   png_byte gamma_shift; /* amount of shift for 16 bit gammas */
   png_byte pass; /* current pass (0 - 6) */
   png_byte row_init; /* 1 if png_read_start_row() has been called */
   png_byte background_gamma_type;
   png_byte background_expand;
   png_byte zlib_finished;
   png_byte user_palette;
   png_uint_16 num_palette; /* number of entries in palette */
   png_uint_16 num_trans; /* number of transparency values */
   png_uint_32 transformations; /* which transformations to perform */
   png_uint_32 crc; /* current crc value */
   png_uint_32 width; /* width of file */
   png_uint_32 height; /* height of file */
   png_uint_32 num_rows; /* number of rows in current pass */
   png_uint_32 rowbytes; /* size of row in bytes */
   png_uint_32 usr_width; /* width of row at start of write */
   png_uint_32 iwidth; /* interlaced width */
   png_uint_32 irowbytes; /* interlaced rowbytes */
   png_uint_32 row_number; /* current row in pass */
   png_uint_32 idat_size; /* current idat size for read */
   png_uint_32 zbuf_size; /* size of zbuf */
   png_color *palette; /* files palette */
   png_byte *palette_lookup; /* lookup table for dithering */
   png_byte *gamma_table; /* gamma table for 8 bit depth files */
   png_byte *gamma_from_1; /* converts from 1.0 to screen */
   png_byte *gamma_to_1; /* converts from file to 1.0 */
   png_byte *trans; /* transparency values for paletted files */
   png_byte *dither_index; /* index translation for palette files */
   png_uint_16 **gamma_16_table; /* gamma table for 16 bit depth files */
   png_uint_16 **gamma_16_from_1; /* converts from 1.0 to screen */
   png_uint_16 **gamma_16_to_1; /* converts from file to 1.0 */
   png_uint_16 *hist; /* histogram */
   png_byte *zbuf; /* buffer for zlib */
   png_byte *row_buf; /* row buffer */
   png_byte *prev_row; /* previous row */
   png_byte *save_row; /* place to save row before filtering */
   z_stream *zstream; /* pointer to decompression structure (below) */
   float gamma; /* file gamma value */
   float display_gamma; /* display gamma value */
   float background_gamma;
   png_color_8 shift; /* shift for significant bit tranformation */
   png_color_8 sig_bit; /* significant bits in file */
   png_color_16 trans_values; /* transparency values for non-paletted files */
   png_color_16 background; /* background color, gamma corrected for screen */
   png_color_16 background_1; /* background normalized to gamma 1.0 */
   png_row_info row_info; /* used for transformation routines */
   z_stream zstream_struct; /* decompression structure */
   FILE *fp; /* used for png_read and png_write */
} png_struct;


/* Here are the function definitions most commonly used.  This is not
   the place to find out how to use libpng.  See libpng.txt for the
   full explanation, see example.c for the summary.  This just provides
   a simple one line of the use of each function. */

/* check the first 1 - 8 bytes to see if it is a png file */
extern int png_check_sig PNGARG((png_byte *sig, int num));

/* initialize png structure for reading, and allocate any memory needed */
extern void png_read_init PNGARG((png_struct *png_ptr));

/* initialize png structure for writing, and allocate any memory needed */
extern void png_write_init PNGARG((png_struct *png_ptr));

/* initialize the info structure */
extern void png_info_init PNGARG((png_info *info));

/* Writes all the png information before the image. */
extern void png_write_info PNGARG((png_struct *png_ptr, png_info *info));

/* read the information before the actual image data. */
extern void png_read_info PNGARG((png_struct *png_ptr, png_info *info));

/* convert from a struct tm to png_time */
extern void png_convert_from_struct_tm PNGARG((png_time *ptime,
   struct tm *ttime));

/* convert from time_t to png_time.  Uses gmtime() */
extern void png_convert_from_time_t PNGARG((png_time *ptime, time_t ttime));

/* Expand the data to 24 bit RGB, or 8 bit Grayscale,
   with alpha if necessary. */
extern void png_set_expand PNGARG((png_struct *png_ptr));

/* Use blue, green, red order for pixels. */
extern void png_set_bgr PNGARG((png_struct *png_ptr));

/* Add a filler byte to rgb images after the colors. */
extern void png_set_rgbx PNGARG((png_struct *png_ptr));

/* Add a filler byte to rgb images before the colors. */
extern void png_set_xrgb PNGARG((png_struct *png_ptr));

/* Swap bytes in 16 bit depth files. */
extern void png_set_swap PNGARG((png_struct *png_ptr));

/* Use 1 byte per pixel in 1, 2, or 4 bit depth files. */
extern void png_set_packing PNGARG((png_struct *png_ptr));

/* Converts files to legal bit depths. */
extern void png_set_shift PNGARG((png_struct *png_ptr,
   png_color_8 *true_bits));

/* Have the code handle the interlacing.  Returns the number of passes. */
extern int png_set_interlace_handling PNGARG((png_struct *png_ptr));

/* Invert monocrome files */
extern void png_set_invert_mono PNGARG((png_struct *png_ptr));

/* Handle alpha and tRNS by replacing with a background color. */
#define PNG_BACKGROUND_GAMMA_SCREEN 0
#define PNG_BACKGROUND_GAMMA_FILE 1
#define PNG_BACKGROUND_GAMMA_UNIQUE 2
#define PNG_BACKGROUND_GAMMA_UNKNOWN 3
extern void png_set_background PNGARG((png_struct *png_ptr,
   png_color_16 *background_color, int background_gamma_code,
   int need_expand, float background_gamma));

/* strip the second byte of information from a 16 bit depth file. */
extern void png_set_strip_16 PNGARG((png_struct *png_ptr));

/* convert a grayscale file into rgb. */
extern void png_set_gray_to_rgb PNGARG((png_struct *png_ptr));

/* Turn on dithering, and reduce the palette to the number of colors available. */
extern void png_set_dither PNGARG((png_struct *png_ptr, png_color *palette,
   int num_palette, int maximum_colors, png_uint_16 *histogram, int full_dither));

/* Handle gamma correction. */
extern void png_set_gamma PNGARG((png_struct *png_ptr, float screen_gamma,
   float default_file_gamma));

/* optional update palette with requested transformations */
void png_start_read_image PNGARG((png_struct *png_ptr));

/* read a one or more rows of image data.*/
extern void png_read_rows PNGARG((png_struct *png_ptr,
   png_byte **row,
   png_byte **display_row, png_uint_32 num_rows));

/* read a row of data.*/
extern void png_read_row PNGARG((png_struct *png_ptr,
   png_byte *row,
   png_byte *display_row));

/* read the whole image into memory at once. */
extern void png_read_image PNGARG((png_struct *png_ptr,
   png_byte **image));

/* write a row of image data */
extern void png_write_row PNGARG((png_struct *png_ptr,
   png_byte *row));

/* write a few rows of image data */
extern void png_write_rows PNGARG((png_struct *png_ptr,
   png_byte **row,
   png_uint_32 num_rows));

/* write the image data */
extern void png_write_image PNGARG((png_struct *png_ptr, png_byte **image));

/* writes the end of the png file. */
extern void png_write_end PNGARG((png_struct *png_ptr, png_info *info));

/* read the end of the png file. */
extern void png_read_end PNGARG((png_struct *png_ptr, png_info *info));

/* free all memory used by the read */
extern void png_read_destroy PNGARG((png_struct *png_ptr, png_info *info,
   png_info *end_info));

/* free any memory used in png struct */
extern void png_write_destroy PNGARG((png_struct *png_ptr));


/* These next functions are stubs of typical c functions for input/output,
   memory, and error handling.  They are in the file pngstub.c, and are
   set up to be easily modified for users that need to.  See the file
   pngstub.c for more information */

/* Write the data to whatever output you are using. */
extern void png_write_data PNGARG((png_struct *png_ptr, png_byte *data,
   png_uint_32 length));

/* Read data from whatever input you are using */
extern void png_read_data PNGARG((png_struct *png_ptr, png_byte *data,
   png_uint_32 length));

/* Initialize the input/output for the png file. */
extern void png_init_io PNGARG((png_struct *png_ptr, FILE *fp));

/* Allocate memory in larger chunks. */
extern void *png_large_malloc PNGARG((png_struct *png_ptr, png_uint_32 size));

/* free's a pointer allocated by png_large_malloc() */
extern void png_large_free PNGARG((png_struct *png_ptr, void *ptr));

/* Allocate memory. */
extern void *png_malloc PNGARG((png_struct *png_ptr, png_uint_32 size));

/* Reallocate memory. */
extern void *png_realloc PNGARG((png_struct *png_ptr, void *ptr,
   png_uint_32 size));

/* free's a pointer allocated by png_malloc() */
extern void png_free PNGARG((png_struct *png_ptr, void *ptr));

/* Fatal error in libpng - can't continue */
extern void png_error PNGARG((png_struct *png_ptr, char *error));

/* Non-fatal error in libpng.  Can continue, but may have a problem. */
extern void png_warning PNGARG((png_struct *png_ptr, char *message));


/* These next functions are used internally in the code.  If you use
   them, make sure you read and understand the png spec.  More information
   about them can be found in the files where the functions are.
   Feel free to move any of these outside the PNG_INTERNAL define if
   you just need a few of them, but if you need access to more, you should
   define PNG_INTERNAL inside your code, so everyone who includes png.h
   won't get yet another definition the compiler has to deal with. */

#ifdef PNG_INTERNAL

/* various modes of operation.  Note that after an init, mode is set to
   zero automatically */
#define PNG_BEFORE_IHDR 0
#define PNG_HAVE_IHDR 1
#define PNG_HAVE_PLTE 2
#define PNG_HAVE_IDAT 3
#define PNG_AT_LAST_IDAT 4
#define PNG_AFTER_IDAT 5
#define PNG_AFTER_IEND 6

/* defines for the transformations the png library does on the image data */
#define PNG_BGR 0x0001
#define PNG_INTERLACE 0x0002
#define PNG_PACK 0x0004
#define PNG_SHIFT 0x0008
#define PNG_SWAP_BYTES 0x0010
#define PNG_INVERT_MONO 0x0020
#define PNG_DITHER 0x0040
#define PNG_BACKGROUND 0x0080
#define PNG_XRGB 0x0100
#define PNG_16_TO_8 0x0200
#define PNG_RGBA 0x0400
#define PNG_EXPAND 0x0800
#define PNG_GAMMA 0x1000
#define PNG_GRAY_TO_RGB 0x2000

/* save typing and make code easier to understand */
#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \
   abs((int)((c1).green) - (int)((c2).green)) + \
   abs((int)((c1).blue) - (int)((c2).blue)))

/* variables defined in png.c - only it needs to define PNG_NO_EXTERN */
#ifndef PNG_NO_EXTERN
/* place to hold the signiture string for a png file. */
extern png_byte png_sig[];

/* constant strings for known chunk types.  If you need to add a chunk,
   add a string holding the name here.  See png.c for more details */
extern png_byte png_IHDR[];
extern png_byte png_IDAT[];
extern png_byte png_IEND[];
extern png_byte png_PLTE[];
extern png_byte png_gAMA[];
extern png_byte png_sBIT[];
extern png_byte png_cHRM[];
extern png_byte png_tRNS[];
extern png_byte png_bKGD[];
extern png_byte png_hIST[];
extern png_byte png_tEXt[];
extern png_byte png_zTXt[];
extern png_byte png_pHYs[];
extern png_byte png_oFFs[];
extern png_byte png_tIME[];
/* Structures to facilitate easy interlacing.  See png.c for more details */
extern int png_pass_start[];
extern int png_pass_inc[];
extern int png_pass_ystart[];
extern int png_pass_yinc[];
/* these are not currently used.  If you need them, see png.c
extern int png_pass_width[];
extern int png_pass_height[];
*/
extern int png_pass_mask[];
extern int png_pass_dsp_mask[];

#endif /* PNG_NO_EXTERN */

/* Function to allocate memory for zlib. */
extern voidp png_zalloc PNGARG((voidp png_ptr, uInt items, uInt size));

/* function to free memory for zlib */
extern void png_zfree PNGARG((voidp png_ptr, voidp ptr));

/* reset the crc variable */
extern void png_reset_crc PNGARG((png_struct *png_ptr));

/* calculate the crc over a section of data.  Note that while we
   are passing in a 32 bit value for length, on 16 bit machines, you
   would need to use huge pointers to access all that data.  See the
   code in png.c for more information. */
extern void png_calculate_crc PNGARG((png_struct *png_ptr, png_byte *ptr,
   png_uint_32 length));

/* place a 32 bit number into a buffer in png byte order.  We work
   with unsigned numbers for convenience, you may have to cast
   signed numbers (if you use any, most png data is unsigned). */
extern void png_save_uint_32 PNGARG((png_byte *buf, png_uint_32 i));

/* place a 16 bit number into a buffer in png byte order */
extern void png_save_uint_16 PNGARG((png_byte *buf, png_uint_16 i));

/* write a 32 bit number */
extern void png_write_uint_32 PNGARG((png_struct *png_ptr, png_uint_32 i));

/* write a 16 bit number */
extern void png_write_uint_16 PNGARG((png_struct *png_ptr, png_uint_16 i));

/* Write a png chunk.  */
extern void png_write_chunk PNGARG((png_struct *png_ptr, png_byte *type,
   png_byte *data, png_uint_32 length));

/* Write the start of a png chunk. */
extern void png_write_chunk_start PNGARG((png_struct *png_ptr, png_byte *type,
   png_uint_32 total_length));

/* write the data of a png chunk started with png_write_chunk_start(). */
extern void png_write_chunk_data PNGARG((png_struct *png_ptr, png_byte *data,
   png_uint_32 length));

/* finish a chunk started with png_write_chunk_start() */
extern void png_write_chunk_end PNGARG((png_struct *png_ptr));

/* simple function to write the signiture */
extern void png_write_sig PNGARG((png_struct *png_ptr));

/* write various chunks */

/* Write the IHDR chunk, and update the png_struct with the necessary
   information. */
extern void png_write_IHDR PNGARG((png_struct *png_ptr, png_uint_32 width,
   png_uint_32 height,
   int bit_depth, int color_type, int compression_type, int filter_type,
   int interlace_type));

extern void png_write_PLTE PNGARG((png_struct *png_ptr, png_color *palette,
   int number));

extern void png_write_IDAT PNGARG((png_struct *png_ptr, png_byte *data,
   png_uint_32 length));

extern void png_write_IEND PNGARG((png_struct *png_ptr));

extern void png_write_gAMA PNGARG((png_struct *png_ptr, float gamma));

extern void png_write_sBIT PNGARG((png_struct *png_ptr, png_color_8 *sbit,
   int color_type));

extern void png_write_cHRM PNGARG((png_struct *png_ptr,
   float white_x, float white_y,
   float red_x, float red_y, float green_x, float green_y,
   float blue_x, float blue_y));

extern void png_write_tRNS PNGARG((png_struct *png_ptr, png_byte *trans,
   png_color_16 *values, int number, int color_type));

extern void png_write_bKGD PNGARG((png_struct *png_ptr, png_color_16 *values,
   int color_type));

extern void png_write_hIST PNGARG((png_struct *png_ptr, png_uint_16 *hist,
   int number));

extern void png_write_tEXt PNGARG((png_struct *png_ptr, char *key,
   char *text, png_uint_32 text_len));

extern void png_write_zTXt PNGARG((png_struct *png_ptr, char *key,
   char *text, png_uint_32 text_len, int compression));

extern void png_write_pHYs PNGARG((png_struct *png_ptr,
   png_uint_32 x_pixels_per_unit,
   png_uint_32 y_pixels_per_unit,
   int unit_type));

extern void png_write_oFFs PNGARG((png_struct *png_ptr,
   png_uint_32 x_offset,
   png_uint_32 y_offset,
   int unit_type));

extern void png_write_tIME PNGARG((png_struct *png_ptr, png_time *mod_time));

/* Internal use only.   Called when finished processing a row of data */
extern void png_write_finish_row PNGARG((png_struct *png_ptr));

/* Internal use only.   Called before first row of data */
extern void png_write_start_row PNGARG((png_struct *png_ptr));

/* callbacks for png chunks */
extern void png_read_IHDR PNGARG((png_struct *png_ptr, png_info *info,
   png_uint_32 width, png_uint_32 height, int bit_depth,
   int color_type, int compression_type, int filter_type,
   int interlace_type));
extern void png_read_PLTE PNGARG((png_struct *png_ptr, png_info *info,
   png_color *palette, int num));
extern void png_read_gAMA PNGARG((png_struct *png_ptr, png_info *info,
   float gamma));
extern void png_read_sBIT PNGARG((png_struct *png_ptr, png_info *info,
   png_color_8 *sig_bit));
extern void png_read_cHRM PNGARG((png_struct *png_ptr, png_info *info,
   float white_x, float white_y, float red_x, float red_y,
   float green_x, float green_y, float blue_x, float blue_y));
extern void png_read_tRNS PNGARG((png_struct *png_ptr, png_info *info,
   png_byte *trans, int num_trans,   png_color_16 *trans_values));
extern void png_read_bKGD PNGARG((png_struct *png_ptr, png_info *info,
   png_color_16 *background));
extern void png_read_hIST PNGARG((png_struct *png_ptr, png_info *info,
   png_uint_16 *hist));
extern void png_read_pHYs PNGARG((png_struct *png_ptr, png_info *info,
   png_uint_32 res_x, png_uint_32 res_y, int unit_type));
extern void png_read_oFFs PNGARG((png_struct *png_ptr, png_info *info,
   png_uint_32 offset_x, png_uint_32 offset_y, int unit_type));
extern void png_read_tIME PNGARG((png_struct *png_ptr, png_info *info,
   png_time *mod_time));
extern void png_read_tEXt PNGARG((png_struct *png_ptr, png_info *info,
   char *key, char *text, png_uint_32 text_len));
extern void png_read_zTXt PNGARG((png_struct *png_ptr, png_info *info,
   char *key, char *text, png_uint_32 text_len, int compression));

void
png_build_gamma_table PNGARG((png_struct *png_ptr));

/* combine a row of data, dealing with alpha, etc. if requested */
extern void png_combine_row PNGARG((png_struct *png_ptr, png_byte *row,
   int mask));
/* expand an interlaced row */
extern void png_do_read_interlace PNGARG((png_row_info *row_info,
   png_byte *row, int pass));
/* grab pixels out of a row for an interlaced pass */
extern void png_do_write_interlace PNGARG((png_row_info *row_info,
   png_byte *row, int pass));

/* unfilter a row */
extern void png_read_filter_row PNGARG((png_row_info *row_info,
   png_byte *row, png_byte *prev_row, int filter));
/* filter a row, and place the correct filter byte in the row */
extern void png_write_filter_row PNGARG((png_row_info *row_info,
   png_byte *row, png_byte *prev_row));
/* finish a row while reading, dealing with interlacing passes, etc. */
extern void png_read_finish_row PNGARG((png_struct *png_ptr));
/* initialize the row buffers, etc. */
extern void png_read_start_row PNGARG((png_struct *png_ptr));

/* these are the functions that do the transformations */
extern void png_do_read_rgbx PNGARG((png_row_info *row_info,
   png_byte *row));
extern void png_do_write_rgbx PNGARG((png_row_info *row_info,
   png_byte *row));
extern void png_do_read_xrgb PNGARG((png_row_info *row_info,
   png_byte *row));
extern void png_do_write_xrgb PNGARG((png_row_info *row_info,
   png_byte *row));
extern void png_do_swap PNGARG((png_row_info *row_info, png_byte *row));
extern void png_do_unpack PNGARG((png_row_info *row_info, png_byte *row));
extern void png_do_unshift PNGARG((png_row_info *row_info, png_byte *row,
   png_color_8 *sig_bits));
extern void png_do_invert PNGARG((png_row_info *row_info, png_byte *row));
extern void png_do_gray_to_rgb PNGARG((png_row_info *row_info,
   png_byte *row));
extern void png_do_chop PNGARG((png_row_info *row_info, png_byte *row));
extern void png_do_dither PNGARG((png_row_info *row_info,
   png_byte *row, png_byte *palette_lookup, png_byte *dither_lookup));
extern void png_do_bgr PNGARG((png_row_info *row_info, png_byte *row));
extern void png_do_pack PNGARG((png_row_info *row_info,
   png_byte *row, png_byte bit_depth));
extern void png_do_shift PNGARG((png_row_info *row_info, png_byte *row,
   png_color_8 *bit_depth));
extern void png_do_background PNGARG((png_row_info *row_info, png_byte *row,
   png_color_16 *trans_values, png_color_16 *background,
   png_color_16 *background_1,
   png_byte *gamma_table, png_byte *gamma_from_1, png_byte *gamma_to_1,
   png_uint_16 **gamma_16, png_uint_16 **gamma_16_from_1,
   png_uint_16 **gamma_16_to_1, int gamma_shift));
extern void png_do_gamma PNGARG((png_row_info *row_info, png_byte *row,
   png_byte *gamma_table, png_uint_16 **gamma_16_table,
   int gamma_shift));
extern void png_do_expand_palette PNGARG((png_row_info *row_info,
   png_byte *row, png_color *palette, png_byte *trans, int num_trans));
extern void png_do_expand PNGARG((png_row_info *row_info,
   png_byte *row, png_color_16 *trans_value));

/* unpack 16 and 32 bit values from a string */
extern png_uint_32 png_get_uint_32 PNGARG((png_byte *buf));
extern png_uint_16 png_get_uint_16 PNGARG((png_byte *buf));

/* read bytes into buf, and update png_ptr->crc */
extern void png_crc_read PNGARG((png_struct *png_ptr, png_byte *buf,
   png_uint_32 length));
/* skip length bytes, and update png_ptr->crc */
extern void png_crc_skip PNGARG((png_struct *png_ptr, png_uint_32 length));

/* the following decodes the appropriate chunks, and does error correction,
   then calls the appropriate callback for the chunk if it is valid */

/* decode the IHDR chunk */
extern void png_handle_IHDR PNGARG((png_struct *png_ptr, png_info *info,
   png_uint_32 length));
extern void png_handle_PLTE PNGARG((png_struct *png_ptr, png_info *info,
   png_uint_32 length));
extern void png_handle_gAMA PNGARG((png_struct *png_ptr, png_info *info,
   png_uint_32 length));
extern void png_handle_sBIT PNGARG((png_struct *png_ptr, png_info *info, 
   png_uint_32 length));
extern void png_handle_cHRM PNGARG((png_struct *png_ptr, png_info *info, 
   png_uint_32 length));
extern void png_handle_tRNS PNGARG((png_struct *png_ptr, png_info *info, 
   png_uint_32 length));
extern void png_handle_bKGD PNGARG((png_struct *png_ptr, png_info *info, 
   png_uint_32 length));
extern void png_handle_hIST PNGARG((png_struct *png_ptr, png_info *info, 
   png_uint_32 length));
extern void png_handle_pHYs PNGARG((png_struct *png_ptr, png_info *info, 
   png_uint_32 length));
extern void png_handle_oFFs PNGARG((png_struct *png_ptr, png_info *info, 
   png_uint_32 length));
extern void png_handle_tIME PNGARG((png_struct *png_ptr, png_info *info, 
   png_uint_32 length));
extern void png_handle_tEXt PNGARG((png_struct *png_ptr, png_info *info, 
   png_uint_32 length));
extern void png_handle_zTXt PNGARG((png_struct *png_ptr, png_info *info, 
   png_uint_32 length));

/* handle the transformations for reading and writing */
extern void png_do_read_transformations PNGARG((png_struct *png_ptr));
extern void png_do_write_transformations PNGARG((png_struct *png_ptr));

extern void png_init_read_transformations PNGARG((png_struct *png_ptr));


#endif /* PNG_INTERNAL */

/* do not put anything past this line */
#endif /* _PNG_H */