
Installing libpng version 1.0.11 - April 27, 2001

Before installing libpng, you must first install zlib.  zlib
can usually be found wherever you got libpng.  zlib can be
placed in another directory, at the same level as libpng.
Note that your system might already have a preinstalled
zlib, but you will still need to have access to the
zlib.h and zconf.h include files that correspond to the
version of zlib that's installed.

You can rename the directories that you downloaded (they
might be called "libpng-1.0.11" or "lpng109" and "zlib-1.1.3"
or "zlib113") so that you have directories called "zlib" and "libpng".

Your directory structure should look like this:

   ..       (the parent directory)
      libpng  (this directory)
          INSTALL (this file)
          README
          *.h
          *.c
          contrib
             gregbook
             msvctest
             pngminus
             pngsuite
             visupng
          projects
             beos
             borland
             msvc
             wince
          scripts
             makefile.*
          pngtest.png
          etc.
      zlib
          README
          *.h
          *.c
          contrib
          etc.

If the line endings in the files look funny, you may wish to get the other
distribution of libpng.  It is available in both tar.gz (UNIX style line
endings) and zip (DOS style line endings) formats.

If you are building libpng with MSVC, you can enter the libpng\msvc directory
and follow the instructions in msvc\README.txt.  You can build libpng for
WindowsCE by entering the libpng\wince directory and following the
instructions in the README* files.

Else enter the zlib directory and follow the instructions in zlib/README,
then come back here and choose the appropriate makefile.sys in the scripts
directory.

The files that are presently available in the scripts directory
include

 makefile.std      =>  Generic UNIX makefile (cc, creates static libpng.a)
 makefile.linux    =>  Linux/ELF makefile (gcc, creates libpng.so.2.1.0.11)
 makefile.gcmmx    =>  Linux/ELF makefile (gcc, creates libpng.so.2.1.0.11,
                       uses assembler code tuned for Intel MMX platform)
 makefile.gcc      =>  Generic makefile (gcc, creates static libpng.a)
 makefile.knr      =>  Archaic UNIX Makefile that converts files with
                       ansi2knr (Requires ansi2knr.c from
                       ftp://ftp.cs.wisc.edu/ghost)
 makefile.aix      =>  AIX makefile
 makefile.cygwin   =>  Cygwin/gcc makefile
 makefile.dec      =>  DEC Alpha UNIX makefile
 makefile.hpgcc    =>  HPUX makefile using gcc
 makefile.hpux     =>  HPUX (10.20 and 11.00) makefile
 makefile.ibmc     =>  IBM C/C++ version 3.x for Win32 and OS/2 (static)
 makefile.intel    =>  Intel C/C++ version 4.0 and later
 libpng.icc        =>  Project file for IBM VisualAge/C++ version 4.0 or later
 makefile.macosx   =>  MACOS X Makefile
 makefile.netbsd   =>  NetBSD/cc makefile, uses PNGGCCRD
 makefile.sgi      =>  Silicon Graphics IRIX makefile (cc, creates static lib)
 makefile.sggcc    =>  Silicon Graphics (gcc, creates libpng.so.2.1.0.11)
 makefile.sunos    =>  Sun makefile
 makefile.solaris  =>  Solaris 2.X makefile (gcc, creates libpng.so.2.1.0.11)
 makefile.sco      =>  For SCO OSr5  ELF and Unixware 7 with Native cc
 makefile.mips     =>  MIPS makefile
 makefile.acorn    =>  Acorn makefile
 makefile.amiga    =>  Amiga makefile
 smakefile.ppc     =>  AMIGA smakefile for SAS C V6.58/7.00 PPC compiler
                       (Requires SCOPTIONS, copied from scripts/SCOPTIONS.ppc)
 makefile.atari    =>  Atari makefile
 makefile.beos     =>  BEOS makefile for X86
 makefile.bor      =>  Borland makefile (uses bcc)
 makefile.bc32     =>  32-bit Borland C++ (all modules compiled in C mode)
 makefile.bd32     =>  To make a png32bd.dll with Borland C++ 4.5
 makefile.tc3      =>  Turbo C 3.0 makefile
 makefile.dj2      =>  DJGPP 2 makefile
 makefile.msc      =>  Microsoft C makefile
 makefile.vcawin32 =>  makefile for Microsoft Visual C++ 5.0 and later (uses
                       assembler code tuned for Intel MMX platform)
 makefile.vcwin32  =>  makefile for Microsoft Visual C++ 4.0 and later (does
                       not use assembler code)
 makefile.os2      =>  OS/2 Makefile (gcc and emx, requires pngos2.def)
 pngos2.def        =>  OS/2 module definition file used by makefile.os2
 makefile.watcom   =>  Watcom 10a+ Makefile, 32-bit flat memory model
 makevms.com       =>  VMS build script
 descrip.mms       =>  VMS makefile for MMS or MMK
 pngdef.pas        =>  Defines for a png32bd.dll with Borland C++ 4.5
 SCOPTIONS.ppc     =>  Used with smakefile.ppc

Copy the file (or files) that you need from the
scripts directory into this directory, for example

   MSDOS example: copy scripts\makefile.msc makefile
   UNIX example:    cp scripts/makefile.std makefile

Read the makefile to see if you need to change any source or
target directories to match your preferences.

Then read pngconf.h to see if you want to make any configuration
changes.

Then just run "make test" which will create the libpng library in
this directory and run a quick test that reads the "pngtest.png"
file and writes a "pngout.png" file that should be identical to it.
Look for "9782 zero samples" in the output of the test.  For more
confidence, you can run another test by typing "pngtest pngnow.png"
and looking for "289 zero samples" in the output.  Also, you can
run "pngtest -m *.png" in the "contrib/pngsuite" directory and compare
your output with the result shown in contrib/pngsuite/README.

Most of the makefiles will allow you to run "make install" to
put the library in its final resting place (if you want to
do that, run "make install" in the zlib directory first if necessary).

Further information can be found in the README and libpng.txt
files, in the individual makefiles, in png.h, in the README files in
subdirectories of the LIB directory, and the manual pages libpng.3 and png.5.
