mewin/libpng
1
0
Fork 0
mirror of https://git.code.sf.net/p/libpng/code.git synced 2025-07-10 18:04:09 +02:00
Code Issues Projects Releases Wiki Activity

Imported from pngcrush-1.4.5.tar

Browse Source
This commit is contained in:
Glenn Randers-Pehrson
2000-07-01 07:10:39 -05:00
parent 52ab58fb21
commit 55c878d8e5
33 changed files with 2225 additions and 1340 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
INSTALL.txt
View File

@@ -1,6 +1,6 @@
There's a sample Makefile.gcc for pngcrush, which you can use
by typing
There are sample Makefile.gcc and Makefile.msc for pngcrush, which you can use
by typing, for example
make -f Makefile.gcc

4
Makefile.gcc
View File

@@ -13,7 +13,7 @@
CC = gcc
LD = gcc
RM = rm -f
CFLAGS = -O -Wall
CFLAGS = -I. -O -Wall
# [note that -Wall is a gcc-specific compilation flag ("all warnings on")]
LDFLAGS =
O = .o
@@ -27,7 +27,7 @@ OBJS = $(PNGCRUSH)$(O) adler32$(O) crc32$(O) deflate$(O) gzio$(O) \
infblock$(O) infcodes$(O) inffast$(O) inflate$(O) inftrees$(O) \
infutil$(O) png$(O) pngerror$(O) pngget$(O) pngmem$(O) \
pngpread$(O) pngread$(O) pngrio$(O) pngrtran$(O) pngrutil$(O) \
pngset$(O) pngtrans$(O) pngvcrd$(O) pngwio$(O) pngwrite$(O) \
pngset$(O) pngtrans$(O) pngwio$(O) pngwrite$(O) pnggccrd$(O) \
pngwtran$(O) pngwutil$(O) trees$(O) zutil$(O)
EXES = $(PNGCRUSH)$(E)

2
Makefile.msc
View File

@@ -14,7 +14,7 @@
CC = cl -nologo
LD = link -nologo
RM = del
CFLAGS = -DPNG_ZBUF_SIZE=0x080000 -DWIN32 -O2
CFLAGS = -I. -DPNG_ZBUF_SIZE=0x080000 -DWIN32 -O2
LDFLAGS =
O = .obj
E = .exe

27
README.txt
View File

@@ -33,15 +33,14 @@ This is the copyright notice, disclaimer, and license:
This is the output of "pngcrush" and "pngcrush -help":
| pngcrush 1.4.4, Copyright (C) 1998, 1999, 2000 Glenn Randers-Pehrson
| pngcrush 1.4.5, Copyright (C) 1998, 1999, 2000 Glenn Randers-Pehrson
| This is a free, open-source program. Permission is
| granted to everyone to use pngcrush without fee.
| This program was built with libpng version 1.0.6i,
| This program was built with libpng version 1.0.7rc2,
| Copyright (C) 1995, Guy Eric Schalnat, Group 42 Inc.,
| Copyright (C) 1996, 1997 Andreas Dilger,
| Copyright (C) 1998, 1999, 2000 Glenn Randers-Pehrson,
| and zlib version 1.1.3, Copyright (C) 1998,
| and zlib version 1.1.3pc, Copyright (C) 1998,
| Jean-loup Gailly and Mark Adler.
@@ -55,17 +54,18 @@ options:
-double_gamma (used for fixing gamma in PhotoShop 5.0/5.02 files)
-e extension (used for creating output filename)
-f user_filter [0-5]
-fix (fix otherwise fatal conditions such as bad CRCs)
-force (Write a new output file even if larger than input)
-g gamma (float, e.g., 0.45455)
-g gamma (float or fixed*100000, e.g., 0.45455 or 45455)
-itxt b[efore_IDAT]|a[fter_IDAT] "keyword" "text"
-l zlib_compression_level [0-9]
-m method [0 through 200]
-max maximum_IDAT_size [1 through 8192]
-max maximum_IDAT_size [1 through 524288]
-n (no save; does not do compression or write output PNG)
-plte_len n (truncate PLTE)
-q (quiet)
-rem chunkname (or "alla" or "allb")
-replace_gamma gamma (float, e.g. 0.45455) even if gAMA is present.
-replace_gamma gamma (float or fixed*100000) even if gAMA is present.
-res dpi
-srgb [0, 1, 2, or 3]
-text b[efore_IDAT]|a[fter_IDAT] "keyword" "text"
@@ -76,6 +76,11 @@ options:
-h (help)
-p (pause)
usage: pngcrush [options] infile.png outfile.png
pngcrush -e ext [other options] files.png ...
pngcrush -d dir [other options] files.png ...
options:
-brute (Use brute-force, try 114 different methods [11-124])
@@ -119,13 +124,15 @@ options:
preceding '-m method' or '-brute_force' argument.
0: none; 1-4: use specified filter; 5: adaptive.
-fix (fix otherwise fatal conditions such as bad CRCs)
-force (Write a new output file even if larger than input)
Otherwise the input file will be copied to output
if it is smaller than any generated file and no chunk
additions, removals, or changes were requested.
-g gamma (float, e.g., 0.45455)
-g gamma (float or fixed*100000, e.g., 0.45455 or 45455)
Value to insert in gAMA chunk, only if the input
file has no gAMA chunk. To replace an existing
@@ -151,7 +158,7 @@ options:
1, 4, and 7 use no filtering; methods 11 and up use
specified filter, compression level, and strategy.
-max maximum_IDAT_size [1 through 8192]
-max maximum_IDAT_size [1 through 524288]
-n (no save; does not do compression or write output PNG)
@@ -181,7 +188,7 @@ options:
all known ancillary chunks except for tRNS, and
"-rem allb" removes all but tRNS and gAMA.
-replace_gamma gamma (float, e.g. 0.45455) even if gAMA is present.
-replace_gamma gamma (float or fixed*100000) even if gAMA is present.
-res dpi

177
cexcept.h
View File

@@ -1,5 +1,5 @@
/*===
cexcept.h 0.6.0 (2000-Apr-07-Fri)
cexcept.h 1.0.0 (2000-Jun-21-Wed)
Adam M. Costello <amc@cs.berkeley.edu>
An interface for exception-handling in ANSI C, developed jointly with
@@ -13,11 +13,165 @@ Cosmin Truta <cosmin@cs.toronto.edu>.
no guarantees about the correctness of this file, and are not
responsible for any damage resulting from its use.
Comments have been stripped from this copy; if you are interested in cexcept
you should look at the most recent version, which this probably isn't.
If this interface is used by multiple .c files, they shouldn't include
this header file directly. Instead, create a wrapper header file that
includes this header file and then invokes the define_exception_type
macro (see below), and let your .c files include that header file.
For recent versions of cexcept.h with documentation and examples, go to
http://www.cs.berkeley.edu/~amc/cexcept/ or http://cexcept.sourceforge.net/
The interface consists of one type, one well-known name, and six macros.
define_exception_type(type_name);
This macro is used like an external declaration. It specifies
the type of object that gets copied from the exception thrower to
the exception catcher. The type_name can be any type that can be
assigned to, that is, a non-constant arithmetic type, struct, union,
or pointer. Examples:
define_exception_type(int);
enum exception { out_of_memory, bad_arguments, disk_full };
define_exception_type(enum exception);
struct exception { int code; const char *msg; };
define_exception_type(struct exception);
struct exception_context;
This type may be used after the define_exception_type() macro has
been invoked. A struct exception_context must be known to both
the thrower and the catcher. It is expected that there be one
context for each thread that uses exceptions. It would certainly
be dangerous for multiple threads to access the same context.
One thread can use multiple contexts, but that is likely to be
confusing and not typically useful. The application can allocate
this structure in any way it pleases--automatic, static, or dynamic.
The application programmer should pretend not to know the structure
members, which are subject to change.
struct exception_context *the_exception_context;
The Try/Catch and Throw statements (described below) implicitly
refer to a context, using the name the_exception_context. It is
the application's responsibility to make sure that this name yields
the address of a mutable (non-constant) struct exception_context
wherever those statements are used. Subject to that constraint, the
application may declare a variable of this name anywhere it likes
(inside a function, in a parameter list, or externally), and may
use whatever storage class specifiers (static, extern, etc) or type
qualifiers (const, volatile) it likes. Examples:
static struct exception_context
* const the_exception_context = &foo;
{ struct exception_context *the_exception_context = bar; ... }
int blah(struct exception_context *the_exception_context, ...);
extern struct exception_context the_exception_context[1];
The last example illustrates a trick that avoids creating a pointer
object separate from the structure object.
The name could even be a macro, for example:
struct exception_context ec_array[numthreads];
#define the_exception_context (ec_array + thread_id)
Be aware that the_exception_context is used several times by the
Try/Catch/Throw macros, so it shouldn't be expensive or have side
effects. The expansion must be a drop-in replacement for an
identifier, so it's safest to put parentheses around it.
void init_exception_context(struct exception_context *ec);
For context structures allocated statically (by an external
definition or using the "static" keyword), the implicit
initialization to all zeros is sufficient, but contexts allocated
by other means must be initialized using this macro before they
are used by a Try/Catch statement. It does no harm to initialize
a context more than once (by using this macro on a statically
allocated context, or using this macro twice on the same context),
but a context must not be re-initialized after it has been used by a
Try/Catch statement.
Try statement
Catch (expression) statement
The Try/Catch/Throw macros are capitalized in order to avoid
confusion with the C++ keywords, which have subtly different
semantics.
A Try/Catch statement has a syntax similar to an if/else
statement, except that the parenthesized expression goes after
the second keyword rather than the first. As with if/else,
there are two clauses, each of which may be a simple statement
ending with a semicolon or a brace-enclosed compound statement.
But whereas the else clause is optional, the Catch clause is
required. The expression must be a modifiable lvalue (something
capable of being assigned to) of the exact same type passed to
define_exception_type().
If a Throw that uses the same exception context as the Try/Catch is
executed within the Try clause (typically within a function called
by the Try clause), and the exception is not caught by a nested
Try/Catch statement, then a copy of the exception will be assigned
to the expression, and control will jump to the Catch clause. If no
such Throw is executed, then the assignment is not performed, and
the Catch clause is not executed.
Regardless of whether an exception is caught, the expression is
always evaluated exactly once, which is significant if it has side
effects, for example:
Try foo();
Catch (p[++i].e) { ... }
IMPORTANT: Jumping into or out of a Try clause (for example via
return, break, continue, goto, longjmp) is forbidden--the compiler
will not complain, but bad things will happen at run-time. Jumping
into or out of a Catch clause is okay, and so is jumping around
inside a Try clause. In many cases where one is tempted to return
from a Try clause, it will suffice to use Throw, and then return
from the Catch clause. Another option is to set a flag variable and
use goto to jump to the end of the Try clause, then check the flag
after the Try/Catch statement.
IMPORTANT: The values of any non-volatile automatic variables
changed within the Try clause are undefined after an exception is
caught. Therefore, variables modified inside the Try block whose
values are needed later outside the Try block must either use static
storage or be declared with the "volatile" type qualifier.
Throw expression;
A Throw statement is very much like a return statement, except that
the expression is required. Whereas return jumps back to the place
where the current function was called, Throw jumps back to the Catch
clause of the innermost enclosing Try clause. The expression must
be compatible with the type passed to define_exception_type(). The
exception must be caught, otherwise the program may crash.
Slight limitation: If the expression is a comma-expression it must
be enclosed in parentheses.
Try statement
Catch_anonymous statement
When the value of the exception is not needed, a Try/Catch statement
can use Catch_anonymous instead of Catch (expression).
Everything below this point is for the benefit of the compiler. The
application programmer should pretend not to know any of it, because it
is subject to change.
===*/
@@ -68,6 +222,19 @@ struct exception_context { \
if (!the_exception_context->caught) { } \
else
/* Try ends with if(), and Catch begins and ends with else. This */
/* ensures that the Try/Catch syntax is really the same as the */
/* if/else syntax. */
/* */
/* We use &exception__s instead of 1 to appease compilers that */
/* warn about constant expressions inside if(). Most compilers */
/* should still recognize that &exception__s is never zero and avoid */
/* generating test code. */
/* */
/* We use the variable exception__i to start the loop at the bottom, */
/* rather than jump into the loop using a switch statement, to */
/* appease compilers that warn about jumping into loops. */
#define Throw \
for (;; longjmp(the_exception_context->last->env, 1)) \
if (the_exception_context->last->exception) \

2
deflate.c
View File

@@ -52,7 +52,7 @@
#include "deflate.h"
const char deflate_copyright[] =
" deflate 1.1.3 Copyright 1995-1998 Jean-loup Gailly ";
" deflate 1.1.3pc Copyright 1995-1998 Jean-loup Gailly ";
/*
If you use the zlib library in a product, an acknowledgment is welcome
in the documentation of your product. If for some reason you cannot

2
inflate.c
View File

@@ -237,6 +237,7 @@ int f;
break;
}
z->state->mode = CHECK4;
r=Z_DATA_ERROR;
case CHECK4:
NEEDBYTE
z->state->sub.check.need = (uLong)NEXTBYTE << 24;
@@ -252,7 +253,6 @@ int f;
case CHECK1:
NEEDBYTE
z->state->sub.check.need += (uLong)NEXTBYTE;
if (z->state->sub.check.was != z->state->sub.check.need)
{
z->state->mode = BAD;

259
png.c
View File

@@ -1,10 +1,10 @@
/* png.c - location for general purpose libpng functions
*
* libpng version 1.0.6i - May 1, 2000
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
* Copyright (c) 1996, 1997 Andreas Dilger
* libpng version 1.0.7rc2 - June 28, 2000
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*
*/
@@ -14,14 +14,14 @@
#include "png.h"
/* Generate a compiler error if there is an old png.h in the search path. */
typedef version_1_0_6i Your_png_h_is_not_version_1_0_6i;
typedef version_1_0_7rc2 Your_png_h_is_not_version_1_0_7rc2;
/* Version information for C files. This had better match the version
* string defined in png.h. */
#ifdef PNG_USE_GLOBAL_ARRAYS
/* png_libpng_ver was changed to a function in version 1.0.5c */
char png_libpng_ver[12] = "1.0.6i";
char png_libpng_ver[12] = "1.0.7rc2";
/* png_sig was changed to a function in version 1.0.5c */
/* Place to hold the signature string for a PNG file. */
@@ -88,7 +88,7 @@ int FARDATA png_pass_dsp_mask[] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
* or write any of the magic bytes before it starts on the IHDR.
*/
void
void PNGAPI
png_set_sig_bytes(png_structp png_ptr, int num_bytes)
{
png_debug(1, "in png_set_sig_bytes\n");
@@ -106,7 +106,7 @@ png_set_sig_bytes(png_structp png_ptr, int num_bytes)
* respectively, to be less than, to match, or be greater than the correct
* PNG signature (this is the same behaviour as strcmp, memcmp, etc).
*/
int
int PNGAPI
png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)
{
png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
@@ -128,14 +128,14 @@ png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)
* to check a partial signature. This function might be removed in the
* future - use png_sig_cmp(). Returns true (nonzero) if the file is a PNG.
*/
int
int PNGAPI
png_check_sig(png_bytep sig, int num)
{
return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num));
}
/* Function to allocate memory for zlib and clear it to 0. */
voidpf
voidpf PNGAPI
png_zalloc(voidpf png_ptr, uInt items, uInt size)
{
png_uint_32 num_bytes = (png_uint_32)items * size;
@@ -155,7 +155,7 @@ png_zalloc(voidpf png_ptr, uInt items, uInt size)
}
/* function to free memory for zlib */
void
void PNGAPI
png_zfree(voidpf png_ptr, voidpf ptr)
{
png_free((png_structp)png_ptr, (png_voidp)ptr);
@@ -164,7 +164,7 @@ png_zfree(voidpf png_ptr, voidpf ptr)
/* Reset the CRC variable to 32 bits of 1's. Care must be taken
* in case CRC is > 32 bits to leave the top bits 0.
*/
void
void /* PRIVATE */
png_reset_crc(png_structp png_ptr)
{
png_ptr->crc = crc32(0, Z_NULL, 0);
@@ -175,7 +175,7 @@ png_reset_crc(png_structp png_ptr)
* also check that this data will actually be used before going to the
* trouble of calculating it.
*/
void
void /* PRIVATE */
png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
{
int need_crc = 1;
@@ -202,7 +202,7 @@ png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
* and png_info_init() so that applications that want to use a shared
* libpng don't have to be recompiled if png_info changes size.
*/
png_infop
png_infop PNGAPI
png_create_info_struct(png_structp png_ptr)
{
png_infop info_ptr;
@@ -227,7 +227,7 @@ png_create_info_struct(png_structp png_ptr)
* png_destroy_write_struct() to free an info struct, but this may be
* useful for some applications.
*/
void
void PNGAPI
png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
{
png_infop info_ptr = NULL;
@@ -253,7 +253,7 @@ png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
* and applications using it are urged to use png_create_info_struct()
* instead.
*/
void
void PNGAPI
png_info_init(png_infop info_ptr)
{
png_debug(1, "in png_info_init\n");
@@ -262,7 +262,7 @@ png_info_init(png_infop info_ptr)
}
#ifdef PNG_FREE_ME_SUPPORTED
void
void PNGAPI
png_data_freer(png_structp png_ptr, png_infop info_ptr,
int freer, png_uint_32 mask)
{
@@ -279,7 +279,7 @@ png_data_freer(png_structp png_ptr, png_infop info_ptr,
}
#endif
void
void PNGAPI
png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, int num)
{
png_debug(1, "in png_free_data\n");
@@ -289,108 +289,120 @@ png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, int num
#if defined(PNG_TEXT_SUPPORTED)
/* free text item num or (if num == -1) all text items */
#ifdef PNG_FREE_ME_SUPPORTED
if (mask & info_ptr->free_me & PNG_FREE_TEXT)
if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
#else
if (mask & PNG_FREE_TEXT)
#endif
{
if (num != -1)
{
if (info_ptr->text[num].key)
if (info_ptr->text && info_ptr->text[num].key)
{
png_free(png_ptr, info_ptr->text[num].key);
info_ptr->text[num].key = NULL;
}
}
else if (info_ptr->text != NULL)
else
{
int i;
for (i = 0; i < info_ptr->num_text; i++)
png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
png_free(png_ptr, info_ptr->text);
info_ptr->text = NULL;
info_ptr->num_text=0;
int i;
for (i = 0; i < info_ptr->num_text; i++)
png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
png_free(png_ptr, info_ptr->text);
info_ptr->text = NULL;
info_ptr->num_text=0;
}
}
#endif
#if defined(PNG_tRNS_SUPPORTED)
/* free any tRNS entry */
if (mask & PNG_FREE_TRNS)
{
if (info_ptr->valid & PNG_INFO_tRNS)
{
#ifdef PNG_FREE_ME_SUPPORTED
if (info_ptr->free_me & PNG_FREE_TRNS)
if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)
#else
if (png_ptr->flags & PNG_FLAG_FREE_TRNS)
if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS))
#endif
png_free(png_ptr, info_ptr->trans);
info_ptr->valid &= ~PNG_INFO_tRNS;
}
{
png_free(png_ptr, info_ptr->trans);
info_ptr->valid &= ~PNG_INFO_tRNS;
info_ptr->trans = NULL;
}
#endif
#if defined(PNG_sCAL_SUPPORTED)
/* free any sCAL entry */
{
if (info_ptr->valid & PNG_INFO_sCAL)
{
#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
png_free(png_ptr, info_ptr->scal_s_width);
png_free(png_ptr, info_ptr->scal_s_height);
#ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
#else
if (mask & PNG_FREE_SCAL)
#endif
info_ptr->valid &= ~PNG_INFO_sCAL;
}
{
#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
png_free(png_ptr, info_ptr->scal_s_width);
png_free(png_ptr, info_ptr->scal_s_height);
info_ptr->scal_s_width = NULL;
info_ptr->scal_s_height = NULL;
#endif
info_ptr->valid &= ~PNG_INFO_sCAL;
}
#endif
#if defined(PNG_pCAL_SUPPORTED)
/* free any pCAL entry */
#ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
#else
if (mask & PNG_FREE_PCAL)
#endif
{
if (info_ptr->valid & PNG_INFO_pCAL)
{
png_free(png_ptr, info_ptr->pcal_purpose);
png_free(png_ptr, info_ptr->pcal_units);
if (info_ptr->pcal_params != NULL)
{
int i;
for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
{
png_free(png_ptr, info_ptr->pcal_params[i]);
}
png_free(png_ptr, info_ptr->pcal_params);
}
info_ptr->valid &= ~PNG_INFO_pCAL;
}
png_free(png_ptr, info_ptr->pcal_purpose);
png_free(png_ptr, info_ptr->pcal_units);
info_ptr->pcal_purpose = NULL;
info_ptr->pcal_units = NULL;
if (info_ptr->pcal_params != NULL)
{
int i;
for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
png_free(png_ptr, info_ptr->pcal_params[i]);
png_free(png_ptr, info_ptr->pcal_params);
info_ptr->pcal_params = NULL;
}
info_ptr->valid &= ~PNG_INFO_pCAL;
}
#endif
#if defined(PNG_iCCP_SUPPORTED)
/* free any iCCP entry */
if (mask & PNG_FREE_ICCP)
{
if (info_ptr->valid & PNG_INFO_iCCP)
{
#ifdef PNG_FREE_ME_SUPPORTED
if (info_ptr->free_me & PNG_FREE_ICCP)
if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
#else
if (mask & PNG_FREE_ICCP)
#endif
{
png_free(png_ptr, info_ptr->iccp_name);
png_free(png_ptr, info_ptr->iccp_profile);
}
info_ptr->valid &= ~PNG_INFO_iCCP;
}
{
png_free(png_ptr, info_ptr->iccp_name);
png_free(png_ptr, info_ptr->iccp_profile);
info_ptr->iccp_name = NULL;
info_ptr->iccp_profile = NULL;
info_ptr->valid &= ~PNG_INFO_iCCP;
}
#endif
#if defined(PNG_sPLT_SUPPORTED)
/* free a given sPLT entry, or (if num == -1) all sPLT entries */
#ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
#else
if (mask & PNG_FREE_SPLT)
#endif
{
if (num != -1)
{
png_free(png_ptr, info_ptr->splt_palettes[num].name);
png_free(png_ptr, info_ptr->splt_palettes[num].entries);
info_ptr->valid &= ~PNG_INFO_sPLT;
if(info_ptr->splt_palettes)
{
png_free(png_ptr, info_ptr->splt_palettes[num].name);
png_free(png_ptr, info_ptr->splt_palettes[num].entries);
info_ptr->splt_palettes[num].name = NULL;
info_ptr->splt_palettes[num].entries = NULL;
}
}
else
{
@@ -401,19 +413,28 @@ if (mask & PNG_FREE_SPLT)
png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);
png_free(png_ptr, info_ptr->splt_palettes);
info_ptr->splt_palettes = NULL;
info_ptr->splt_palettes_num = 0;
}
info_ptr->valid &= ~PNG_INFO_sPLT;
}
}
#endif
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
#ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
#else
if (mask & PNG_FREE_UNKN)
#endif
{
if (num != -1)
{
png_free(png_ptr, info_ptr->unknown_chunks[num].data);
info_ptr->unknown_chunks[num].data = NULL;
if(info_ptr->unknown_chunks)
{
png_free(png_ptr, info_ptr->unknown_chunks[num].data);
info_ptr->unknown_chunks[num].data = NULL;
}
}
else
{
@@ -425,6 +446,7 @@ if (mask & PNG_FREE_UNKN)
png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);
png_free(png_ptr, info_ptr->unknown_chunks);
info_ptr->unknown_chunks = NULL;
info_ptr->unknown_chunks_num = 0;
}
}
@@ -433,56 +455,56 @@ if (mask & PNG_FREE_UNKN)
#if defined(PNG_hIST_SUPPORTED)
/* free any hIST entry */
if (mask & PNG_FREE_HIST)
{
if (info_ptr->valid & PNG_INFO_hIST)
{
#ifdef PNG_FREE_ME_SUPPORTED
if (info_ptr->free_me & PNG_FREE_HIST)
if ((mask & PNG_FREE_HIST) & info_ptr->free_me)
#else
if (png_ptr->flags & PNG_FLAG_FREE_HIST)
if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST))
#endif
png_free(png_ptr, info_ptr->hist);
info_ptr->valid &= ~PNG_INFO_hIST;
}
{
png_free(png_ptr, info_ptr->hist);
info_ptr->hist = NULL;
info_ptr->valid &= ~PNG_INFO_hIST;
}
#endif
/* free any PLTE entry that was internally allocated */
if (mask & PNG_FREE_PLTE)
{
if (info_ptr->valid & PNG_INFO_PLTE)
{
#ifdef PNG_FREE_ME_SUPPORTED
if (info_ptr->free_me & PNG_FREE_PLTE)
if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
#else
if (png_ptr->flags & PNG_FLAG_FREE_PLTE)
if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE))
#endif
png_zfree(png_ptr, info_ptr->palette);
info_ptr->valid &= ~(PNG_INFO_PLTE);
info_ptr->num_palette = 0;
}
{
png_zfree(png_ptr, info_ptr->palette);
info_ptr->palette = NULL;
info_ptr->valid &= ~PNG_INFO_PLTE;
info_ptr->num_palette = 0;
}
#if defined(PNG_INFO_IMAGE_SUPPORTED)
/* free any image bits attached to the info structure */
if (mask & PNG_FREE_ROWS)
{
#ifdef PNG_FREE_ME_SUPPORTED
if (info_ptr->free_me & PNG_FREE_ROWS)
if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
#else
if (mask & PNG_FREE_ROWS)
#endif
{
{
if(info_ptr->row_pointers)
{
int row;
for (row = 0; row < (int)info_ptr->height; row++)
png_free(png_ptr, info_ptr->row_pointers[row]);
png_free(png_ptr, info_ptr->row_pointers);
}
info_ptr->row_pointers=NULL;
}
info_ptr->valid &= ~PNG_INFO_IDAT;
}
#endif
#ifdef PNG_FREE_ME_SUPPORTED
if(num == -1)
info_ptr->free_me &= ~mask;
else
info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);
#endif
}
@@ -490,7 +512,7 @@ if (mask & PNG_FREE_ROWS)
* pointing to before re-using it or freeing the struct itself. Recall
* that png_free() checks for NULL pointers for us.
*/
void
void /* PRIVATE */
png_info_destroy(png_structp png_ptr, png_infop info_ptr)
{
png_debug(1, "in png_info_destroy\n");
@@ -512,7 +534,7 @@ png_info_destroy(png_structp png_ptr, png_infop info_ptr)
* functions. The application should free any memory associated with this
* pointer before png_write_destroy() or png_read_destroy() are called.
*/
png_voidp
png_voidp PNGAPI
png_get_io_ptr(png_structp png_ptr)
{
return (png_ptr->io_ptr);
@@ -525,7 +547,7 @@ png_get_io_ptr(png_structp png_ptr)
* PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't
* necessarily available.
*/
void
void PNGAPI
png_init_io(png_structp png_ptr, FILE *fp)
{
png_debug(1, "in png_init_io\n");
@@ -537,7 +559,7 @@ png_init_io(png_structp png_ptr, FILE *fp)
/* Convert the supplied time into an RFC 1123 string suitable for use in
* a "Creation Time" or other text-based time string.
*/
png_charp
png_charp PNGAPI
png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
{
static PNG_CONST char short_months[12][4] =
@@ -572,21 +594,21 @@ png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
#if 0
/* Signature string for a PNG file. */
png_bytep
png_bytep PNGAPI
png_sig_bytes(void)
{
return ((png_bytep)"\211\120\116\107\015\012\032\012");
}
#endif
png_charp
png_charp PNGAPI
png_get_copyright(png_structp png_ptr)
{
if (png_ptr != NULL || png_ptr == NULL) /* silence compiler warning */
return ("\n libpng version 1.0.6i - May 1, 2000\n\
Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.\n\
return ("\n libpng version 1.0.7rc2 - June 28, 2000\n\
Copyright (c) 1998-2000 Glenn Randers-Pehrson\n\
Copyright (c) 1996, 1997 Andreas Dilger\n\
Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson\n");
Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.\n");
return ("");
}
@@ -596,16 +618,16 @@ png_get_copyright(png_structp png_ptr)
* in png.h.
*/
png_charp
png_charp PNGAPI
png_get_libpng_ver(png_structp png_ptr)
{
/* Version of *.c files used when building libpng */
if(png_ptr != NULL) /* silence compiler warning about unused png_ptr */
return("1.0.6i");
return("1.0.6i");
return("1.0.7rc2");
return("1.0.7rc2");
}
png_charp
png_charp PNGAPI
png_get_header_ver(png_structp png_ptr)
{
/* Version of *.h files used when building libpng */
@@ -614,7 +636,7 @@ png_get_header_ver(png_structp png_ptr)
return(PNG_LIBPNG_VER_STRING);
}
png_charp
png_charp PNGAPI
png_get_header_version(png_structp png_ptr)
{
/* Returns longer string containing both version and date */
@@ -624,7 +646,7 @@ png_get_header_version(png_structp png_ptr)
}
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
int
int PNGAPI
png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)
{
/* check chunk_name and return "keep" value if it's on the list, else 0 */
@@ -641,8 +663,15 @@ png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)
#endif
/* This function, added to libpng-1.0.6g, is untested. */
int
int PNGAPI
png_reset_zstream(png_structp png_ptr)
{
return (inflateReset(&png_ptr->zstream));
}
png_uint_32 PNGAPI
png_access_version_number(void)
{
/* Version of *.c files used when building libpng */
return((png_uint_32) 10007L);
}

291
png.h
View File

@@ -1,15 +1,15 @@
/* png.h - header file for PNG reference library
*
* libpng version 1.0.6i - May 1, 2000
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
* Copyright (c) 1996, 1997 Andreas Dilger
* libpng version 1.0.7rc2 - June 28, 2000
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*
* Authors and maintainers:
* libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat
* libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger
* libpng versions 0.97, January 1998, through 1.0.6i - May 1, 2000: Glenn
* libpng versions 0.97, January 1998, through 1.0.7rc2 - June 28, 2000: Glenn
* See also "Contributing Authors", below.
*
* Note about libpng version numbers:
@@ -20,39 +20,43 @@
* 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 1.0.0 100 2.1.0 [100 should be 10000]
* 1.0.1 1.0.1 10001 2.1.0
* 1.0.1a-e 1.0.1a-e 10002 2.1.0.1a-e
* 1.0.2 1.0.2 10002 2.1.0.2
* 1.0.2a-b 1.0.2a-b 10003 2.1.0.2a-b
* 1.0.3 1.0.3 10003 2.1.0.3
* 1.0.3a-d 1.0.3a-d 10004 2.1.0.3a-d
* 1.0.4 1.0.4 10004 2.1.0.4
* 1.0.4a-f 1.0.4a-f 10005 2.1.0.4a-f
* 1.0.5 (+ 2 patches) 1.0.5 10005 2.1.0.5
* 1.0.5a-d 1.0.5a-d 10006 2.1.0.5a-d
* 1.0.5e-r 1.0.5e-r 10100 2.1.0.5e-r (not source compatible)
* 1.0.5s-v 1.0.5s-v 10006 2.1.0.5s-v (not binary compatible)
* 1.0.6 (+ 3 patches) 1.0.6 10006 2.1.0.6 (still binary incompat)
* 1.0.6d-f 1.0.6d-f 10007 2.1.0.6d-f (still binary incompat)
* 1.0.6g 1.0.6g 10007 2.1.0.6g
* 1.0.6h 1.0.6h 10007 10.6h
* 1.0.6 (+ 4 patches) 1.0.6 10006 2.1.0.6ad (compatible with 1.0.0)
* 1.0.6i 1.0.6i 10007 10.6i (can be compatible w/ 1.0.0)
* 1.0.7 1.0.7 10007 10.7 (still can be compatible)
* 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-18 10007 2.1.0.7beta11-18 (binary compatible)
* 1.0.7rc1-2 10007 2.1.0.7rc1-2 (binary compatible)
* planned:
* 1.0.6patch4 (w/4 patches) 10006 2.1.0.6 (binary compatible)
* 1.0.7 10007 (still compatible)
*
* Henceforth the source version will match the shared-library major
* and minor numbers; the shared-library major version number will be
@@ -60,7 +64,9 @@
* PNG_PNGLIB_VER macro, which is not used within libpng but is available
* for applications, is an unsigned integer of the form xyyzz corresponding
* to the source version x.y.z (leading zeros in y and z). Beta versions
* are given the previous public release number plus a letter or two.
* were given the previous public release number plus a letter, until
* version 1.0.6j; from then on they were given the upcoming public
* release number plus "betaNN" or "rcN".
*
* Binary incompatibility exists only when applications make direct access
* to the info_ptr or png_ptr members through png.h, and the compiled
@@ -74,32 +80,49 @@
/*
* COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
*
* If you modify libpng you may insert additional notices after this sentence.
* If you modify libpng you may insert additional notices immediately following
* this sentence.
*
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
* (libpng versions 0.5, May 1995, through 0.88, January 1996)
* libpng versions 1.0.6, March 20, 2000, through 1.0.7rc2, June 28, 2000, are
* Copyright (c) 2000 Glenn Randers-Pehrson
* Distributed according to the same disclaimer and license as libpng-1.0.5
* with the following individuals added to the list of Contributing Authors:
*
* Simon-Pierre Cadieux
* Eric S. Raymond
* Gilles Vollant
*
* libpng versions 0.97, January 1998, through 1.0.5, October 15, 1999, are
* Copyright (c) 1998, 1999 Glenn Randers-Pehrson
* Distributed according to the same disclaimer and license as libpng-0.96,
* with the following individuals added to the list of Contributing Authors:
*
* Tom Lane
* Glenn Randers-Pehrson
* Willem van Schaik
*
* libpng versions 0.89, June 1996, through 0.96, May 1997, are
* Copyright (c) 1996, 1997 Andreas Dilger
* (libpng versions 0.89c, June 1996, through 0.96, May 1997)
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* (libpng versions 0.97, January 1998, through 1.0.6i, May 1, 2000)
*
* For the purposes of this copyright and license, "Contributing Authors"
* is defined as the following set of individuals:
* Distributed according to the same disclaimer and license as libpng-0.88,
* with the following individuals added to the list of Contributing Authors:
*
* John Bowler
* Kevin Bracey
* Sam Bushell
* Andreas Dilger
* Magnus Holmgren
* Tom Lane
* Dave Martindale
* Glenn Randers-Pehrson
* Eric S. Raymond
* Greg Roelofs
* Tom Tanner
*
* libpng versions 0.5, May 1995, through 0.88, January 1996, are
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
*
* For the purposes of this copyright and license, "Contributing Authors"
* is defined as the following set of individuals:
*
* Andreas Dilger
* Dave Martindale
* Guy Eric Schalnat
* Paul Schmidt
* Tom Tanner
* Willem van Schaik
* Tim Wegner
*
* The PNG Reference Library is supplied "AS IS". The Contributing Authors
@@ -156,13 +179,13 @@
* Y2K compliance in libpng:
* =========================
*
* May 1, 2000
* June 28, 2000
*
* Since the PNG Development group is an ad-hoc body, we can't make
* an official declaration.
*
* This is your unofficial assurance that libpng from version 0.71 and
* upward through 1.0.6i are Y2K compliant. It is my belief that earlier
* upward through 1.0.7rc2 are Y2K compliant. It is my belief that earlier
* versions were also Y2K compliant.
*
* Libpng only has three year fields. One is a 2-byte unsigned integer
@@ -208,8 +231,8 @@
* PNG Development Group
*/
#ifndef _PNG_H
#define _PNG_H
#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
@@ -217,6 +240,30 @@
* at the actual function definitions and structure components.
*/
/* Version information for png.h - this should match the version in png.c */
#define PNG_LIBPNG_VER_STRING "1.0.7rc2"
#define PNG_LIBPNG_VER_SONUM 2
/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */
#define PNG_LIBPNG_VER_MAJOR 1
#define PNG_LIBPNG_VER_MINOR 0
#define PNG_LIBPNG_VER_RELEASE 7
/* This should match the numeric part of the final component of
* PNG_LIBPNG_VER_STRING, omitting any leading zero: */
#define PNG_LIBPNG_VER_BUILD 2
/* Careful here. At one time, Guy wanted to use 082, but that would be octal.
* We must not include leading zeros.
* Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only
* version 1.0.0 was mis-numbered 100 instead of 10000). From
* version 1.0.1 it's xxyyzz, where x=major, y=minor, z=release */
#define PNG_LIBPNG_VER 10007 /* 1.0.7 */
/* Note to maintainer: update this number in scripts/pngdef.pas as well */
#ifndef PNG_VERSION_INFO_ONLY
/* include the compression library's header */
#include "zlib.h"
@@ -239,25 +286,14 @@ extern "C" {
* which applications aren't expected to use directly.
*/
/* Version information for png.h - this should match the version in png.c */
#define PNG_LIBPNG_VER_STRING "1.0.6i"
/* Careful here. At one time, Guy wanted to use 082, but that would be octal.
* We must not include leading zeros.
* Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only
* version 1.0.0 was mis-numbered 100 instead of 10000). From
* version 1.0.1 it's xxyyzz, where x=major, y=minor, z=bugfix */
#define PNG_LIBPNG_VER 10007 /* 1.0.7 */
/* Note to maintainer: update this number in scripts/pngdef.pas as well */
/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */
#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN)
/* Version information for C files, stored in png.c. This had better match
* the version above.
*/
#ifdef PNG_USE_GLOBAL_ARRAYS
PNG_EXPORT_VAR (char) png_libpng_ver[12]; /* need room for 99.99.99aa */
PNG_EXPORT_VAR (char) png_libpng_ver[12]; /* need room for 99.99.99-patch-aa0*/
/* Note to maintainer: increase to 18 at the next opportunity */
#else
#define png_libpng_ver png_get_header_ver(NULL)
#endif
@@ -366,11 +402,13 @@ typedef struct png_text_struct
png_charp text; /* comment, may be an empty string (ie "")
or a NULL pointer */
png_size_t text_length; /* length of the text string */
#ifdef PNG_iTXt_SUPPORTED
png_size_t itxt_length; /* length of the itxt string */
png_charp lang; /* language code, 0-79 characters
or a NULL pointer */
png_charp lang_key; /* keyword translated UTF-8 string, 0 or more
chars or a NULL pointer */
#endif
} png_text;
typedef png_text FAR * png_textp;
typedef png_text FAR * FAR * png_textpp;
@@ -813,31 +851,33 @@ typedef png_row_info FAR * FAR * png_row_infopp;
typedef struct png_struct_def png_struct;
typedef png_struct FAR * png_structp;
typedef void (*png_error_ptr) PNGARG((png_structp, png_const_charp));
typedef void (*png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t));
typedef void (*png_flush_ptr) PNGARG((png_structp));
typedef void (*png_read_status_ptr) PNGARG((png_structp, png_uint_32, int));
typedef void (*png_write_status_ptr) PNGARG((png_structp, png_uint_32, int));
typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp));
typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t));
typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp));
typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32,
int));
typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32,
int));
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
typedef void (*png_progressive_info_ptr) PNGARG((png_structp, png_infop));
typedef void (*png_progressive_end_ptr) PNGARG((png_structp, png_infop));
typedef void (*png_progressive_row_ptr) PNGARG((png_structp, png_bytep,
typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp, png_infop));
typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop));
typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep,
png_uint_32, int));
#endif
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \
defined(PNG_LEGACY_SUPPORTED)
typedef void (*png_user_transform_ptr) PNGARG((png_structp,
typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp,
png_row_infop, png_bytep));
#endif
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
typedef int (*png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp));
typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp));
#endif
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
typedef void (*png_unknown_chunk_ptr) PNGARG((png_structp));
typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp));
#endif
/* Transform masks for the high-level interface */
@@ -852,7 +892,7 @@ typedef void (*png_unknown_chunk_ptr) PNGARG((png_structp));
#define PNG_TRANSFORM_BGR 0x0080 /* read and write */
#define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */
#define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */
#define PNG_TRANSFORM_INVERT_ALPHA 0x0200 /* read and write */
#define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */
#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* WRITE only */
typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_size_t));
@@ -1100,9 +1140,9 @@ struct png_struct_def
};
/* This prevents a compiler error in png_get_copyright() in png.c if png.c
and png.h are both at * version 1.0.6i
and png.h are both at * version 1.0.7rc2
*/
typedef png_structp version_1_0_6i;
typedef png_structp version_1_0_7rc2;
typedef png_struct FAR * FAR * png_structpp;
@@ -1112,6 +1152,9 @@ typedef png_struct FAR * FAR * png_structpp;
* a simple one line description of the use of each function.
*/
/* Returns the version number of the library */
extern PNG_EXPORT(png_uint_32,png_access_version_number) PNGARG((void));
/* Tell lib we have already handled the first <num_bytes> magic bytes.
* Handling more than 8 bytes from the beginning of the file is an error.
*/
@@ -1292,7 +1335,7 @@ extern PNG_EXPORT(int,png_set_interlace_handling) PNGARG((png_structp png_ptr));
#endif
#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
/* Invert monocrome files */
/* Invert monochrome files */
extern PNG_EXPORT(void,png_set_invert_mono) PNGARG((png_structp png_ptr));
#endif
@@ -1664,14 +1707,15 @@ extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr,
#define PNG_FREE_ICCP 0x0010
#define PNG_FREE_SPLT 0x0020
#define PNG_FREE_ROWS 0x0040
#define PNG_FREE_PCAL 0x0080 /* not used any more */
#define PNG_FREE_SCAL 0x0100 /* not used any more */
#define PNG_FREE_PCAL 0x0080
#define PNG_FREE_SCAL 0x0100
#define PNG_FREE_UNKN 0x0200
#define PNG_FREE_LIST 0x0400
#define PNG_FREE_PLTE 0x1000
#define PNG_FREE_TRNS 0x2000
#define PNG_FREE_TEXT 0x4000
#define PNG_FREE_ALL 0x3fff
#define PNG_FREE_ALL 0x7fff
#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */
#ifdef PNG_USER_MEM_SUPPORTED
extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr,
@@ -1786,13 +1830,13 @@ png_ptr, png_infop info_ptr));
#endif
/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */
extern PNG_EXPORT(png_uint_32, png_get_x_offset_pixels) PNGARG((png_structp
extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp
png_ptr, png_infop info_ptr));
extern PNG_EXPORT(png_uint_32, png_get_y_offset_pixels) PNGARG((png_structp
extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp
png_ptr, png_infop info_ptr));
extern PNG_EXPORT(png_uint_32, png_get_x_offset_microns) PNGARG((png_structp
extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp
png_ptr, png_infop info_ptr));
extern PNG_EXPORT(png_uint_32, png_get_y_offset_microns) PNGARG((png_structp
extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp
png_ptr, png_infop info_ptr));
#endif /* PNG_EASY_ACCESS_SUPPORTED */
@@ -2050,6 +2094,12 @@ extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp
png_ptr, png_infop info_ptr, png_unknown_chunkpp entries));
#endif
/* Png_free_data() will turn off the "valid" flag for anything it frees.
If you need to turn it off for a chunk that your application has freed,
you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); */
extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr,
png_infop info_ptr, int mask));
#if defined(PNG_INFO_IMAGE_SUPPORTED)
/* The "params" pointer is currently not used and is for future expansion. */
extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr,
@@ -2069,19 +2119,28 @@ extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr,
*/
#ifdef PNG_DEBUG
#if (PNG_DEBUG > 0)
#if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER)
#include <crtdbg.h>
#define png_debug(l,m) if (PNG_DEBUG > l) _RPT0(_CRT_WARN,m)
#define png_debug1(l,m,p1) if (PNG_DEBUG > l) _RPT1(_CRT_WARN,m,p1)
#define png_debug2(l,m,p1,p2) if (PNG_DEBUG > l) _RPT2(_CRT_WARN,m,p1,p2)
#else /* PNG_DEBUG_FILE || !_MSC_VER */
#ifndef PNG_DEBUG_FILE
#define PNG_DEBUG_FILE stderr
#endif /* PNG_DEBUG_FILE */
#define png_debug(l,m) if (PNG_DEBUG > l) \
fprintf(PNG_DEBUG_FILE,"%s"m,(l==1 ? "\t" : \
(l==2 ? "\t\t":(l>2 ? "\t\t\t":""))))
#define png_debug1(l,m,p1) if (PNG_DEBUG > l) \
fprintf(PNG_DEBUG_FILE,"%s"m,(l==1 ? "\t" : \
(l==2 ? "\t\t":(l>2 ? "\t\t\t":""))),p1)
#define png_debug2(l,m,p1,p2) if (PNG_DEBUG > l) \
fprintf(PNG_DEBUG_FILE,"%s"m,(l==1 ? "\t" : \
(l==2 ? "\t\t":(l>2 ? "\t\t\t":""))),p1,p2)
#define png_debug(l,m) \
if (PNG_DEBUG > l) \
fprintf(PNG_DEBUG_FILE,"%s"m,(l==1 ? "\t" : \
(l==2 ? "\t\t":(l>2 ? "\t\t\t":""))))
#define png_debug1(l,m,p1) \
if (PNG_DEBUG > l) \
fprintf(PNG_DEBUG_FILE,"%s"m,(l==1 ? "\t" : \
(l==2 ? "\t\t":(l>2 ? "\t\t\t":""))),p1)
#define png_debug2(l,m,p1,p2) \
if (PNG_DEBUG > l) \
fprintf(PNG_DEBUG_FILE,"%s"m,(l==1 ? "\t" : \
(l==2 ? "\t\t":(l>2 ? "\t\t\t":""))),p1,p2)
#endif /* _MSC_VER */
#endif /* (PNG_DEBUG > 0) */
#endif /* PNG_DEBUG */
#ifndef png_debug
@@ -2102,7 +2161,7 @@ extern PNG_EXPORT(png_charp,png_get_header_version) PNGARG((png_structp png_ptr)
extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr));
#define PNG_HEADER_VERSION_STRING \
" libpng version 1.0.6i - May 1, 2000 (header)\n"
" libpng version 1.0.7rc2 - June 28, 2000 (header)\n"
#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED
/* With these routines we avoid an integer divide, which will be slower on
@@ -2168,8 +2227,6 @@ extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr));
#define PNG_WROTE_tIME 0x200
#define PNG_WROTE_INFO_BEFORE_PLTE 0x400
#define PNG_BACKGROUND_IS_GRAY 0x800
#define PNG_CREATED_READ_STRUCT 0x1000
#define PNG_CREATED_WRITE_STRUCT 0x2000
/* flags for the transformations the PNG library does on the image data */
#define PNG_BGR 0x0001
@@ -2225,6 +2282,7 @@ extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr));
#define PNG_FLAG_FREE_HIST 0x4000
#define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000L
#define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000L
#define PNG_FLAG_LIBRARY_MISMATCH 0x20000L
/* For use in png_set_keep_unknown, png_handle_as_unknown */
#define HANDLE_CHUNK_AS_DEFAULT 0
@@ -2330,14 +2388,24 @@ PNG_EXTERN png_uint_16 png_get_uint_16 PNGARG((png_bytep buf));
#endif /* !PNG_READ_BIG_ENDIAN_SUPPORTED */
/* Initialize png_ptr struct for reading, and allocate any other memory.
* (old interface - NOT DLL EXPORTED).
* (old interface - DEPRECATED).
*/
extern void png_read_init PNGARG((png_structp png_ptr));
extern PNG_EXPORT(void,png_read_init) PNGARG((png_structp png_ptr));
#define png_read_init(png_ptr) png_read_init_2(png_ptr, \
PNG_LIBPNG_VER_STRING, sizeof(png_struct), sizeof(png_info));
extern PNG_EXPORT(void,png_read_init_2) PNGARG((png_structp png_ptr,
png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t
png_info_size));
/* Initialize png_ptr struct for writing, and allocate any other memory.
* (old interface - NOT DLL EXPORTED).
* (old interface - DEPRECATED).
*/
extern void png_write_init PNGARG((png_structp png_ptr));
extern PNG_EXPORT(void,png_write_init) PNGARG((png_structp png_ptr));
#define png_write_init(png_ptr) png_write_init_2(png_ptr, \
PNG_LIBPNG_VER_STRING, sizeof(png_struct), sizeof(png_info));
extern PNG_EXPORT(void,png_write_init_2) PNGARG((png_structp png_ptr,
png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t
png_info_size));
/* Allocate memory for an internal libpng struct */
PNG_EXTERN png_voidp png_create_struct PNGARG((int type));
@@ -2885,5 +2953,6 @@ PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr,
}
#endif
#endif /* PNG_VERSION_INFO_ONLY */
/* do not put anything past this line */
#endif /* _PNG_H */
#endif /* PNG_H */

221
png_ptr.h
View File

@@ -1,221 +0,0 @@
struct png_struct_def
{
#ifdef PNG_SETJMP_SUPPORTED
jmp_buf jmpbuf; /* used in png_error */
#endif
png_error_ptr error_fn; /* function for printing errors and aborting */
png_error_ptr warning_fn; /* function for printing warnings */
png_voidp error_ptr; /* user supplied struct for error functions */
png_rw_ptr write_data_fn; /* function for writing output data */
png_rw_ptr read_data_fn; /* function for reading input data */
png_voidp io_ptr; /* ptr to application struct for I/O functions*/
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
png_user_transform_ptr read_user_transform_fn; /* user read transform */
#endif
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
png_user_transform_ptr write_user_transform_fn; /* user write transform */
#endif
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
png_voidp user_transform_ptr; /* user supplied struct for user transform */
png_byte user_transform_depth; /* bit depth of user transformed pixels */
png_byte user_transform_channels; /* channels in user transformed pixels */
#endif
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
png_voidp user_chunk_ptr;
png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */
#endif
png_uint_32 mode; /* tells us where we are in the PNG file */
png_uint_32 flags; /* flags indicating various things to libpng */
png_uint_32 transformations; /* which transformations to perform */
z_stream zstream; /* pointer to decompression structure (below) */
png_bytep zbuf; /* buffer for zlib */
png_size_t zbuf_size; /* size of zbuf */
int zlib_level; /* holds zlib compression level */
int zlib_method; /* holds zlib compression method */
int zlib_window_bits; /* holds zlib compression window bits */
int zlib_mem_level; /* holds zlib compression memory level */
int zlib_strategy; /* holds zlib compression strategy */
png_uint_32 width; /* width of image in pixels */
png_uint_32 height; /* height of image in pixels */
png_uint_32 num_rows; /* number of rows in current pass */
png_uint_32 usr_width; /* width of row at start of write */
png_uint_32 rowbytes; /* size of row in bytes */
png_uint_32 irowbytes; /* size of current interlaced row in bytes */
png_uint_32 iwidth; /* width of current interlaced row in pixels */
png_uint_32 row_number; /* current row in interlace pass */
png_bytep prev_row; /* buffer to save previous (unfiltered) row */
png_bytep row_buf; /* buffer to save current (unfiltered) row */
png_bytep sub_row; /* buffer to save "sub" row when filtering */
png_bytep up_row; /* buffer to save "up" row when filtering */
png_bytep avg_row; /* buffer to save "avg" row when filtering */
png_bytep paeth_row; /* buffer to save "Paeth" row when filtering */
png_row_info row_info; /* used for transformation routines */
png_uint_32 idat_size; /* current IDAT size for read */
png_uint_32 crc; /* current chunk CRC value */
png_colorp palette; /* palette from the input file */
png_uint_16 num_palette; /* number of color entries in palette */
png_uint_16 num_trans; /* number of transparency values */
png_byte chunk_name[5]; /* null-terminated name of current chunk */
png_byte compression; /* file compression type (always 0) */
png_byte filter; /* file filter type (always 0) */
png_byte interlaced; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */
png_byte pass; /* current interlace pass (0 - 6) */
png_byte do_filter; /* row filter flags (see PNG_FILTER_ below ) */
png_byte color_type; /* color type of file */
png_byte bit_depth; /* bit depth of file */
png_byte usr_bit_depth; /* bit depth of users row */
png_byte pixel_depth; /* number of bits per pixel */
png_byte channels; /* number of channels in file */
png_byte usr_channels; /* channels at start of write */
png_byte sig_bytes; /* magic bytes read/written from start of file */
#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
png_uint_16 filler; /* filler bytes for pixel expansion */
#endif
#if defined(PNG_READ_bKGD_SUPPORTED)
png_byte background_gamma_type;
#ifdef PNG_FLOATING_POINT_SUPPORTED
float background_gamma;
#endif
png_color_16 background; /* background color in screen gamma space */
# if defined(PNG_READ_GAMMA_SUPPORTED)
png_color_16 background_1; /* background normalized to gamma 1.0 */
# endif /* PNG_READ_GAMMA && PNG_READ_bKGD_SUPPORTED */
#endif /* PNG_READ_bKGD_SUPPORTED */
#if defined(PNG_WRITE_FLUSH_SUPPORTED)
png_flush_ptr output_flush_fn;/* Function for flushing output */
png_uint_32 flush_dist; /* how many rows apart to flush, 0 - no flush */
png_uint_32 flush_rows; /* number of rows written since last flush */
#endif
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
int gamma_shift; /* number of "insignificant" bits 16-bit gamma */
#ifdef PNG_FLOATING_POINT_SUPPORTED
float gamma; /* file gamma value */
float screen_gamma; /* screen gamma value (display_exponent) */
#endif
#endif
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
png_bytep gamma_table; /* gamma table for 8-bit depth files */
png_bytep gamma_from_1; /* converts from 1.0 to screen */
png_bytep gamma_to_1; /* converts from file to 1.0 */
png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */
png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */
png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */
#endif
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined (PNG_READ_sBIT_SUPPORTED)
png_color_8 sig_bit; /* significant bits in each available channel */
#endif
#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
png_color_8 shift; /* shift for significant bit tranformation */
#endif
#if defined(PNG_READ_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \
|| defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
png_bytep trans; /* transparency values for paletted files */
png_color_16 trans_values; /* transparency values for non-paletted files */
#endif
png_read_status_ptr read_row_fn; /* called after each row is decoded */
png_write_status_ptr write_row_fn; /* called after each row is encoded */
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
png_progressive_info_ptr info_fn; /* called after header data fully read */
png_progressive_row_ptr row_fn; /* called after each prog. row is decoded */
png_progressive_end_ptr end_fn; /* called after image is complete */
png_bytep save_buffer_ptr; /* current location in save_buffer */
png_bytep save_buffer; /* buffer for previously read data */
png_bytep current_buffer_ptr; /* current location in current_buffer */
png_bytep current_buffer; /* buffer for recently used data */
png_uint_32 push_length; /* size of current input chunk */
png_uint_32 skip_length; /* bytes to skip in input data */
png_size_t save_buffer_size; /* amount of data now in save_buffer */
png_size_t save_buffer_max; /* total size of save_buffer */
png_size_t buffer_size; /* total amount of available input data */
png_size_t current_buffer_size; /* amount of data now in current_buffer */
int process_mode; /* what push library is currently doing */
int cur_palette; /* current push library palette index */
# if defined(PNG_READ_TEXT_SUPPORTED)
png_size_t current_text_size; /* current size of text input data */
png_size_t current_text_left; /* how much text left to read in input */
png_charp current_text; /* current text chunk buffer */
png_charp current_text_ptr; /* current location in current_text */
# endif /* PNG_PROGRESSIVE_READ_SUPPORTED && PNG_READ_TEXT_SUPPORTED */
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
/* for the Borland special 64K segment handler */
png_bytepp offset_table_ptr;
png_bytep offset_table;
png_uint_16 offset_table_number;
png_uint_16 offset_table_count;
png_uint_16 offset_table_count_free;
#endif
#if defined(PNG_READ_DITHER_SUPPORTED)
png_bytep palette_lookup; /* lookup table for dithering */
png_bytep dither_index; /* index translation for palette files */
#endif
#if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_READ_hIST_SUPPORTED)
png_uint_16p hist; /* histogram */
#endif
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
png_byte heuristic_method; /* heuristic for row filter selection */
png_byte num_prev_filters; /* number of weights for previous rows */
png_bytep prev_filters; /* filter type(s) of previous row(s) */
png_uint_16p filter_weights; /* weight(s) for previous line(s) */
png_uint_16p inv_filter_weights; /* 1/weight(s) for previous line(s) */
png_uint_16p filter_costs; /* relative filter calculation cost */
png_uint_16p inv_filter_costs; /* 1/relative filter calculation cost */
#endif
#if defined(PNG_TIME_RFC1123_SUPPORTED)
png_charp time_buffer; /* String to hold RFC 1123 time text */
#endif
#ifdef PNG_USER_MEM_SUPPORTED
png_voidp mem_ptr; /* user supplied struct for mem functions */
png_malloc_ptr malloc_fn; /* function for allocating memory */
png_free_ptr free_fn; /* function for freeing memory */
#endif
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
png_byte rgb_to_gray_status;
png_uint_16 rgb_to_gray_red_coeff;
png_uint_16 rgb_to_gray_green_coeff;
png_uint_16 rgb_to_gray_blue_coeff;
#endif
#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \
defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)
png_byte empty_plte_permitted;
#endif
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
int num_chunk_list;
png_bytep chunk_list;
#endif
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
png_fixed_point int_gamma;
#endif
png_uint_32 free_me; /* flags items libpng is responsible for freeing */
};

6
pngasmrd.h
View File

@@ -1,11 +1,14 @@
/* pngasmrd.h - assembler version of utilities to read a PNG file
*
* libpng 1.0.6i - May 1, 2000
* libpng 1.0.7rc2 - June 28, 2000
* For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1999, 2000 Glenn Randers-Pehrson
*
*/
#ifndef PNGASMRD_H
#define PNGASMRD_H
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
/* Set this in the makefile for VC++ on Pentium, not in pngconf.h */
@@ -33,3 +36,4 @@
*/
#endif
#endif /* PNGASMRD_H */

301
pngconf.h
View File

@@ -1,11 +1,10 @@
/* pngconf.h - machine configurable file for libpng
*
* libpng 1.0.6i - May 1, 2000
* libpng 1.0.7rc2 - June 28, 2000
* For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
* Copyright (c) 1996, 1997 Andreas Dilger
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*/
/* Any machine specific code is near the front of this file, so if you
@@ -17,38 +16,8 @@
#ifndef PNGCONF_H
#define PNGCONF_H
/* The following support, added at version 1.0.6, will be turned on by
* default in version 2.0.0.
* They have been turned off here in case you need binary compatibility
* with old applications that require the length of png_struct and
* png_info to remain at the old length.
*/
#include "pngcrush.h" /* except for this line, this is libpng's pngconf.h */
#ifdef PNG_LEGACY_SUPPORTED
#define PNG_NO_FREE_ME
#define PNG_NO_READ_UNKNOWN_CHUNKS
#define PNG_NO_WRITE_UNKNOWN_CHUNKS
#define PNG_NO_READ_USER_CHUNKS
#define PNG_NO_READ_iCCP
#define PNG_NO_WRITE_iCCP
#define PNG_NO_READ_sCAL
#define PNG_NO_WRITE_sCAL
#define PNG_NO_READ_sPLT
#define PNG_NO_WRITE_sPLT
#define PNG_NO_INFO_IMAGE
#define PNG_NO_READ_RGB_TO_GRAY
#define PNG_NO_READ_USER_TRANSFORM
#define PNG_NO_WRITE_USER_TRANSFORM
#define PNG_NO_USER_MEM
#define PNG_NO_READ_EMPTY_PLTE
#endif
#ifndef PNG_NO_FREE_ME
#define PNG_FREE_ME_SUPPORTED
#endif
/* 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
@@ -66,6 +35,10 @@
#define PNG_ZBUF_SIZE 8192
#endif
#ifndef PNG_NO_FLOATING_POINT_SUPPORTED
#define PNG_FLOATING_POINT_SUPPORTED
#endif
/* If you are running on a machine where you cannot allocate more
* than 64K of memory at once, uncomment this. While libpng will not
* normally need that much memory in a chunk (unless you load up a very
@@ -91,6 +64,14 @@
* #define PNG_NO_STDIO
*/
#ifdef PNG_BUILD_DLL
# ifndef PNG_CONSOLE_IO_SUPPORTED
# ifndef PNG_NO_CONSOLE_IO
# define PNG_NO_CONSOLE_IO
# endif
# endif
#endif
# ifdef PNG_NO_STDIO
# ifndef PNG_NO_CONSOLE_IO
# define PNG_NO_CONSOLE_IO
@@ -151,14 +132,15 @@
/* This is an attempt to force a single setjmp behaviour on Linux. If
* the X config stuff didn't define _BSD_SOURCE we wouldn't need this.
*/
# ifdef __linux__
# ifdef _BSD_SOURCE
# define _PNG_SAVE_BSD_SOURCE
# define PNG_SAVE_BSD_SOURCE
# undef _BSD_SOURCE
# endif
# ifdef _SETJMP_H
__png.h__ already includes setjmp.h
__dont__ include it again
__png.h__ already includes setjmp.h;
__dont__ include it again.;
# endif
#endif /* __linux__ */
@@ -166,13 +148,19 @@
#include <setjmp.h>
# ifdef __linux__
# ifdef _PNG_SAVE_BSD_SOURCE
# ifdef PNG_SAVE_BSD_SOURCE
# define _BSD_SOURCE
# undef _PNG_SAVE_BSD_SOURCE
# undef PNG_SAVE_BSD_SOURCE
# endif
# endif /* __linux__ */
#endif /* PNG_SETJMP_SUPPORTED */
#if defined(_AIX) && defined(__xlC__)
/* This prevents "AIX/xlC" from generating an "index(s,c)" macro in strings.h
* that conflicts with libpng's png_color_16.index */
#undef __STR__
#endif
#ifdef BSD
#include <strings.h>
#else
@@ -196,7 +184,7 @@
* them inside an appropriate ifdef/endif pair for portability.
*/
#if !defined(PNG_NO_FLOATING_POINT_SUPPORTED)
#if defined(PNG_FLOATING_POINT_SUPPORTED)
#if defined(MACOS)
/* We need to check that <math.h> hasn't already been included earlier
* as it seems it doesn't agree with <fp.h>, yet we should really use
@@ -208,6 +196,12 @@
#else
#include <math.h>
#endif
#if defined(_AMIGA) && defined(__SASC) && defined(_M68881)
/* Amiga SAS/C: We must include builtin FPU functions when compiling using
* MATH=68881
*/
#include <m68881.h>
#endif
#endif
/* Codewarrior on NT has linking problems without this. */
@@ -290,25 +284,69 @@
/* Any features you will not be using can be undef'ed here */
/* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user
to turn it off with "*TRANSFORMS_NOT_SUPPORTED" or *PNG_NO_*_TRANSFORMS
on the compile line, then pick and choose which ones to define without
having to edit this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED
if you only want to have a png-compliant reader/writer but don't need
any of the extra transformations. This saves about 80 kbytes in a
typical installation of the library. (PNG_NO_* form added in version
1.0.1c, for consistency)
* to turn it off with "*TRANSFORMS_NOT_SUPPORTED" or *PNG_NO_*_TRANSFORMS
* on the compile line, then pick and choose which ones to define without
* having to edit this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED
* if you only want to have a png-compliant reader/writer but don't need
* any of the extra transformations. This saves about 80 kbytes in a
* typical installation of the library. (PNG_NO_* form added in version
* 1.0.1c, for consistency)
*/
#ifndef PNG_NO_FLOATING_POINT_SUPPORTED
#define PNG_FLOATING_POINT_SUPPORTED
/* The size of the png_text structure changed in libpng-1.0.6 when
* iTXt is supported. It is turned off by default, to support old apps
* that malloc the png_text structure instead of calling png_set_text()
* and letting libpng malloc it. It will be turned on by default in
* libpng-2.0.0.
*/
#ifndef PNG_iTXt_SUPPORTED
# ifndef PNG_READ_iTXt_SUPPORTED
# define PNG_NO_READ_iTXt
# endif
# ifndef PNG_WRITE_iTXt_SUPPORTED
# define PNG_NO_WRITE_iTXt
# endif
#endif
/* The following support, added after version 1.0.0, can be turned off here en
* masse by defining PNG_LEGACY_SUPPORTED in case you need binary compatibility
* with old applications that require the length of png_struct and png_info
* to remain unchanged.
*/
#ifdef PNG_LEGACY_SUPPORTED
#define PNG_NO_FREE_ME
#define PNG_NO_READ_UNKNOWN_CHUNKS
#define PNG_NO_WRITE_UNKNOWN_CHUNKS
#define PNG_NO_READ_USER_CHUNKS
#define PNG_NO_READ_iCCP
#define PNG_NO_WRITE_iCCP
#define PNG_NO_READ_iTXt
#define PNG_NO_WRITE_iTXt
#define PNG_NO_READ_sCAL
#define PNG_NO_WRITE_sCAL
#define PNG_NO_READ_sPLT
#define PNG_NO_WRITE_sPLT
#define PNG_NO_INFO_IMAGE
#define PNG_NO_READ_RGB_TO_GRAY
#define PNG_NO_READ_USER_TRANSFORM
#define PNG_NO_WRITE_USER_TRANSFORM
#define PNG_NO_USER_MEM
#define PNG_NO_READ_EMPTY_PLTE
#define PNG_NO_FIXED_POINT_SUPPORTED
#endif
/* Ignore attempt to turn off both floating and fixed point support */
#ifndef PNG_FLOATING_POINT_SUPPORTED
#if !defined(PNG_FLOATING_POINT_SUPPORTED) || \
!defined(PNG_NO_FIXED_POINT_SUPPORTED)
#define PNG_FIXED_POINT_SUPPORTED
#endif
#ifndef PNG_NO_FREE_ME
#define PNG_FREE_ME_SUPPORTED
#endif
#if !defined(PNG_READ_TRANSFORMS_NOT_SUPPORTED) && \
!defined(PNG_NO_READ_TRANSFORMS)
#define PNG_READ_TRANSFORMS_SUPPORTED
@@ -382,9 +420,11 @@
/* still have interlacing unless you change the following line: */
#define PNG_READ_INTERLACING_SUPPORTED /* required for PNG-compliant decoders */
#ifndef PNG_NO_READ_COMPOSITED_NODIV
#ifndef PNG_NO_READ_COMPOSITE_NODIV
#ifndef PNG_NO_READ_COMPOSITED_NODIV /* libpng-1.0.x misspelling */
#define PNG_READ_COMPOSITE_NODIV_SUPPORTED /* well tested on Intel and SGI */
#endif
#endif
#ifndef PNG_NO_READ_EMPTY_PLTE
#define PNG_READ_EMPTY_PLTE_SUPPORTED /* useful for MNG applications */
@@ -476,21 +516,6 @@ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
#define PNG_ASSEMBLER_CODE_SUPPORTED
#endif
/* Do not use global arrays (helps with building DLL's)
* They are no longer used in libpng itself, since version 1.0.5c,
* but might be required for some pre-1.0.5c applications.
*/
#ifdef PNG_NO_GLOBAL_ARRAYS
# define PNG_USE_LOCAL_ARRAYS
#else
# if defined(__GNUC__) && defined(WIN32)
# define PNG_NO_GLOBAL_ARRAYS
# define PNG_USE_LOCAL_ARRAYS
# else
# define PNG_USE_GLOBAL_ARRAYS
# endif
#endif
/* These are currently experimental features, define them if you want */
/* very little testing */
@@ -507,6 +532,11 @@ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
#define PNG_READ_BIG_ENDIAN_SUPPORTED
*/
/* Buggy compilers (e.g., gcc 2.7.2.2) need this */
/*
#define PNG_NO_POINTER_INDEXING
*/
/* These functions are turned off by default, as they will be phased out. */
/*
#define PNG_USELESS_TESTS_SUPPORTED
@@ -605,13 +635,15 @@ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
#endif
#ifndef PNG_NO_READ_UNKNOWN_CHUNKS
# define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
# define PNG_UNKNOWN_CHUNKS_SUPPORTED
# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED
# define PNG_UNKNOWN_CHUNKS_SUPPORTED
# endif
# ifndef PNG_NO_HANDLE_AS_UNKNOWN
# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED
# endif
#endif
#if !defined (PNG_NO_READ_USER_CHUNKS) && \
defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
# define PNG_READ_USER_CHUNKS_SUPPORTED
# define PNG_USER_CHUNKS_SUPPORTED
# ifdef PNG_NO_READ_UNKNOWN_CHUNKS
@@ -894,66 +926,109 @@ typedef charf * png_zcharp;
typedef charf * FAR * png_zcharpp;
typedef z_stream FAR * png_zstreamp;
/*
* Define PNG_BUILD_DLL if the module being built is a Windows
* LIBPNG DLL.
*
* Define PNG_USE_DLL if you want to *link* to the Windows LIBPNG DLL.
* It is equivalent to Microsoft predefined macro _DLL which is
* automatically defined when you compile using the share
* version of the CRT (C Run-Time library)
*/
#ifndef PNG_EXPORT
/* GRR 20000206: based on zconf.h and MSVC 5.0 docs */
# if defined(_MSC_VER) && defined(_DLL)
# define PNG_EXPORT(type,symbol) type __declspec(dllexport) symbol
#if !defined(PNG_DLL) && (defined(PNG_BUILD_DLL) || defined(PNG_USE_DLL))
# define PNG_DLL
#endif
/* Do not use global arrays (helps with building DLL's)
* They are no longer used in libpng itself, since version 1.0.5c,
* but might be required for some pre-1.0.5c applications.
*/
#if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS)
# if defined(PNG_NO_GLOBAL_ARRAYS) || (defined(__GNUC__) && defined(PNG_DLL))
# define PNG_USE_LOCAL_ARRAYS
# else
# define PNG_USE_GLOBAL_ARRAYS
# endif
#endif
#ifndef PNGAPI
#if defined(__MINGW32__) || defined(__CYGWIN32__) && !defined(PNG_MODULEDEF)
# ifndef PNG_NO_MODULEDEF
# define PNG_NO_MODULEDEF
# endif
#endif
#if !defined(PNG_IMPEXP) && defined(PNG_BUILD_DLL) && !defined(PNG_NO_MODULEDEF)
# define PNG_IMPEXP
#endif
#if defined(PNG_DLL) || defined(_DLL) || defined(__DLL__ ) || \
defined(_Windows) || defined(_WINDOWS) || \
defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
# ifdef __GNUC__
# define PNGAPI __cdecl
# else
# define PNGAPI _cdecl
# endif
/* allow for compilation as a DLL under MS Windows */
# ifdef __WIN32DLL__ /* Borland? */
# define PNG_EXPORT(type,symbol) __declspec(dllexport) type symbol
# if !defined(PNG_IMPEXP) && (!defined(PNG_DLL) || \
0 /* WINCOMPILER_WITH_NO_SUPPORT_FOR_DECLIMPEXP */)
# define PNG_IMPEXP
# endif
/* this variant is used in Mozilla; may correspond to MSVC++ 6.0 changes */
# ifdef ALT_WIN32_DLL
# define PNG_EXPORT(type,symbol) type __attribute__((dllexport)) symbol
# endif
# if !defined(PNG_IMPEXP)
/* allow for compilation as a DLL with Borland C++ 5.0 */
# if defined(__BORLANDC__) && defined(_Windows) && defined(__DLL__)
# define PNG_EXPORT(type,symbol) type _export symbol
# endif
# define PNG_EXPORT_TYPE1(type,symbol) PNG_IMPEXP type PNGAPI symbol
# define PNG_EXPORT_TYPE2(type,symbol) type PNG_IMPEXP PNGAPI symbol
/* allow for compilation as shared lib under BeOS */
# ifdef __BEOSDLL__
# define PNG_EXPORT(type,symbol) __declspec(export) type symbol
/* Borland/Microsoft */
# if defined(_MSC_VER) || defined(__BORLANDC__)
# if (_MSC_VER >= 800) || (__BORLANDC__ >= 0x500)
# define PNG_EXPORT PNG_EXPORT_TYPE1
# else
# define PNG_EXPORT PNG_EXPORT_TYPE2
# if defined(PNG_BUILD_DLL)
# define PNG_IMPEXP __export
# else
# define PNG_IMPEXP /*__import*/ /* doesn't exist AFAIK in
VC++*/
# endif /* Exists in Borland C++ for
C++ classes (== huge) */
# endif
# endif
# if !defined(PNG_IMPEXP)
# if defined(PNG_BUILD_DLL)
# define PNG_IMPEXP __declspec(dllexport)
# else
# define PNG_IMPEXP __declspec(dllimport)
# endif
# endif
# endif /* PNG_IMPEXP */
#else /* !(DLL || WINDOWS) */
# if 0 /* ... other platforms, with other meanings */
# else
# define PNGAPI
# define PNG_IMPEXP
# endif
#endif
#endif
#ifndef PNG_EXPORT
# define PNG_EXPORT(type,symbol) type symbol
#endif
#if defined(__MINGW32__) || defined(__CYGWIN32__)
# define PNG_ATTR_DLLIMP
# define PNG_EXPORT(type,symbol) PNG_IMPEXP type PNGAPI symbol
#endif
#ifdef PNG_USE_GLOBAL_ARRAYS
#ifndef PNG_EXPORT_VAR
# if defined(_MSC_VER) && defined(_DLL) /* GRR 20000206 */
# define PNG_EXPORT_VAR(type) extern type __declspec(dllexport)
# endif
# ifdef PNG_DECL_DLLEXP
# define PNG_EXPORT_VAR(type) extern __declspec(dllexport) type
# endif
# ifdef PNG_ATTR_DLLEXP
# define PNG_EXPORT_VAR(type) extern type __attribute__((dllexport))
# endif
# ifdef PNG_DECL_DLLIMP
# define PNG_EXPORT_VAR(type) extern __declspec(dllimport) type
# endif
# ifdef PNG_ATTR_DLLIMP
# define PNG_EXPORT_VAR(type) extern type __attribute__((dllimport))
# endif
# define PNG_EXPORT_VAR(type) extern type
#endif
#endif
#ifndef PNG_EXPORT_VAR
# define PNG_EXPORT_VAR(type) extern type
#endif
/* User may want to use these so not in PNG_INTERNAL. Any library functions
* that are passed far data must be model independent.
/* User may want to use these so they are not in PNG_INTERNAL. Any library
* functions that are passed far data must be model independent.
*/
#ifndef PNG_ABORT

737
pngcrush.c
View File

File diff suppressed because it is too large Load Diff

35
pngcrush.h
View File

@@ -6,11 +6,23 @@
#ifndef PNGCRUSH_H
#define PNGCRUSH_H
#ifdef PNG_LIBPNG_VER
#define PNGCRUSH_LIBPNG_VER PNG_LIBPNG_VER
#else
/* This must agree with PNG_LIBPNG_VER; you have to define it manually
here if you are using libpng-1.0.6h or earlier */
#define PNGCRUSH_LIBPNG_VER 10007
#endif
#ifndef PNG_USER_MEM_SUPPORTED
# define PNG_USER_MEM_SUPPORTED
#endif
#define PNG_NO_LEGACY_SUPPORTED
#define PNG_SETJMP_NOT_SUPPORTED
#if PNG_LIBPNG_VER > 10006
#if PNGCRUSH_LIBPNG_VER > 10006
#define PNG_NO_FLOATING_POINT_SUPPORTED
#define PNG_READ_GRAY_TO_RGB_SUPPORTED
#endif
@@ -19,8 +31,6 @@
#define PNG_NO_WRITE_cHRM
#define PNG_NO_READ_hIST
#define PNG_NO_WRITE_hIST
#define PNG_NO_READ_iCCP
#define PNG_NO_WRITE_iCCP
#define PNG_NO_READ_pCAL
#define PNG_NO_WRITE_pCAL
#define PNG_NO_READ_sCAL
@@ -32,7 +42,7 @@
#define PNG_NO_INFO_IMAGE
#define PNG_NO_READ_USER_CHUNKS
#define PNG_NO_EASY_ACCESS
#define PNG_EASY_ACCESS
#define PNG_NO_READ_DITHER
#define PNG_NO_READ_EMPTY_PLTE
#define PNG_NO_WRITE_TRANSFORMS
@@ -45,27 +55,31 @@
#define PNG_READ_EXPAND_SUPPORTED
#define PNG_READ_FILLER_SUPPORTED
#if (PNG_LIBPNG_VER > 10002)
#if (PNGCRUSH_LIBPNG_VER > 10002)
/* versions 0.96 through 1.0.2 have a stub png_rgb_to_gray() with the
* wrong number of parameters */
# define PNG_READ_RGB_TO_GRAY_SUPPORTED
#endif
#ifndef PNG_NO_iTXt_SUPPORTED
# define PNG_iTXt_SUPPORTED
#endif
#ifndef PNG_NO_FLOATING_POINT_SUPPORTED
# define PNG_READ_GRAY_TO_RGB_SUPPORTED
# define PNG_READ_BACKGROUND_SUPPORTED
# define PNG_READ_GAMMA_SUPPORTED
#else
# if (PNG_LIBPNG_VER < 10007)
# if (PNGCRUSH_LIBPNG_VER < 10007)
# define PNG_NO_READ_RGB_TO_GRAY
# endif
#endif
#if !defined(PNG_ZBUF_SIZE) && (PNG_LIBPNG_VER > 97)
#if !defined(PNG_ZBUF_SIZE) && (PNGCRUSH_LIBPNG_VER > 97)
# define PNG_ZBUF_SIZE 524288 /* increases the IDAT size */
#endif
/* Changed in version 0.99 */
#if PNG_LIBPNG_VER < 99
#if PNGCRUSH_LIBPNG_VER < 99
#undef PNG_CONST
#ifndef PNG_NO_CONST
# define PNG_CONST const
@@ -74,11 +88,10 @@
#endif
#endif
/* We are not supporting legacy code so we don't need the reserved space */
/* This allows png_default_error() to return, when it is called after our
own exception handling, which only returns after "Too many IDAT's",
that we want to handle as a warning instead of an error. */
or anything else that we might want to handle as a warning instead of
an error. */
#define PNG_ABORT()
#endif

40
pngerror.c
View File

@@ -1,11 +1,11 @@
/* pngerror.c - stub functions for i/o and memory allocation
*
* libpng 1.0.6i - May 1, 2000
* libpng 1.0.7rc2 - June 28, 2000
* For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
* Copyright (c) 1996, 1997 Andreas Dilger
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*
* This file provides a location for all error handling. Users who
* need special error handling are expected to write replacement functions
@@ -16,9 +16,11 @@
#define PNG_INTERNAL
#include "png.h"
static void png_default_error PNGARG((png_structp png_ptr,
static void /* PRIVATE */
png_default_error PNGARG((png_structp png_ptr,
png_const_charp message));
static void png_default_warning PNGARG((png_structp png_ptr,
static void /* PRIVATE */
png_default_warning PNGARG((png_structp png_ptr,
png_const_charp message));
/* This function is called whenever there is a fatal error. This function
@@ -26,7 +28,7 @@ static void png_default_warning PNGARG((png_structp png_ptr,
* you should supply a replacement error function and use png_set_error_fn()
* to replace the error function at run-time.
*/
void
void PNGAPI
png_error(png_structp png_ptr, png_const_charp message)
{
if (png_ptr->error_fn != NULL)
@@ -42,7 +44,7 @@ png_error(png_structp png_ptr, png_const_charp message)
* you should supply a replacement warning function and use
* png_set_error_fn() to replace the warning function at run-time.
*/
void
void PNGAPI
png_warning(png_structp png_ptr, png_const_charp message)
{
if (png_ptr->warning_fn != NULL)
@@ -62,7 +64,7 @@ static PNG_CONST char png_digit[16] = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
};
static void
static void /* PRIVATE */
png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp message)
{
int iout = 0, iin = 0;
@@ -94,7 +96,7 @@ png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp message
}
}
void
void PNGAPI
png_chunk_error(png_structp png_ptr, png_const_charp message)
{
char msg[16+64];
@@ -102,7 +104,7 @@ png_chunk_error(png_structp png_ptr, png_const_charp message)
png_error(png_ptr, msg);
}
void
void PNGAPI
png_chunk_warning(png_structp png_ptr, png_const_charp message)
{
char msg[16+64];
@@ -115,11 +117,14 @@ png_chunk_warning(png_structp png_ptr, png_const_charp message)
* function is used by default, or if the program supplies NULL for the
* error function pointer in png_set_error_fn().
*/
static void
static void /* PRIVATE */
png_default_error(png_structp png_ptr, png_const_charp message)
{
#ifndef PNG_NO_CONSOLE_IO
fprintf(stderr, "libpng error: %s\n", message);
#else
if (message)
/* make compiler happy */ ;
#endif
#ifdef PNG_SETJMP_SUPPORTED
@@ -133,7 +138,7 @@ png_default_error(png_structp png_ptr, png_const_charp message)
longjmp(png_ptr->jmpbuf, 1);
# endif
#else
if (png_ptr == NULL)
if (png_ptr)
/* make compiler happy */ ;
PNG_ABORT();
#endif
@@ -144,13 +149,16 @@ png_default_error(png_structp png_ptr, png_const_charp message)
* here if you don't want them to. In the default configuration, png_ptr is
* not used, but it is passed in case it may be useful.
*/
static void
static void /* PRIVATE */
png_default_warning(png_structp png_ptr, png_const_charp message)
{
#ifndef PNG_NO_CONSOLE_IO
fprintf(stderr, "libpng warning: %s\n", message);
#else
if (message)
/* appease compiler */ ;
#endif
if (png_ptr == NULL)
if (png_ptr)
return;
}
@@ -159,7 +167,7 @@ png_default_warning(png_structp png_ptr, png_const_charp message)
* return to the calling routine or serious problems will occur. The return
* method used in the default routine calls longjmp(png_ptr->jmpbuf, 1)
*/
void
void PNGAPI
png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
png_error_ptr error_fn, png_error_ptr warning_fn)
{
@@ -173,7 +181,7 @@ png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
* functions. The application should free any memory associated with this
* pointer before png_write_destroy and png_read_destroy are called.
*/
png_voidp
png_voidp PNGAPI
png_get_error_ptr(png_structp png_ptr)
{
return ((png_voidp)png_ptr->error_ptr);

68
pngerror.h
View File

@@ -1,68 +0,0 @@
/* This linked list implements a stack structure where jmpbuf context
* is to be saved. It will allow multiple, nested calls of setjmp/longjmp...
*/
#ifndef _PNGERROR_H
#define _PNGERROR_H
#ifndef PNG_ABORT
# define PNG_ABORT() abort()
#endif
#ifndef PNG_SETJMP_NOT_SUPPORTED
# define PNG_SETJMP_SUPPORTED
#endif
#ifdef PNG_SETJMP_SUPPORTED
/* New feature in version 1.1.0d. Don't undefine this; it's here just so
* applications can test for the new version. */
#define PNG_JMPBUF_SUPPORTED
/* This is an attempt to force a single setjmp behaviour on Linux. If
* the X config stuff didn't define _BSD_SOURCE we wouldn't need this.
*/
#ifdef __linux__
# ifdef _BSD_SOURCE
# define _PNG_SAVE_BSD_SOURCE
# undef _BSD_SOURCE
# endif
# ifdef _SETJMP_H
__png.h__ already includes setjmp.h
__dont__ include it again
# endif
#endif /* __linux__ */
/* include setjmp.h for error handling */
#include <setjmp.h>
#ifdef __linux__
# ifdef _PNG_SAVE_BSD_SOURCE
# define _BSD_SOURCE
# undef _PNG_SAVE_BSD_SOURCE
# endif
#endif /* __linux__ */
typedef struct png_jmpbuf_struct
{
jmp_buf env;
struct png_jmpbuf_struct FAR * link;
} png_jmpbuf;
typedef png_jmpbuf FAR * png_jmpbufp;
typedef png_jmpbuf FAR * FAR * png_jmpbufpp;
#define png_jmpbuf(png_ptr) png_get_jmpbuf(png_ptr)->env
extern PNG_EXPORT(png_jmpbufp,png_get_jmpbuf)
PNGARG((png_structp));
#define png_setjmp(png_ptr) setjmp(png_get_jmpbuf(png_ptr)->env)
#define png_longjmp(png_ptr,val) longjmp(png_get_jmpbuf(png_ptr)->env,val)
#else
# define png_jmpbuf(png_ptr) \
(LIBPNG_WAS_COMPILED_WITH__PNG_SETJMP_NOT_SUPPORTED)
#endif /* PNG_SETJMP_SUPPORTED */
#endif /* _PNGERROR_H */

35
pnggccrd.c
View File

@@ -6,10 +6,10 @@
* and http://www.intel.com/drg/pentiumII/appnotes/923/923.htm
* for Intel's performance analysis of the MMX vs. non-MMX code.
*
* libpng 1.0.6i - May 1, 2000
* libpng 1.0.7rc2 - June 28, 2000
* For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1998, Intel Corporation
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* Copyright (c) 1998, Intel Corporation
*
* Based on MSVC code contributed by Nirav Chhatrapati, Intel Corp., 1998.
* Interface to libpng contributed by Gilles Vollant, 1999.
@@ -43,8 +43,8 @@
*/
/*
* GRR NOTES
* =========
* NOTES (mostly by Greg Roelofs)
* =====
*
* 19991006:
* - fixed sign error in post-MMX cleanup code (16- & 32-bit cases)
@@ -125,9 +125,10 @@
* 20000319:
* - fixed a register-name typo in png_do_read_interlace(), default (MMX) case,
* pass == 4 or 5, that caused visible corruption of interlaced images
*
* - When compiling with gcc, be sure to use -fomit-frame-pointer
*/
#define PNG_INTERNAL
#include "png.h"
@@ -143,8 +144,9 @@ static const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
static const int png_pass_width[7] = {8, 4, 4, 2, 2, 1, 1};
#endif
// djgpp adds its own underscores to global variables, so define them without:
#ifdef __DJGPP__
// djgpp and Win32 add their own underscores to global variables,
// so define them without:
#if (defined __DJGPP__) || defined (WIN32)
# define _unmask unmask
# define _const4 const4
# define _const6 const6
@@ -209,7 +211,7 @@ static png_uint_32 _MMXLength;
static int _dif;
void
void /* PRIVATE */
png_read_filter_row_c(png_structp png_ptr, png_row_infop row_info,
png_bytep row, png_bytep prev_row, int filter);
@@ -230,7 +232,7 @@ png_read_filter_row_c(png_structp png_ptr, png_row_infop row_info,
/* Use this routine for the x86 platform - it uses a faster MMX routine
if the machine supports MMX. */
void
void /* PRIVATE */
png_combine_row(png_structp png_ptr, png_bytep row, int mask)
{
png_debug(1,"in png_combine_row_asm\n");
@@ -1210,7 +1212,7 @@ fflush(stderr);
* has taken place. [GRR: what other steps come before and/or after?]
*/
void
void /* PRIVATE */
png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
png_uint_32 transformations)
{
@@ -2401,7 +2403,7 @@ union uAll {
// Optimized code for PNG Average filter decoder
void
void /* PRIVATE */
png_read_filter_row_mmx_avg(png_row_infop row_info, png_bytep row,
png_bytep prev_row)
{
@@ -2901,7 +2903,7 @@ png_read_filter_row_mmx_avg(png_row_infop row_info, png_bytep row,
}
// Optimized code for PNG Paeth filter decoder
void
void /* PRIVATE */
png_read_filter_row_mmx_paeth(png_row_infop row_info, png_bytep row,
png_bytep prev_row)
{
@@ -3833,7 +3835,7 @@ png_read_filter_row_mmx_paeth(png_row_infop row_info, png_bytep row,
}
// Optimized code for PNG Sub filter decoder
void
void /* PRIVATE */
png_read_filter_row_mmx_sub(png_row_infop row_info, png_bytep row)
{
#ifdef GRR_GCC_MMX_CONVERTED
@@ -4183,7 +4185,7 @@ png_read_filter_row_mmx_sub(png_row_infop row_info, png_bytep row)
}
// Optimized code for PNG Up filter decoder
void
void /* PRIVATE */
png_read_filter_row_mmx_up(png_row_infop row_info, png_bytep row,
png_bytep prev_row)
{
@@ -4310,7 +4312,7 @@ png_read_filter_row_mmx_up(png_row_infop row_info, png_bytep row,
// Optimized png_read_filter_row routines
void
void /* PRIVATE */
png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep
row, png_bytep prev_row, int filter)
{
@@ -4500,7 +4502,8 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep
break;
default:
png_error(png_ptr, "#103 Bad adaptive filter type");
png_warning(png_ptr, "Ignoring bad adaptive filter type");
*row=0;
break;
}
}

172
pngget.c
View File

@@ -1,17 +1,17 @@
/* pngget.c - retrieval of values from info struct
*
* libpng 1.0.6i - May 1, 2000
* libpng 1.0.7rc2 - June 28, 2000
* For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
* Copyright (c) 1996, 1997 Andreas Dilger
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*/
#define PNG_INTERNAL
#include "png.h"
png_uint_32
png_uint_32 PNGAPI
png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag)
{
if (png_ptr != NULL && info_ptr != NULL)
@@ -20,7 +20,7 @@ png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag)
return(0);
}
png_uint_32
png_uint_32 PNGAPI
png_get_rowbytes(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
@@ -30,7 +30,7 @@ png_get_rowbytes(png_structp png_ptr, png_infop info_ptr)
}
#if defined(PNG_INFO_IMAGE_SUPPORTED)
png_bytepp
png_bytepp PNGAPI
png_get_rows(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
@@ -42,7 +42,7 @@ png_get_rows(png_structp png_ptr, png_infop info_ptr)
#ifdef PNG_EASY_ACCESS_SUPPORTED
/* easy access to info, added in libpng-0.99 */
png_uint_32
png_uint_32 PNGAPI
png_get_image_width(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
@@ -52,7 +52,7 @@ png_get_image_width(png_structp png_ptr, png_infop info_ptr)
return (0);
}
png_uint_32
png_uint_32 PNGAPI
png_get_image_height(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
@@ -62,7 +62,7 @@ png_get_image_height(png_structp png_ptr, png_infop info_ptr)
return (0);
}
png_byte
png_byte PNGAPI
png_get_bit_depth(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
@@ -72,7 +72,7 @@ png_get_bit_depth(png_structp png_ptr, png_infop info_ptr)
return (0);
}
png_byte
png_byte PNGAPI
png_get_color_type(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
@@ -82,7 +82,7 @@ png_get_color_type(png_structp png_ptr, png_infop info_ptr)
return (0);
}
png_byte
png_byte PNGAPI
png_get_filter_type(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
@@ -92,7 +92,7 @@ png_get_filter_type(png_structp png_ptr, png_infop info_ptr)
return (0);
}
png_byte
png_byte PNGAPI
png_get_interlace_type(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
@@ -102,7 +102,7 @@ png_get_interlace_type(png_structp png_ptr, png_infop info_ptr)
return (0);
}
png_byte
png_byte PNGAPI
png_get_compression_type(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
@@ -112,43 +112,48 @@ png_get_compression_type(png_structp png_ptr, png_infop info_ptr)
return (0);
}
png_uint_32
png_uint_32 PNGAPI
png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_pHYs_SUPPORTED)
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
if (info_ptr->valid & PNG_INFO_pHYs)
{
png_debug1(1, "in %s retrieval function\n", "png_get_x_pixels_per_meter");
if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
return (0);
else return (info_ptr->x_pixels_per_unit);
}
else
#else
return (0);
#endif
return (0);
}
png_uint_32
png_uint_32 PNGAPI
png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_pHYs_SUPPORTED)
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
if (info_ptr->valid & PNG_INFO_pHYs)
{
png_debug1(1, "in %s retrieval function\n", "png_get_y_pixels_per_meter");
png_debug1(1, "in %s retrieval function\n", "png_get_y_pixels_per_meter");
if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
return (0);
else return (info_ptr->y_pixels_per_unit);
}
else
#else
return (0);
#endif
return (0);
}
png_uint_32
png_uint_32 PNGAPI
png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_pHYs_SUPPORTED)
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
if (info_ptr->valid & PNG_INFO_pHYs)
{
png_debug1(1, "in %s retrieval function\n", "png_get_pixels_per_meter");
if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER ||
@@ -156,133 +161,144 @@ png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
return (0);
else return (info_ptr->x_pixels_per_unit);
}
else
#else
return (0);
#endif
return (0);
}
#ifdef PNG_FLOATING_POINT_SUPPORTED
float
float PNGAPI
png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_pHYs_SUPPORTED)
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
if (info_ptr->valid & PNG_INFO_pHYs)
{
png_debug1(1, "in %s retrieval function\n", "png_get_aspect_ratio");
if (info_ptr->x_pixels_per_unit == 0)
return ((float)0.0);
else
return ((float)info_ptr->y_pixels_per_unit
/(float)info_ptr->x_pixels_per_unit);
return ((float)((float)info_ptr->y_pixels_per_unit
/(float)info_ptr->x_pixels_per_unit));
}
else
#else
return (0.0);
#endif
return ((float)0.0);
return ((float)0.0);
}
#endif
png_uint_32
png_int_32 PNGAPI
png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_oFFs_SUPPORTED)
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
if (info_ptr->valid & PNG_INFO_oFFs)
{
png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns");
if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
return (0);
else return (info_ptr->x_offset);
}
else
#else
return (0);
#endif
return (0);
}
png_uint_32
png_int_32 PNGAPI
png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_oFFs_SUPPORTED)
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
if (info_ptr->valid & PNG_INFO_oFFs)
{
png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns");
if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
return (0);
else return (info_ptr->y_offset);
}
else
#else
return (0);
#endif
return (0);
}
png_uint_32
png_int_32 PNGAPI
png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_oFFs_SUPPORTED)
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
if (info_ptr->valid & PNG_INFO_oFFs)
{
png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns");
if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
return (0);
else return (info_ptr->x_offset);
}
else
#else
return (0);
#endif
return (0);
}
png_uint_32
png_int_32 PNGAPI
png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_oFFs_SUPPORTED)
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))
if (info_ptr->valid & PNG_INFO_oFFs)
{
png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns");
if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
return (0);
else return (info_ptr->y_offset);
}
else
#else
return (0);
#endif
return (0);
}
#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED)
png_uint_32
png_uint_32 PNGAPI
png_get_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
{
return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr)
*.0254 +.5);
*.0254 +.5));
}
png_uint_32
png_uint_32 PNGAPI
png_get_x_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
{
return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr)
*.0254 +.5);
*.0254 +.5));
}
png_uint_32
png_uint_32 PNGAPI
png_get_y_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)
{
return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr)
*.0254 +.5);
*.0254 +.5));
}
float
float PNGAPI
png_get_x_offset_inches(png_structp png_ptr, png_infop info_ptr)
{
return ((float)png_get_x_offset_microns(png_ptr, info_ptr)
*.00003937);
}
float
float PNGAPI
png_get_y_offset_inches(png_structp png_ptr, png_infop info_ptr)
{
return ((float)png_get_y_offset_microns(png_ptr, info_ptr)
*.00003937)
*.00003937);
}
#if defined(PNG_READ_pHYs_SUPPORTED)
png_uint_32
png_uint_32 PNGAPI
png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr,
png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
{
@@ -305,7 +321,7 @@ png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr,
{
*unit_type = (int)info_ptr->phys_unit_type;
retval |= PNG_INFO_pHYs;
if(unit_type == 1)
if(*unit_type == 1)
{
if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);
if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);
@@ -321,7 +337,7 @@ png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr,
#endif /* PNG_EASY_ACCESS_SUPPORTED */
png_byte
png_byte PNGAPI
png_get_channels(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
@@ -330,7 +346,7 @@ png_get_channels(png_structp png_ptr, png_infop info_ptr)
return (0);
}
png_bytep
png_bytep PNGAPI
png_get_signature(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr != NULL && info_ptr != NULL)
@@ -340,7 +356,7 @@ png_get_signature(png_structp png_ptr, png_infop info_ptr)
}
#if defined(PNG_READ_bKGD_SUPPORTED)
png_uint_32
png_uint_32 PNGAPI
png_get_bKGD(png_structp png_ptr, png_infop info_ptr,
png_color_16p *background)
{
@@ -357,7 +373,7 @@ png_get_bKGD(png_structp png_ptr, png_infop info_ptr,
#if defined(PNG_READ_cHRM_SUPPORTED)
#ifdef PNG_FLOATING_POINT_SUPPORTED
png_uint_32
png_uint_32 PNGAPI
png_get_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)
@@ -387,7 +403,7 @@ png_get_cHRM(png_structp png_ptr, png_infop info_ptr,
}
#endif
#ifdef PNG_FIXED_POINT_SUPPORTED
png_uint_32
png_uint_32 PNGAPI
png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x,
png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y,
@@ -421,7 +437,7 @@ png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
#if defined(PNG_READ_gAMA_SUPPORTED)
#ifdef PNG_FLOATING_POINT_SUPPORTED
png_uint_32
png_uint_32 PNGAPI
png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)
{
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
@@ -435,7 +451,7 @@ png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)
}
#endif
#ifdef PNG_FIXED_POINT_SUPPORTED
png_uint_32
png_uint_32 PNGAPI
png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr,
png_fixed_point *int_file_gamma)
{
@@ -452,7 +468,7 @@ png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr,
#endif
#if defined(PNG_READ_sRGB_SUPPORTED)
png_uint_32
png_uint_32 PNGAPI
png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent)
{
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)
@@ -467,7 +483,7 @@ png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent)
#endif
#if defined(PNG_READ_iCCP_SUPPORTED)
png_uint_32
png_uint_32 PNGAPI
png_get_iCCP(png_structp png_ptr, png_infop info_ptr,
png_charpp name, int *compression_type,
png_charpp profile, png_uint_32 *proflen)
@@ -489,7 +505,7 @@ png_get_iCCP(png_structp png_ptr, png_infop info_ptr,
#endif
#if defined(PNG_READ_sPLT_SUPPORTED)
png_uint_32
png_uint_32 PNGAPI
png_get_sPLT(png_structp png_ptr, png_infop info_ptr,
png_sPLT_tpp spalettes)
{
@@ -500,7 +516,7 @@ png_get_sPLT(png_structp png_ptr, png_infop info_ptr,
#endif
#if defined(PNG_READ_hIST_SUPPORTED)
png_uint_32
png_uint_32 PNGAPI
png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist)
{
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)
@@ -514,7 +530,7 @@ png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist)
}
#endif
png_uint_32
png_uint_32 PNGAPI
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,
@@ -561,7 +577,7 @@ png_get_IHDR(png_structp png_ptr, png_infop info_ptr,
}
#if defined(PNG_READ_oFFs_SUPPORTED)
png_uint_32
png_uint_32 PNGAPI
png_get_oFFs(png_structp png_ptr, png_infop info_ptr,
png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)
{
@@ -579,7 +595,7 @@ png_get_oFFs(png_structp png_ptr, png_infop info_ptr,
#endif
#if defined(PNG_READ_pCAL_SUPPORTED)
png_uint_32
png_uint_32 PNGAPI
png_get_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)
@@ -604,7 +620,7 @@ png_get_pCAL(png_structp png_ptr, png_infop info_ptr,
#if defined(PNG_READ_sCAL_SUPPORTED) || defined(PNG_WRITE_sCAL_SUPPORTED)
#ifdef PNG_FLOATING_POINT_SUPPORTED
png_uint_32
png_uint_32 PNGAPI
png_get_sCAL(png_structp png_ptr, png_infop info_ptr,
int *unit, double *width, double *height)
{
@@ -620,7 +636,7 @@ png_get_sCAL(png_structp png_ptr, png_infop info_ptr,
}
#else
#ifdef PNG_FIXED_POINT_SUPPORTED
png_uint_32
png_uint_32 PNGAPI
png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr,
int *unit, png_charpp width, png_charpp height)
{
@@ -639,7 +655,7 @@ png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr,
#endif
#if defined(PNG_READ_pHYs_SUPPORTED)
png_uint_32
png_uint_32 PNGAPI
png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
{
@@ -669,7 +685,7 @@ png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
}
#endif
png_uint_32
png_uint_32 PNGAPI
png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette,
int *num_palette)
{
@@ -686,7 +702,7 @@ png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette,
}
#if defined(PNG_READ_sBIT_SUPPORTED)
png_uint_32
png_uint_32 PNGAPI
png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit)
{
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)
@@ -701,7 +717,7 @@ png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit)
#endif
#if defined(PNG_READ_TEXT_SUPPORTED)
png_uint_32
png_uint_32 PNGAPI
png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,
int *num_text)
{
@@ -723,7 +739,7 @@ png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,
#endif
#if defined(PNG_READ_tIME_SUPPORTED)
png_uint_32
png_uint_32 PNGAPI
png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time)
{
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)
@@ -738,7 +754,7 @@ png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time)
#endif
#if defined(PNG_READ_tRNS_SUPPORTED)
png_uint_32
png_uint_32 PNGAPI
png_get_tRNS(png_structp png_ptr, png_infop info_ptr,
png_bytep *trans, int *num_trans, png_color_16p *trans_values)
{
@@ -777,7 +793,7 @@ png_get_tRNS(png_structp png_ptr, png_infop info_ptr,
#endif
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
png_uint_32
png_uint_32 PNGAPI
png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr,
png_unknown_chunkpp unknowns)
{
@@ -788,7 +804,7 @@ png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr,
#endif
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
png_byte
png_byte PNGAPI
png_get_rgb_to_gray_status (png_structp png_ptr)
{
return png_ptr->rgb_to_gray_status;
@@ -796,7 +812,7 @@ png_get_rgb_to_gray_status (png_structp png_ptr)
#endif
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
png_voidp
png_voidp PNGAPI
png_get_user_chunk_ptr(png_structp png_ptr)
{
return (png_ptr->user_chunk_ptr);
@@ -804,7 +820,7 @@ png_get_user_chunk_ptr(png_structp png_ptr)
#endif
png_uint_32
png_uint_32 PNGAPI
png_get_compression_buffer_size(png_structp png_ptr)
{
return(png_ptr->zbuf_size);

46
pngmem.c
View File

@@ -1,11 +1,11 @@
/* pngmem.c - stub functions for memory allocation
*
* libpng 1.0.6i - May 1, 2000
* libpng 1.0.7rc2 - June 28, 2000
* For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
* Copyright (c) 1996, 1997 Andreas Dilger
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*
* This file provides a location for all memory allocation. Users who
* need special memory handling are expected to supply replacement
@@ -23,7 +23,7 @@
/* Allocate memory for a png_struct. The malloc and memset can be replaced
by a single call to calloc() if this is thought to improve performance. */
png_voidp
png_voidp /* PRIVATE */
png_create_struct(int type)
{
#ifdef PNG_USER_MEM_SUPPORTED
@@ -31,7 +31,7 @@ png_create_struct(int type)
}
/* Alternate version of png_create_struct, for use with user-defined malloc. */
png_voidp
png_voidp /* PRIVATE */
png_create_struct_2(int type, png_malloc_ptr malloc_fn)
{
#endif /* PNG_USER_MEM_SUPPORTED */
@@ -62,7 +62,7 @@ png_create_struct_2(int type, png_malloc_ptr malloc_fn)
/* Free memory allocated by a png_create_struct() call */
void
void /* PRIVATE */
png_destroy_struct(png_voidp struct_ptr)
{
#ifdef PNG_USER_MEM_SUPPORTED
@@ -70,7 +70,7 @@ png_destroy_struct(png_voidp struct_ptr)
}
/* Free memory allocated by a png_create_struct() call */
void
void /* PRIVATE */
png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn)
{
#endif
@@ -108,7 +108,7 @@ png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn)
* result, we would be truncating potentially larger memory requests
* (which should cause a fatal error) and introducing major problems.
*/
png_voidp
png_voidp PNGAPI
png_malloc(png_structp png_ptr, png_uint_32 size)
{
#ifndef PNG_USER_MEM_SUPPORTED
@@ -124,7 +124,7 @@ png_malloc(png_structp png_ptr, png_uint_32 size)
return png_malloc_default(png_ptr, size);
}
png_voidp
png_voidp PNGAPI
png_malloc_default(png_structp png_ptr, png_uint_32 size)
{
png_voidp ret;
@@ -224,7 +224,7 @@ png_malloc_default(png_structp png_ptr, png_uint_32 size)
/* free a pointer allocated by png_malloc(). In the default
configuration, png_ptr is not used, but is passed in case it
is needed. If ptr is NULL, return without taking any action. */
void
void PNGAPI
png_free(png_structp png_ptr, png_voidp ptr)
{
if (png_ptr == NULL || ptr == NULL)
@@ -239,7 +239,7 @@ png_free(png_structp png_ptr, png_voidp ptr)
else png_free_default(png_ptr, ptr);
}
void
void PNGAPI
png_free_default(png_structp png_ptr, png_voidp ptr)
{
#endif /* PNG_USER_MEM_SUPPORTED */
@@ -277,7 +277,7 @@ png_free_default(png_structp png_ptr, png_voidp ptr)
/* Allocate memory for a png_struct or a png_info. The malloc and
memset can be replaced by a single call to calloc() if this is thought
to improve performance noticably.*/
png_voidp
png_voidp /* PRIVATE */
png_create_struct(int type)
{
#ifdef PNG_USER_MEM_SUPPORTED
@@ -287,7 +287,7 @@ png_create_struct(int type)
/* Allocate memory for a png_struct or a png_info. The malloc and
memset can be replaced by a single call to calloc() if this is thought
to improve performance noticably.*/
png_voidp
png_voidp /* PRIVATE */
png_create_struct_2(int type, png_malloc_ptr malloc_fn)
{
#endif /* PNG_USER_MEM_SUPPORTED */
@@ -328,7 +328,7 @@ png_create_struct_2(int type, png_malloc_ptr malloc_fn)
/* Free memory allocated by a png_create_struct() call */
void
void /* PRIVATE */
png_destroy_struct(png_voidp struct_ptr)
{
#ifdef PNG_USER_MEM_SUPPORTED
@@ -336,7 +336,7 @@ png_destroy_struct(png_voidp struct_ptr)
}
/* Free memory allocated by a png_create_struct() call */
void
void /* PRIVATE */
png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn)
{
#endif /* PNG_USER_MEM_SUPPORTED */
@@ -370,7 +370,7 @@ png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn)
need to allocate exactly 64K, so whatever you call here must
have the ability to do that. */
png_voidp
png_voidp PNGAPI
png_malloc(png_structp png_ptr, png_uint_32 size)
{
#ifndef PNG_USER_MEM_SUPPORTED
@@ -385,7 +385,7 @@ png_malloc(png_structp png_ptr, png_uint_32 size)
else
return (png_malloc_default(png_ptr, size));
}
png_voidp
png_voidp /* PRIVATE */
png_malloc_default(png_structp png_ptr, png_uint_32 size)
{
png_voidp ret;
@@ -416,7 +416,7 @@ png_malloc_default(png_structp png_ptr, png_uint_32 size)
/* Free a pointer allocated by png_malloc(). If ptr is NULL, return
without taking any action. */
void
void PNGAPI
png_free(png_structp png_ptr, png_voidp ptr)
{
if (png_ptr == NULL || ptr == NULL)
@@ -430,7 +430,7 @@ png_free(png_structp png_ptr, png_voidp ptr)
}
else png_free_default(png_ptr, ptr);
}
void
void /* PRIVATE */
png_free_default(png_structp png_ptr, png_voidp ptr)
{
if (png_ptr == NULL || ptr == NULL)
@@ -451,7 +451,7 @@ png_free_default(png_structp png_ptr, png_voidp ptr)
#endif /* Not Borland DOS special memory handler */
png_voidp
png_voidp /* PRIVATE */
png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2,
png_uint_32 length)
{
@@ -464,7 +464,7 @@ png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2,
return(png_memcpy (s1, s2, size));
}
png_voidp
png_voidp /* PRIVATE */
png_memset_check (png_structp png_ptr, png_voidp s1, int value,
png_uint_32 length)
{
@@ -482,7 +482,7 @@ png_memset_check (png_structp png_ptr, png_voidp s1, int value,
/* This function is called when the application wants to use another method
* of allocating and freeing memory.
*/
void
void PNGAPI
png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
malloc_fn, png_free_ptr free_fn)
{
@@ -495,7 +495,7 @@ png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
* functions. The application should free any memory associated with this
* pointer before png_write_destroy and png_read_destroy are called.
*/
png_voidp
png_voidp PNGAPI
png_get_mem_ptr(png_structp png_ptr)
{
return ((png_voidp)png_ptr->mem_ptr);

93
pngpread.c
View File

@@ -1,11 +1,11 @@
/* pngpread.c - read a png file in push mode
*
* libpng 1.0.6i - May 1, 2000
* libpng 1.0.7rc2 - June 28, 2000
* For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
* Copyright (c) 1996, 1997 Andreas Dilger
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*/
#define PNG_INTERNAL
@@ -24,7 +24,7 @@
#define PNG_READ_iTXt_MODE 7
#define PNG_ERROR_MODE 8
void
void PNGAPI
png_process_data(png_structp png_ptr, png_infop info_ptr,
png_bytep buffer, png_size_t buffer_size)
{
@@ -39,7 +39,7 @@ png_process_data(png_structp png_ptr, png_infop info_ptr,
/* What we do with the incoming data depends on what we were previously
* doing before we ran out of data...
*/
void
void /* PRIVATE */
png_process_some_data(png_structp png_ptr, png_infop info_ptr)
{
switch (png_ptr->process_mode)
@@ -99,7 +99,7 @@ png_process_some_data(png_structp png_ptr, png_infop info_ptr)
* checked by the calling application, or because of multiple calls to this
* routine.
*/
void
void /* PRIVATE */
png_push_read_sig(png_structp png_ptr, png_infop info_ptr)
{
png_size_t num_checked = png_ptr->sig_bytes,
@@ -131,7 +131,7 @@ png_push_read_sig(png_structp png_ptr, png_infop info_ptr)
}
}
void
void /* PRIVATE */
png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -463,14 +463,14 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
}
void
void /* PRIVATE */
png_push_crc_skip(png_structp png_ptr, png_uint_32 skip)
{
png_ptr->process_mode = PNG_SKIP_MODE;
png_ptr->skip_length = skip;
}
void
void /* PRIVATE */
png_push_crc_finish(png_structp png_ptr)
{
if (png_ptr->skip_length && png_ptr->save_buffer_size)
@@ -518,7 +518,7 @@ png_push_crc_finish(png_structp png_ptr)
}
}
void
void /* PRIVATE */
png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
{
png_bytep ptr;
@@ -556,7 +556,7 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
}
}
void
void /* PRIVATE */
png_push_save_buffer(png_structp png_ptr)
{
if (png_ptr->save_buffer_size)
@@ -600,7 +600,7 @@ png_push_save_buffer(png_structp png_ptr)
png_ptr->buffer_size = 0;
}
void
void /* PRIVATE */
png_push_restore_buffer(png_structp png_ptr, png_bytep buffer,
png_size_t buffer_length)
{
@@ -610,7 +610,7 @@ png_push_restore_buffer(png_structp png_ptr, png_bytep buffer,
png_ptr->current_buffer_ptr = png_ptr->current_buffer;
}
void
void /* PRIVATE */
png_push_read_IDAT(png_structp png_ptr)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -700,7 +700,7 @@ png_push_read_IDAT(png_structp png_ptr)
}
}
void
void /* PRIVATE */
png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
png_size_t buffer_length)
{
@@ -714,23 +714,26 @@ png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
for(;;)
{
ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
if (ret == Z_STREAM_END)
if (ret != Z_OK)
{
if (png_ptr->zstream.avail_in)
png_error(png_ptr, "Extra compressed data");
if (!(png_ptr->zstream.avail_out))
if (ret == Z_STREAM_END)
{
png_push_process_row(png_ptr);
}
if (png_ptr->zstream.avail_in)
png_error(png_ptr, "Extra compressed data");
if (!(png_ptr->zstream.avail_out))
{
png_push_process_row(png_ptr);
}
png_ptr->mode |= PNG_AFTER_IDAT;
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
break;
png_ptr->mode |= PNG_AFTER_IDAT;
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
break;
}
else if (ret == Z_BUF_ERROR)
break;
else
png_error(png_ptr, "Decompression Error");
}
else if (ret == Z_BUF_ERROR)
break;
else if (ret != Z_OK)
png_error(png_ptr, "Decompression Error");
if (!(png_ptr->zstream.avail_out))
{
png_push_process_row(png_ptr);
@@ -742,7 +745,7 @@ png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
}
}
void
void /* PRIVATE */
png_push_process_row(png_structp png_ptr)
{
png_ptr->row_info.color_type = png_ptr->color_type;
@@ -884,7 +887,7 @@ png_push_process_row(png_structp png_ptr)
}
}
void
void /* PRIVATE */
png_read_push_finish_row(png_structp png_ptr)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -949,7 +952,7 @@ png_read_push_finish_row(png_structp png_ptr)
}
#if defined(PNG_READ_tEXt_SUPPORTED)
void
void /* PRIVATE */
png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
@@ -979,7 +982,7 @@ png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length
png_ptr->process_mode = PNG_READ_tEXt_MODE;
}
void
void /* PRIVATE */
png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr->buffer_size && png_ptr->current_text_left)
@@ -1024,9 +1027,11 @@ png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text));
text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;
text_ptr->lang = (char *)NULL;
text_ptr->key = key;
#ifdef PNG_iTXt_SUPPORTED
text_ptr->lang = (char *)NULL;
text_ptr->lang_key = (char *)NULL;
#endif
text_ptr->text = text;
png_set_text(png_ptr, info_ptr, text_ptr, 1);
@@ -1037,7 +1042,7 @@ png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
#endif
#if defined(PNG_READ_zTXt_SUPPORTED)
void
void /* PRIVATE */
png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
@@ -1069,7 +1074,7 @@ png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length
png_ptr->process_mode = PNG_READ_zTXt_MODE;
}
void
void /* PRIVATE */
png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr->buffer_size && png_ptr->current_text_left)
@@ -1206,8 +1211,10 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text));
text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt;
text_ptr->key = key;
#ifdef PNG_iTXt_SUPPORTED
text_ptr->lang = (char *)NULL;
text_ptr->lang_key = (char *)NULL;
#endif
text_ptr->text = text;
png_set_text(png_ptr, info_ptr, text_ptr, 1);
@@ -1218,7 +1225,7 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
#endif
#if defined(PNG_READ_iTXt_SUPPORTED)
void
void /* PRIVATE */
png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
@@ -1248,7 +1255,7 @@ png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length
png_ptr->process_mode = PNG_READ_iTXt_MODE;
}
void
void /* PRIVATE */
png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
{
@@ -1328,7 +1335,7 @@ png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
* chunk. If there isn't a problem with the chunk itself (ie a bad chunk
* name or a critical chunk), the chunk is (currently) silently ignored.
*/
void
void /* PRIVATE */
png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_uint_32 skip=0;
@@ -1393,21 +1400,21 @@ png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 len
png_push_crc_skip(png_ptr, skip);
}
void
void /* PRIVATE */
png_push_have_info(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr->info_fn != NULL)
(*(png_ptr->info_fn))(png_ptr, info_ptr);
}
void
void /* PRIVATE */
png_push_have_end(png_structp png_ptr, png_infop info_ptr)
{
if (png_ptr->end_fn != NULL)
(*(png_ptr->end_fn))(png_ptr, info_ptr);
}
void
void /* PRIVATE */
png_push_have_row(png_structp png_ptr, png_bytep row)
{
if (png_ptr->row_fn != NULL)
@@ -1415,7 +1422,7 @@ png_push_have_row(png_structp png_ptr, png_bytep row)
(int)png_ptr->pass);
}
void
void PNGAPI
png_progressive_combine_row (png_structp png_ptr,
png_bytep old_row, png_bytep new_row)
{
@@ -1426,7 +1433,7 @@ png_progressive_combine_row (png_structp png_ptr,
png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]);
}
void
void PNGAPI
png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr,
png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,
png_progressive_end_ptr end_fn)
@@ -1438,7 +1445,7 @@ png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr,
png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer);
}
png_voidp
png_voidp PNGAPI
png_get_progressive_ptr(png_structp png_ptr)
{
return png_ptr->io_ptr;

137
pngread.c
View File

@@ -1,11 +1,11 @@
/* pngread.c - read a PNG file
*
* libpng 1.0.6i - May 1, 2000
* libpng 1.0.7rc2 - June 28, 2000
* For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
* Copyright (c) 1996, 1997 Andreas Dilger
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*
* This file contains routines that an application calls directly to
* read a PNG file or stream.
@@ -15,7 +15,7 @@
#include "png.h"
/* Create a PNG structure for reading, and allocate any memory needed. */
png_structp
png_structp PNGAPI
png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr,
png_error_ptr error_fn, png_error_ptr warn_fn)
{
@@ -26,7 +26,7 @@ png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr,
}
/* Alternate create PNG structure for reading, and allocate any memory needed. */
png_structp
png_structp PNGAPI
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)
@@ -41,6 +41,8 @@ png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
#endif
#endif
int i;
png_debug(1, "in png_create_read_struct\n");
#ifdef PNG_USER_MEM_SUPPORTED
if ((png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
@@ -74,16 +76,38 @@ png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);
/* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
* we must recompile any applications that use any older library version.
* For versions after libpng 1.0, we will be compatible, so we need
* only check the first digit.
*/
if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
(user_png_ver[0] == '0' && user_png_ver[2] < '9'))
i=0;
do
{
png_error(png_ptr,
"Incompatible libpng version in application and library");
if(user_png_ver[i] != png_libpng_ver[i])
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
} while (png_libpng_ver[i++]);
if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
{
/* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
* we must recompile any applications that use any older library version.
* For versions after libpng 1.0, we will be compatible, so we need
* only check the first digit.
*/
if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
(user_png_ver[0] == '0' && user_png_ver[2] < '9'))
{
png_error(png_ptr,
"Incompatible libpng version in application and library");
}
/* Libpng 1.0.6 was not binary compatible, due to insertion of the
info_ptr->free_me member. Note to maintainer: this test can be
removed from version 2.0.0 and beyond because the previous test
would have already rejected it. */
if (user_png_ver[4] == '6' && user_png_ver[2] == '0' &&
user_png_ver[0] == '1' && user_png_ver[5] == '\0')
{
png_error(png_ptr,
"Application must be recompiled; version 1.0.6 was incompatible");
}
}
/* initialize zbuf - compression buffer */
@@ -108,22 +132,52 @@ png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
png_set_read_fn(png_ptr, NULL, NULL);
png_ptr->mode |= PNG_CREATED_READ_STRUCT;
return (png_ptr);
}
/* Initialize PNG structure for reading, and allocate any memory needed.
This interface is deprecated in favour of the png_create_read_struct(),
and it will eventually disappear. */
void
#undef png_read_init
void PNGAPI
png_read_init(png_structp png_ptr)
{
/* We only come here via pre-1.0.7-compiled applications */
png_read_init_2(png_ptr, "1.0.0", 10000, 10000);
}
void PNGAPI
png_read_init_2(png_structp png_ptr, png_const_charp user_png_ver,
png_size_t png_struct_size, png_size_t png_info_size)
{
#ifdef PNG_SETJMP_SUPPORTED
jmp_buf tmp_jmp; /* to save current jump buffer */
#endif
png_debug(1, "in png_read_init\n");
int i=0;
do
{
if(user_png_ver[i] != png_libpng_ver[i])
{
#ifdef PNG_LEGACY_SUPPORTED
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
#else
png_ptr->error_fn=(png_error_ptr)NULL;
png_error(png_ptr,
"Application uses deprecated png_read_init() and must be recompiled.");
#endif
}
} while (png_libpng_ver[i++]);
if(sizeof(png_struct) > png_struct_size ||
sizeof(png_info) > png_info_size)
{
png_ptr->error_fn=(png_error_ptr)NULL;
png_error(png_ptr,
"Application and library have different sized structs. Please recompile.");
}
png_debug(1, "in png_read_init_2\n");
#ifdef PNG_SETJMP_SUPPORTED
/* save jump buffer and error functions */
@@ -138,15 +192,6 @@ png_read_init(png_structp png_ptr)
png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
#endif
#ifndef PNG_LEGACY_SUPPORTED
if(!(png_ptr->mode & PNG_CREATED_READ_STRUCT))
{
png_ptr->error_fn=NULL;
png_error(png_ptr,
"Read struct not properly created; use a legacy-supporting libpng.");
}
#endif
/* initialize zbuf - compression buffer */
png_ptr->zbuf_size = PNG_ZBUF_SIZE;
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
@@ -178,7 +223,7 @@ png_read_init(png_structp png_ptr)
* here. The application can then have access to the signature bytes we
* read if it is determined that this isn't a valid PNG file.
*/
void
void PNGAPI
png_read_info(png_structp png_ptr, png_infop info_ptr)
{
png_debug(1, "in png_read_info\n");
@@ -387,7 +432,7 @@ png_read_info(png_structp png_ptr, png_infop info_ptr)
}
/* optional call to update the users info_ptr structure */
void
void PNGAPI
png_read_update_info(png_structp png_ptr, png_infop info_ptr)
{
png_debug(1, "in png_read_update_info\n");
@@ -402,7 +447,7 @@ png_read_update_info(png_structp png_ptr, png_infop info_ptr)
* the user to obtain a gamma-corrected palette, for example.
* If the user doesn't call this, we will do it ourselves.
*/
void
void PNGAPI
png_start_read_image(png_structp png_ptr)
{
png_debug(1, "in png_start_read_image\n");
@@ -411,7 +456,7 @@ png_start_read_image(png_structp png_ptr)
png_read_start_row(png_ptr);
}
void
void PNGAPI
png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -652,10 +697,10 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
* not called png_set_interlace_handling(), the display_row buffer will
* be ignored, so pass NULL to it.
*
* [*] png_handle_alpha() does not exist yet, as of libpng version 1.0.6i.
* [*] png_handle_alpha() does not exist yet, as of libpng version 1.0.7rc2
*/
void
void PNGAPI
png_read_rows(png_structp png_ptr, png_bytepp row,
png_bytepp display_row, png_uint_32 num_rows)
{
@@ -701,9 +746,9 @@ png_read_rows(png_structp png_ptr, png_bytepp row,
* only call this function once. If you desire to have an image for
* each pass of a interlaced image, use png_read_rows() instead.
*
* [*] png_handle_alpha() does not exist yet, as of libpng version 1.0.6i.
* [*] png_handle_alpha() does not exist yet, as of libpng version 1.0.7rc2
*/
void
void PNGAPI
png_read_image(png_structp png_ptr, png_bytepp image)
{
png_uint_32 i,image_height;
@@ -741,7 +786,7 @@ png_read_image(png_structp png_ptr, png_bytepp image)
* file, will verify the end is accurate, and will read any comments
* or time information at the end of the file, if info is not NULL.
*/
void
void PNGAPI
png_read_end(png_structp png_ptr, png_infop info_ptr)
{
png_byte chunk_length[4];
@@ -923,7 +968,7 @@ png_read_end(png_structp png_ptr, png_infop info_ptr)
}
/* free all memory used by the read */
void
void PNGAPI
png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
png_infopp end_info_ptr_ptr)
{
@@ -989,7 +1034,7 @@ png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
}
/* free all memory used by the read (old method) */
void
void PNGAPI
png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr)
{
#ifdef PNG_SETJMP_SUPPORTED
@@ -1128,14 +1173,15 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr
}
void
void PNGAPI
png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)
{
png_ptr->read_row_fn = read_row_fn;
}
#if defined(PNG_INFO_IMAGE_SUPPORTED)
void png_read_png(png_structp png_ptr, png_infop info_ptr,
void PNGAPI
png_read_png(png_structp png_ptr, png_infop info_ptr,
int transforms,
voidp params)
{
@@ -1247,18 +1293,9 @@ void png_read_png(png_structp png_ptr, png_infop info_ptr,
/* -------------- image transformations end here ------------------- */
if(info_ptr->row_pointers)
{
#ifdef PNG_FREE_ME_SUPPORTED
if(info_ptr->free_me & PNG_FREE_ROWS)
{
for (row = 0; row < (int)info_ptr->height; row++)
png_free(png_ptr, info_ptr->row_pointers[row]);
png_free(png_ptr, info_ptr->row_pointers);
info_ptr->row_pointers = NULL;
}
png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
#endif
}
if(info_ptr->row_pointers == NULL)
{
info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,

14
pngrio.c
View File

@@ -1,11 +1,11 @@
/* pngrio.c - functions for data input
*
* libpng 1.0.6i - May 1, 2000
* libpng 1.0.7rc2 - June 28, 2000
* For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
* Copyright (c) 1996, 1997 Andreas Dilger
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*
* This file provides a location for all input. Users who need
* special handling are expected to write a function that has the same
@@ -23,7 +23,7 @@
with very small lengths, so you should implement some kind of simple
buffering if you are using unbuffered reads. This should never be asked
to read more then 64K on a 16 bit machine. */
void
void /* PRIVATE */
png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
{
png_debug1(4,"reading %d bytes\n", length);
@@ -39,7 +39,7 @@ png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
read_data function and use it at run time with png_set_read_fn(), rather
than changing the library. */
#ifndef USE_FAR_KEYWORD
static void
static void /* PRIVATE */
png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
{
png_size_t check;
@@ -64,7 +64,7 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
#define NEAR_BUF_SIZE 1024
#define MIN(a,b) (a <= b ? a : b)
static void
static void /* PRIVATE */
png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
{
int check;
@@ -119,7 +119,7 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
unsigned int that is the number of bytes to be read.
To exit and output any fatal error messages the new write
function should call png_error(png_ptr, "Error msg"). */
void
void PNGAPI
png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,
png_rw_ptr read_data_fn)
{

81
pngrtran.c
View File

@@ -1,11 +1,11 @@
/* pngrtran.c - transforms the data in a row for PNG readers
*
* libpng 1.0.6i - May 1, 2000
* libpng 1.0.7rc2 - June 28, 2000
* For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
* Copyright (c) 1996, 1997 Andreas Dilger
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*
* This file contains functions optionally called by an application
* in order to tell libpng how to handle data when reading a PNG.
@@ -17,7 +17,7 @@
#include "png.h"
/* Set the action on getting a CRC error for an ancillary or critical chunk. */
void
void PNGAPI
png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)
{
png_debug(1, "in png_set_crc_action\n");
@@ -72,7 +72,7 @@ png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)
#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
defined(PNG_FLOATING_POINT_SUPPORTED)
/* handle alpha and tRNS via a background color */
void
void PNGAPI
png_set_background(png_structp png_ptr,
png_color_16p background_color, int background_gamma_code,
int need_expand, double background_gamma)
@@ -105,7 +105,7 @@ png_set_background(png_structp png_ptr,
#if defined(PNG_READ_16_TO_8_SUPPORTED)
/* strip 16 bit depth files to 8 bit depth */
void
void PNGAPI
png_set_strip_16(png_structp png_ptr)
{
png_debug(1, "in png_set_strip_16\n");
@@ -114,7 +114,7 @@ png_set_strip_16(png_structp png_ptr)
#endif
#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
void
void PNGAPI
png_set_strip_alpha(png_structp png_ptr)
{
png_debug(1, "in png_set_strip_alpha\n");
@@ -141,7 +141,7 @@ typedef struct png_dsort_struct
typedef png_dsort FAR * png_dsortp;
typedef png_dsort FAR * FAR * png_dsortpp;
void
void PNGAPI
png_set_dither(png_structp png_ptr, png_colorp palette,
int num_palette, int maximum_colors, png_uint_16p histogram,
int full_dither)
@@ -511,7 +511,7 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
* are not close reciprocals, otherwise it slows things down slightly, and
* also needlessly introduces small errors.
*/
void
void PNGAPI
png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)
{
png_debug(1, "in png_set_gamma\n");
@@ -527,7 +527,7 @@ png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)
* less than 8-bit depth to 8-bit depth, and expand tRNS chunks
* to alpha channels.
*/
void
void PNGAPI
png_set_expand(png_structp png_ptr)
{
png_debug(1, "in png_set_expand\n");
@@ -549,7 +549,7 @@ png_set_expand(png_structp png_ptr)
*/
/* Expand paletted images to RGB. */
void
void PNGAPI
png_set_palette_to_rgb(png_structp png_ptr)
{
png_debug(1, "in png_set_expand\n");
@@ -557,7 +557,7 @@ png_set_palette_to_rgb(png_structp png_ptr)
}
/* Expand grayscale images of less than 8-bit depth to 8 bits. */
void
void PNGAPI
png_set_gray_1_2_4_to_8(png_structp png_ptr)
{
png_debug(1, "in png_set_expand\n");
@@ -565,7 +565,7 @@ png_set_gray_1_2_4_to_8(png_structp png_ptr)
}
/* Expand tRNS chunks to alpha channels. */
void
void PNGAPI
png_set_tRNS_to_alpha(png_structp png_ptr)
{
png_debug(1, "in png_set_expand\n");
@@ -574,7 +574,7 @@ png_set_tRNS_to_alpha(png_structp png_ptr)
#endif /* defined(PNG_READ_EXPAND_SUPPORTED) */
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
void
void PNGAPI
png_set_gray_to_rgb(png_structp png_ptr)
{
png_debug(1, "in png_set_gray_to_rgb\n");
@@ -588,7 +588,7 @@ png_set_gray_to_rgb(png_structp png_ptr)
* for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image.
*/
void
void PNGAPI
png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red,
double green)
{
@@ -598,7 +598,7 @@ png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red,
}
#endif
void
void PNGAPI
png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action,
png_fixed_point red, png_fixed_point green)
{
@@ -648,7 +648,7 @@ png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action,
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \
defined(PNG_LEGACY_SUPPORTED)
void
void PNGAPI
png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
read_user_transform_fn)
{
@@ -668,7 +668,7 @@ png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
/* Initialize everything needed for the read. This includes modifying
* the palette.
*/
void
void /* PRIVATE */
png_init_read_transformations(png_structp png_ptr)
{
png_debug(1, "in png_init_read_transformations\n");
@@ -979,13 +979,18 @@ png_init_read_transformations(png_structp png_ptr)
}
#endif
}
#if !defined(PNG_READ_GAMMA_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) \
&& !defined(PNG_READ_BACKGROUND_SUPPORTED)
if(png_ptr)
return;
#endif
}
/* Modify the info structure to reflect the transformations. The
* info should be updated so a PNG file could be written with it,
* assuming the transformations result in valid PNG data.
*/
void
void /* PRIVATE */
png_read_transform_info(png_structp png_ptr, png_infop info_ptr)
{
png_debug(1, "in png_read_transform_info\n");
@@ -1103,13 +1108,17 @@ defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
info_ptr->bit_depth);
info_ptr->rowbytes = ((info_ptr->width * info_ptr->pixel_depth + 7) >> 3);
#if !defined(PNG_READ_EXPAND_SUPPORTED)
if(png_ptr)
return;
#endif
}
/* Transform the row. The order of transformations is significant,
* and is very touchy. If you add a transformation, take care to
* decide how it fits in with the other transformations here.
*/
void
void /* PRIVATE */
png_do_read_transformations(png_structp png_ptr)
{
png_debug(1, "in png_do_read_transformations\n");
@@ -1339,7 +1348,7 @@ From Andreas Dilger e-mail to png-implement, 26 March 1998:
* the numbers 0 or 1. If you would rather they contain 0 and 255, use
* png_do_shift() after this.
*/
void
void /* PRIVATE */
png_do_unpack(png_row_infop row_info, png_bytep row)
{
png_debug(1, "in png_do_unpack\n");
@@ -1429,7 +1438,7 @@ png_do_unpack(png_row_infop row_info, png_bytep row)
* a row of bit depth 8, but only 5 are significant, this will shift
* the values back to 0 through 31.
*/
void
void /* PRIVATE */
png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)
{
png_debug(1, "in png_do_unshift\n");
@@ -1535,7 +1544,7 @@ png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)
#if defined(PNG_READ_16_TO_8_SUPPORTED)
/* chop rows of bit depth 16 down to 8 */
void
void /* PRIVATE */
png_do_chop(png_row_infop row_info, png_bytep row)
{
png_debug(1, "in png_do_chop\n");
@@ -1589,7 +1598,7 @@ png_do_chop(png_row_infop row_info, png_bytep row)
#endif
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
void
void /* PRIVATE */
png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)
{
png_debug(1, "in png_do_read_swap_alpha\n");
@@ -1681,7 +1690,7 @@ png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)
#endif
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
void
void /* PRIVATE */
png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
{
png_debug(1, "in png_do_read_invert_alpha\n");
@@ -1780,7 +1789,7 @@ png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)
#if defined(PNG_READ_FILLER_SUPPORTED)
/* Add filler channel if we have RGB color */
void
void /* PRIVATE */
png_do_read_filler(png_row_infop row_info, png_bytep row,
png_uint_32 filler, png_uint_32 flags)
{
@@ -1956,7 +1965,7 @@ png_do_read_filler(png_row_infop row_info, png_bytep row,
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)
/* expand grayscale files to RGB, with or without alpha */
void
void /* PRIVATE */
png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
{
png_uint_32 i;
@@ -2058,7 +2067,7 @@ png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
*
* Other integer coefficents can be used via png_set_rgb_to_gray().
*/
int
int /* PRIVATE */
png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row)
{
@@ -2298,7 +2307,7 @@ png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row)
* paletted. Most useful for gamma correction and simplification
* of code.
*/
void
void /* PRIVATE */
png_build_grayscale_palette(int bit_depth, png_colorp palette)
{
int num_palette;
@@ -2344,7 +2353,7 @@ png_build_grayscale_palette(int bit_depth, png_colorp palette)
/* This function is currently unused. Do we really need it? */
#if defined(PNG_READ_DITHER_SUPPORTED) && defined(PNG_CORRECT_PALETTE_SUPPORTED)
void
void /* PRIVATE */
png_correct_palette(png_structp png_ptr, png_colorp palette,
int num_palette)
{
@@ -2529,7 +2538,7 @@ png_correct_palette(png_structp png_ptr, png_colorp palette,
* "background" is already in the screen gamma, while "background_1" is
* at a gamma of 1.0. Paletted files have already been taken care of.
*/
void
void /* PRIVATE */
png_do_background(png_row_infop row_info, png_bytep row,
png_color_16p trans_values, png_color_16p background,
png_color_16p background_1,
@@ -3200,7 +3209,7 @@ png_do_background(png_row_infop row_info, png_bytep row,
* is 16, use gamma_16_table and gamma_shift. Build these with
* build_gamma_table().
*/
void
void /* PRIVATE */
png_do_gamma(png_row_infop row_info, png_bytep row,
png_bytep gamma_table, png_uint_16pp gamma_16_table,
int gamma_shift)
@@ -3382,7 +3391,7 @@ png_do_gamma(png_row_infop row_info, png_bytep row,
/* Expands a palette row to an RGB or RGBA row depending
* upon whether you supply trans and num_trans.
*/
void
void /* PRIVATE */
png_do_expand_palette(png_row_infop row_info, png_bytep row,
png_colorp palette, png_bytep trans, int num_trans)
{
@@ -3525,7 +3534,7 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row,
/* If the bit depth < 8, it is expanded to 8. Also, if the
* transparency value is supplied, an alpha channel is built.
*/
void
void /* PRIVATE */
png_do_expand(png_row_infop row_info, png_bytep row,
png_color_16p trans_value)
{
@@ -3724,7 +3733,7 @@ png_do_expand(png_row_infop row_info, png_bytep row,
#endif
#if defined(PNG_READ_DITHER_SUPPORTED)
void
void /* PRIVATE */
png_do_dither(png_row_infop row_info, png_bytep row,
png_bytep palette_lookup, png_bytep dither_lookup)
{
@@ -3826,7 +3835,7 @@ static int png_gamma_shift[] =
* the future. Note also how the gamma_16 tables are segmented so that
* we don't need to allocate > 64K chunks for a full 16-bit table.
*/
void
void /* PRIVATE */
png_build_gamma_table(png_structp png_ptr)
{
png_debug(1, "in png_build_gamma_table\n");

168
pngrutil.c
View File

@@ -1,11 +1,11 @@
/* pngrutil.c - utilities to read a PNG file
*
* libpng 1.0.6i - May 1, 2000
* libpng 1.0.7rc2 - June 28, 2000
* For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
* Copyright (c) 1996, 1997 Andreas Dilger
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*
* This file contains routines that are only called from within
* libpng itself during the course of reading an image.
@@ -16,7 +16,7 @@
#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED
/* Grab an unsigned 32-bit integer from a buffer in big-endian format. */
png_uint_32
png_uint_32 /* PRIVATE */
png_get_uint_32(png_bytep buf)
{
png_uint_32 i = ((png_uint_32)(*buf) << 24) +
@@ -31,7 +31,7 @@ png_get_uint_32(png_bytep buf)
/* Grab a signed 32-bit integer from a buffer in big-endian format. The
* data is stored in the PNG file in two's complement format, and it is
* assumed that the machine format for signed integers is the same. */
png_int_32
png_int_32 /* PRIVATE */
png_get_int_32(png_bytep buf)
{
png_int_32 i = ((png_int_32)(*buf) << 24) +
@@ -44,7 +44,7 @@ png_get_int_32(png_bytep buf)
#endif /* PNG_READ_pCAL_SUPPORTED */
/* Grab an unsigned 16-bit integer from a buffer in big-endian format. */
png_uint_16
png_uint_16 /* PRIVATE */
png_get_uint_16(png_bytep buf)
{
png_uint_16 i = (png_uint_16)(((png_uint_16)(*buf) << 8) +
@@ -55,7 +55,7 @@ png_get_uint_16(png_bytep buf)
#endif /* PNG_READ_BIG_ENDIAN_SUPPORTED */
/* Read data, and (optionally) run it through the CRC. */
void
void /* PRIVATE */
png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)
{
png_read_data(png_ptr, buf, length);
@@ -66,7 +66,7 @@ png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)
are reading a ancillary or critical chunk, and how the program has set
things up, we may calculate the CRC on the data and print a message.
Returns '1' if there was a CRC error, '0' otherwise. */
int
int /* PRIVATE */
png_crc_finish(png_structp png_ptr, png_uint_32 skip)
{
png_size_t i;
@@ -102,7 +102,7 @@ png_crc_finish(png_structp png_ptr, png_uint_32 skip)
/* Compare the CRC stored in the PNG file with that calculated by libpng from
the data it has read thus far. */
int
int /* PRIVATE */
png_crc_error(png_structp png_ptr)
{
png_byte crc_bytes[4];
@@ -141,7 +141,8 @@ png_crc_error(png_structp png_ptr)
* holding the original prefix part and an uncompressed version of the
* trailing part (the malloc area passed in is freed).
*/
png_charp png_decompress_chunk(png_structp png_ptr, int comp_type,
png_charp /* PRIVATE */
png_decompress_chunk(png_structp png_ptr, int comp_type,
png_charp chunkdata, png_size_t chunklength,
png_size_t prefix_size, png_size_t *newlength)
{
@@ -151,6 +152,7 @@ png_charp png_decompress_chunk(png_structp png_ptr, int comp_type,
if (comp_type == PNG_TEXT_COMPRESSION_zTXt)
{
int ret = Z_OK;
png_ptr->zstream.next_in = (png_bytep)(chunkdata + prefix_size);
png_ptr->zstream.avail_in = (uInt)(chunklength - prefix_size);
png_ptr->zstream.next_out = png_ptr->zbuf;
@@ -161,7 +163,7 @@ png_charp png_decompress_chunk(png_structp png_ptr, int comp_type,
while (png_ptr->zstream.avail_in)
{
int ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
if (ret != Z_OK && ret != Z_STREAM_END)
{
if (png_ptr->zstream.msg != NULL)
@@ -221,6 +223,19 @@ png_charp png_decompress_chunk(png_structp png_ptr, int comp_type,
}
}
}
if (ret != Z_STREAM_END)
{
#if !defined(PNG_NO_STDIO)
char umsg[50];
sprintf(umsg,"Incomplete compressed datastream in %s chunk",
png_ptr->chunk_name);
png_warning(png_ptr, umsg);
#else
png_warning(png_ptr,
"Incomplete compressed datastream in chunk other than IDAT");
#endif
}
inflateReset(&png_ptr->zstream);
png_ptr->zstream.avail_in = 0;
@@ -229,7 +244,7 @@ png_charp png_decompress_chunk(png_structp png_ptr, int comp_type,
chunkdata = text;
*newlength=text_size;
}
else /* if (comp_type >= PNG_TEXT_COMPRESSION_LAST) */
else /* if (comp_type != PNG_TEXT_COMPRESSION_zTXt) */
{
#if !defined(PNG_NO_STDIO)
char umsg[50];
@@ -251,7 +266,7 @@ png_charp png_decompress_chunk(png_structp png_ptr, int comp_type,
#endif
/* read and check the IDHR chunk */
void
void /* PRIVATE */
png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_byte buf[13];
@@ -348,11 +363,14 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
}
/* read and check the palette */
void
void /* PRIVATE */
png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_colorp palette;
int num, i;
#ifndef PNG_NO_POINTER_INDEXING
png_colorp pal_ptr;
#endif
png_debug(1, "in png_handle_PLTE\n");
@@ -377,7 +395,7 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
}
#endif
if (length % 3)
if (length > 768 || length % 3)
{
if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
{
@@ -395,6 +413,17 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
palette = (png_colorp)png_zalloc(png_ptr, (uInt)num, sizeof (png_color));
#ifndef PNG_NO_POINTER_INDEXING
for (i = 0, pal_ptr = palette; i < num; i++, pal_ptr++)
{
png_byte buf[3];
png_crc_read(png_ptr, buf, 3);
pal_ptr->red = buf[0];
pal_ptr->green = buf[1];
pal_ptr->blue = buf[2];
}
#else
for (i = 0; i < num; i++)
{
png_byte buf[3];
@@ -405,6 +434,7 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
palette[i].green = buf[1];
palette[i].blue = buf[2];
}
#endif
/* If we actually NEED the PLTE chunk (ie for a paletted image), we do
whatever the normal CRC configuration tells us. However, if we
@@ -475,7 +505,7 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
}
void
void /* PRIVATE */
png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_debug(1, "in png_handle_IEND\n");
@@ -499,7 +529,7 @@ png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
}
#if defined(PNG_READ_gAMA_SUPPORTED)
void
void /* PRIVATE */
png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_fixed_point igamma;
@@ -576,7 +606,7 @@ png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif
#if defined(PNG_READ_sBIT_SUPPORTED)
void
void /* PRIVATE */
png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_size_t truelen;
@@ -642,7 +672,7 @@ png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif
#if defined(PNG_READ_cHRM_SUPPORTED)
void
void /* PRIVATE */
png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_byte buf[4];
@@ -799,7 +829,7 @@ png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif
#if defined(PNG_READ_sRGB_SUPPORTED)
void
void /* PRIVATE */
png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
int intent;
@@ -907,7 +937,7 @@ png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif /* PNG_READ_sRGB_SUPPORTED */
#if defined(PNG_READ_iCCP_SUPPORTED)
void
void /* PRIVATE */
png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
/* Note: this does not properly handle chunks that are > 64K under DOS */
{
@@ -961,18 +991,19 @@ png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
for (profile = chunkdata; *profile; profile++)
/* empty loop to find end of name */ ;
++profile;
/* there should be at least one NUL (the compression type byte)
/* there should be at least one zero (the compression type byte)
following the separator, and we should be on it */
if (profile >= chunkdata + slength)
if (*profile || profile >= chunkdata + slength)
{
png_free(png_ptr, chunkdata);
png_warning(png_ptr, "malformed iCCP chunk");
return;
}
/* compression should always be zero */
/* compression_type should always be zero */
compression_type = *profile++;
prefix_length = profile - chunkdata;
@@ -986,13 +1017,16 @@ png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif /* PNG_READ_iCCP_SUPPORTED */
#if defined(PNG_READ_sPLT_SUPPORTED)
void
void /* PRIVATE */
png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
/* Note: this does not properly handle chunks that are > 64K under DOS */
{
png_bytep chunkdata;
png_bytep entry_start;
png_sPLT_t new_palette;
#ifdef PNG_NO_POINTER_INDEXING
png_sPLT_entryp pp;
#endif
int data_length, entry_size, i;
png_uint_32 skip = 0;
png_size_t slength;
@@ -1056,6 +1090,7 @@ png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
new_palette.entries = (png_sPLT_entryp)png_malloc(
png_ptr, new_palette.nentries * sizeof(png_sPLT_entry));
#ifndef PNG_NO_POINTER_INDEXING
for (i = 0; i < new_palette.nentries; i++)
{
png_sPLT_entryp pp = new_palette.entries + i;
@@ -1076,6 +1111,28 @@ png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
}
pp->frequency = png_get_uint_16(entry_start); entry_start += 2;
}
#else
pp = new_palette.entries;
for (i = 0; i < new_palette.nentries; i++)
{
if (new_palette.depth == 8)
{
pp[i].red = *entry_start++;
pp[i].green = *entry_start++;
pp[i].blue = *entry_start++;
pp[i].alpha = *entry_start++;
}
else
{
pp[i].red = png_get_uint_16(entry_start); entry_start += 2;
pp[i].green = png_get_uint_16(entry_start); entry_start += 2;
pp[i].blue = png_get_uint_16(entry_start); entry_start += 2;
pp[i].alpha = png_get_uint_16(entry_start); entry_start += 2;
}
pp->frequency = png_get_uint_16(entry_start); entry_start += 2;
}
#endif
/* discard all chunk data except the name and stash that */
new_palette.name = (png_charp)chunkdata;
@@ -1088,7 +1145,7 @@ png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif /* PNG_READ_sPLT_SUPPORTED */
#if defined(PNG_READ_tRNS_SUPPORTED)
void
void /* PRIVATE */
png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_debug(1, "in png_handle_tRNS\n");
@@ -1186,7 +1243,7 @@ png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif
#if defined(PNG_READ_bKGD_SUPPORTED)
void
void /* PRIVATE */
png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_size_t truelen;
@@ -1276,7 +1333,7 @@ png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif
#if defined(PNG_READ_hIST_SUPPORTED)
void
void /* PRIVATE */
png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
int num, i;
@@ -1336,7 +1393,7 @@ png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif
#if defined(PNG_READ_pHYs_SUPPORTED)
void
void /* PRIVATE */
png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_byte buf[9];
@@ -1346,16 +1403,16 @@ png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
png_debug(1, "in png_handle_pHYs\n");
if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_error(png_ptr, "Missing IHDR before pHYS");
png_error(png_ptr, "Missing IHDR before pHYs");
else if (png_ptr->mode & PNG_HAVE_IDAT)
{
png_warning(png_ptr, "Invalid pHYS after IDAT");
png_warning(png_ptr, "Invalid pHYs after IDAT");
png_crc_finish(png_ptr, length);
return;
}
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
{
png_warning(png_ptr, "Duplicate pHYS chunk");
png_warning(png_ptr, "Duplicate pHYs chunk");
png_crc_finish(png_ptr, length);
return;
}
@@ -1379,7 +1436,7 @@ png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif
#if defined(PNG_READ_oFFs_SUPPORTED)
void
void /* PRIVATE */
png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_byte buf[9];
@@ -1423,7 +1480,7 @@ png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#if defined(PNG_READ_pCAL_SUPPORTED)
/* read the pCAL chunk (png-scivis-19970203) */
void
void /* PRIVATE */
png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_charp purpose;
@@ -1540,7 +1597,7 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#if defined(PNG_READ_sCAL_SUPPORTED)
/* read the sCAL chunk */
void
void /* PRIVATE */
png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_charp buffer, ep;
@@ -1652,7 +1709,7 @@ png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif
#if defined(PNG_READ_tIME_SUPPORTED)
void
void /* PRIVATE */
png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_byte buf[7];
@@ -1696,7 +1753,7 @@ png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#if defined(PNG_READ_tEXt_SUPPORTED)
/* Note: this does not properly handle chunks that are > 64K under DOS */
void
void /* PRIVATE */
png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_textp text_ptr;
@@ -1743,11 +1800,13 @@ png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text));
text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;
text_ptr->key = key;
#ifdef PNG_iTXt_SUPPORTED
text_ptr->lang = NULL;
text_ptr->lang_key = NULL;
text_ptr->itxt_length = 0;
#endif
text_ptr->text = text;
text_ptr->text_length = png_strlen(text);
text_ptr->itxt_length = 0;
png_set_text(png_ptr, info_ptr, text_ptr, 1);
@@ -1758,7 +1817,7 @@ png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#if defined(PNG_READ_zTXt_SUPPORTED)
/* note: this does not correctly handle chunks that are > 64K under DOS */
void
void /* PRIVATE */
png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_textp text_ptr;
@@ -1817,12 +1876,14 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text));
text_ptr->compression = comp_type;
text_ptr->lang = NULL;
text_ptr->key = chunkdata;
#ifdef PNG_iTXt_SUPPORTED
text_ptr->lang = NULL;
text_ptr->lang_key = NULL;
text_ptr->itxt_length = 0;
#endif
text_ptr->text = chunkdata + prefix_len;
text_ptr->text_length = data_len;
text_ptr->itxt_length = 0;
png_set_text(png_ptr, info_ptr, text_ptr, 1);
@@ -1833,7 +1894,7 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#if defined(PNG_READ_iTXt_SUPPORTED)
/* note: this does not correctly handle chunks that are > 64K under DOS */
void
void /* PRIVATE */
png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_textp text_ptr;
@@ -1912,10 +1973,10 @@ png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
text_ptr->compression = (int)comp_flag + 1;
text_ptr->lang_key = chunkdata+(lang_key-key);
text_ptr->lang = chunkdata+(lang-key);
text_ptr->itxt_length = data_len;
text_ptr->text_length = 0;
text_ptr->key = chunkdata;
text_ptr->text = chunkdata + prefix_len;
text_ptr->text_length = 0;
text_ptr->itxt_length = data_len;
png_set_text(png_ptr, info_ptr, text_ptr, 1);
@@ -1929,7 +1990,7 @@ png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
chunk name, CRC, or a critical chunk), the chunk is silently ignored
-- unless the PNG_FLAG_UNKNOWN_CHUNKS_SUPPORTED flag is on in which
case it will be saved away to be written out later. */
void
void /* PRIVATE */
png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_uint_32 skip = 0;
@@ -2015,7 +2076,7 @@ png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#define isnonalpha(c) ((c) < 41 || (c) > 122 || ((c) > 90 && (c) < 97))
void
void /* PRIVATE */
png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name)
{
png_debug(1, "in png_check_chunk_name\n");
@@ -2036,7 +2097,7 @@ png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name)
a zero indicates the pixel is to be skipped. This is in addition
to any alpha or transparency value associated with the pixel. If
you want all pixels to be combined, pass 0xff (255) in mask. */
void
void /* PRIVATE */
#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW
png_combine_row_c
#else
@@ -2244,7 +2305,7 @@ png_combine_row
}
#if defined(PNG_READ_INTERLACING_SUPPORTED)
void
void /* PRIVATE */
#ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE
png_do_read_interlace_c
#else
@@ -2464,10 +2525,15 @@ png_do_read_interlace
row_info->rowbytes = ((final_width *
(png_uint_32)row_info->pixel_depth + 7) >> 3);
}
#if !defined(PNG_READ_PACKSWAP_SUPPORTED)
/* silence compiler warning */
if (transformations)
return;
#endif
}
#endif
void
void /* PRIVATE */
#ifdef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW
png_read_filter_row_c
#else
@@ -2595,7 +2661,7 @@ png_read_filter_row
}
}
void
void /* PRIVATE */
png_read_finish_row(png_structp png_ptr)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -2717,7 +2783,7 @@ png_read_finish_row(png_structp png_ptr)
png_ptr->mode |= PNG_AFTER_IDAT;
}
void
void /* PRIVATE */
png_read_start_row(png_structp png_ptr)
{
#ifdef PNG_USE_LOCAL_ARRAYS

124
pngset.c
View File

@@ -1,11 +1,11 @@
/* pngset.c - storage of image information into info struct
*
* libpng 1.0.6i - May 1, 2000
* libpng 1.0.7rc2 - June 28, 2000
* For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
* Copyright (c) 1996, 1997 Andreas Dilger
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*
* The functions here are used during reads to store data from the file
* into the info struct, and during writes to store application data
@@ -17,7 +17,7 @@
#include "png.h"
#if defined(PNG_bKGD_SUPPORTED)
void
void PNGAPI
png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background)
{
png_debug1(1, "in %s storage function\n", "bKGD");
@@ -31,7 +31,7 @@ png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background)
#if defined(PNG_cHRM_SUPPORTED)
#ifdef PNG_FLOATING_POINT_SUPPORTED
void
void PNGAPI
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)
@@ -62,7 +62,7 @@ png_set_cHRM(png_structp png_ptr, png_infop info_ptr,
}
#endif
#ifdef PNG_FIXED_POINT_SUPPORTED
void
void PNGAPI
png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,
png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,
@@ -97,7 +97,7 @@ png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
#if defined(PNG_gAMA_SUPPORTED)
#ifdef PNG_FLOATING_POINT_SUPPORTED
void
void PNGAPI
png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)
{
png_debug1(1, "in %s storage function\n", "gAMA");
@@ -112,7 +112,7 @@ png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)
}
#endif
#endif
void
void PNGAPI
png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point
int_gamma)
{
@@ -130,7 +130,7 @@ png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point
}
#if defined(PNG_hIST_SUPPORTED)
void
void PNGAPI
png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)
{
png_debug1(1, "in %s storage function\n", "hIST");
@@ -142,7 +142,7 @@ png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)
}
#endif
void
void PNGAPI
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 interlace_type, int compression_type,
@@ -183,7 +183,7 @@ png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
}
#if defined(PNG_oFFs_SUPPORTED)
void
void PNGAPI
png_set_oFFs(png_structp png_ptr, png_infop info_ptr,
png_int_32 offset_x, png_int_32 offset_y, int unit_type)
{
@@ -199,7 +199,7 @@ png_set_oFFs(png_structp png_ptr, png_infop info_ptr,
#endif
#if defined(PNG_pCAL_SUPPORTED)
void
void PNGAPI
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)
@@ -240,12 +240,15 @@ png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
}
info_ptr->valid |= PNG_INFO_pCAL;
#ifdef PNG_FREE_ME_SUPPORTED
info_ptr->free_me |= PNG_FREE_PCAL;
#endif
}
#endif
#if defined(PNG_READ_sCAL_SUPPORTED) || defined(PNG_WRITE_sCAL_SUPPORTED)
#ifdef PNG_FLOATING_POINT_SUPPORTED
void
void PNGAPI
png_set_sCAL(png_structp png_ptr, png_infop info_ptr,
int unit, double width, double height)
{
@@ -261,7 +264,7 @@ png_set_sCAL(png_structp png_ptr, png_infop info_ptr,
}
#else
#ifdef PNG_FIXED_POINT_SUPPORTED
void
void PNGAPI
png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,
int unit, png_charp swidth, png_charp sheight)
{
@@ -284,13 +287,16 @@ png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,
png_memcpy(info_ptr->scal_s_height, sheight, (png_size_t)length);
info_ptr->valid |= PNG_INFO_sCAL;
#ifdef PNG_FREE_ME_SUPPORTED
info_ptr->free_me |= PNG_FREE_SCAL;
#endif
}
#endif
#endif
#endif
#if defined(PNG_pHYs_SUPPORTED)
void
void PNGAPI
png_set_pHYs(png_structp png_ptr, png_infop info_ptr,
png_uint_32 res_x, png_uint_32 res_y, int unit_type)
{
@@ -305,7 +311,7 @@ png_set_pHYs(png_structp png_ptr, png_infop info_ptr,
}
#endif
void
void PNGAPI
png_set_PLTE(png_structp png_ptr, png_infop info_ptr,
png_colorp palette, int num_palette)
{
@@ -321,7 +327,7 @@ png_set_PLTE(png_structp png_ptr, png_infop info_ptr,
}
#if defined(PNG_sBIT_SUPPORTED)
void
void PNGAPI
png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
png_color_8p sig_bit)
{
@@ -335,7 +341,7 @@ png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
#endif
#if defined(PNG_sRGB_SUPPORTED)
void
void PNGAPI
png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent)
{
png_debug1(1, "in %s storage function\n", "sRGB");
@@ -346,7 +352,7 @@ png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent)
info_ptr->valid |= PNG_INFO_sRGB;
}
void
void PNGAPI
png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
int intent)
{
@@ -418,7 +424,7 @@ png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
#if defined(PNG_iCCP_SUPPORTED)
void
void PNGAPI
png_set_iCCP(png_structp png_ptr, png_infop info_ptr,
png_charp name, int compression_type,
png_charp profile, png_uint_32 proflen)
@@ -451,7 +457,7 @@ png_set_iCCP(png_structp png_ptr, png_infop info_ptr,
#endif
#if defined(PNG_TEXT_SUPPORTED)
void
void PNGAPI
png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
int num_text)
{
@@ -488,14 +494,17 @@ png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
info_ptr->num_text = 0;
info_ptr->text = (png_textp)png_malloc(png_ptr,
(png_uint_32)(info_ptr->max_text * sizeof (png_text)));
#ifdef PNG_FREE_ME_SUPPORTED
info_ptr->free_me |= PNG_FREE_TEXT;
#endif
}
png_debug1(3, "allocated %d entries for info_ptr->text\n",
info_ptr->max_text);
}
for (i = 0; i < num_text; i++)
{
png_size_t text_length,key_len,lang_len,lang_key_len;
png_size_t text_length,key_len;
png_size_t lang_len,lang_key_len;
png_textp textp = &(info_ptr->text[info_ptr->num_text]);
if (text_ptr[i].key == (png_charp)NULL)
@@ -503,7 +512,13 @@ png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
key_len = png_strlen(text_ptr[i].key);
if(text_ptr[i].compression > 0)
if(text_ptr[i].compression <= 0)
{
lang_len = 0;
lang_key_len = 0;
}
else
#ifdef PNG_iTXt_SUPPORTED
{
/* set iTXt data */
if (text_ptr[i].key != (png_charp)NULL)
@@ -515,18 +530,21 @@ png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
else
lang_key_len = 0;
}
else
#else
{
lang_len = 0;
lang_key_len = 0;
png_warning(png_ptr, "iTXt chunk not supported.");
continue;
}
#endif
if (text_ptr[i].text == (png_charp)NULL || text_ptr[i].text[0] == '\0')
{
text_length = 0;
#ifdef PNG_iTXt_SUPPORTED
if(text_ptr[i].compression > 0)
textp->compression = PNG_ITXT_COMPRESSION_NONE;
else
#endif
textp->compression = PNG_TEXT_COMPRESSION_NONE;
}
else
@@ -536,13 +554,14 @@ png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
}
textp->key = (png_charp)png_malloc(png_ptr,
(png_uint_32)(key_len + lang_len + lang_key_len + text_length + 4));
(png_uint_32)(key_len + text_length + lang_len + lang_key_len + 4));
png_debug2(2, "Allocated %d bytes at %x in png_set_text\n",
key_len + lang_len + lang_key_len + text_length + 4, textp->key);
png_memcpy(textp->key, text_ptr[i].key,
(png_size_t)(key_len));
*(textp->key+key_len) = '\0';
#ifdef PNG_iTXt_SUPPORTED
if (text_ptr[i].compression > 0)
{
textp->lang=textp->key + key_len + 1;
@@ -554,40 +573,42 @@ png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
textp->text=textp->lang_key + lang_key_len + 1;
}
else
#endif
{
#ifdef PNG_iTXt_SUPPORTED
textp->lang=(png_charp)NULL;
textp->lang_key=(png_charp)NULL;
#endif
textp->text=textp->key + key_len + 1;
}
if(text_length)
png_memcpy(textp->text, text_ptr[i].text,
(png_size_t)(text_length));
*(textp->text+text_length) = '\0';
#ifdef PNG_iTXt_SUPPORTED
if(textp->compression > 0)
{
textp->text_length = 0;
textp->itxt_length = text_length;
}
else
#endif
{
textp->text_length = text_length;
#ifdef PNG_iTXt_SUPPORTED
textp->itxt_length = 0;
#endif
}
info_ptr->text[info_ptr->num_text]= *textp;
info_ptr->num_text++;
#ifdef PNG_FREE_ME_SUPPORTED
info_ptr->free_me |= PNG_FREE_TEXT;
#endif
png_debug1(3, "transferred text chunk %d\n", info_ptr->num_text);
}
}
#endif
#if defined(PNG_tIME_SUPPORTED)
void
void PNGAPI
png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time)
{
png_debug1(1, "in %s storage function\n", "tIME");
@@ -601,7 +622,7 @@ png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time)
#endif
#if defined(PNG_tRNS_SUPPORTED)
void
void PNGAPI
png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
png_bytep trans, int num_trans, png_color_16p trans_values)
{
@@ -625,7 +646,7 @@ png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
#endif
#if defined(PNG_sPLT_SUPPORTED)
void
void PNGAPI
png_set_sPLT(png_structp png_ptr,
png_infop info_ptr, png_sPLT_tp entries, int nentries)
{
@@ -665,7 +686,7 @@ png_set_sPLT(png_structp png_ptr,
#endif /* PNG_sPLT_SUPPORTED */
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
void
void PNGAPI
png_set_unknown_chunks(png_structp png_ptr,
png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)
{
@@ -703,7 +724,7 @@ png_set_unknown_chunks(png_structp png_ptr,
info_ptr->free_me |= PNG_FREE_UNKN;
#endif
}
void
void PNGAPI
png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr,
int chunk, int location)
{
@@ -715,7 +736,7 @@ png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr,
#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \
defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)
void
void PNGAPI
png_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted)
{
png_debug1(1, "in png_permit_empty_plte\n", "");
@@ -726,7 +747,7 @@ png_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted)
#endif
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
void
void PNGAPI
png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep
chunk_list, int num_chunks)
{
@@ -766,7 +787,7 @@ png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep
#endif
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
void
void PNGAPI
png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr,
png_user_chunk_ptr read_user_chunk_fn)
{
@@ -777,22 +798,24 @@ png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr,
#endif
#if defined(PNG_INFO_IMAGE_SUPPORTED)
void
void PNGAPI
png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers)
{
png_debug1(1, "in %s storage function\n", "rows");
if (png_ptr == NULL || info_ptr == NULL)
return;
if(info_ptr->row_pointers != row_pointers)
{
if(info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers))
png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
info_ptr->row_pointers = row_pointers;
}
info_ptr->row_pointers = row_pointers;
if(row_pointers)
info_ptr->valid |= PNG_INFO_IDAT;
}
#endif
void
void PNGAPI
png_set_compression_buffer_size(png_structp png_ptr, png_uint_32 size)
{
if(png_ptr->zbuf)
@@ -802,3 +825,10 @@ png_set_compression_buffer_size(png_structp png_ptr, png_uint_32 size)
png_ptr->zstream.next_out = png_ptr->zbuf;
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
}
void PNGAPI
png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask)
{
if (png_ptr && info_ptr)
info_ptr->valid &= ~(mask);
}

40
pngtrans.c
View File

@@ -1,11 +1,11 @@
/* pngtrans.c - transforms the data in a row (used by both readers and writers)
*
* libpng 1.0.6i - May 1, 2000
* libpng 1.0.7rc2 - June 28, 2000
* For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
* Copyright (c) 1996, 1997 Andreas Dilger
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*/
#define PNG_INTERNAL
@@ -13,7 +13,7 @@
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
/* turn on BGR-to-RGB mapping */
void
void PNGAPI
png_set_bgr(png_structp png_ptr)
{
png_debug(1, "in png_set_bgr\n");
@@ -23,7 +23,7 @@ png_set_bgr(png_structp png_ptr)
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
/* turn on 16 bit byte swapping */
void
void PNGAPI
png_set_swap(png_structp png_ptr)
{
png_debug(1, "in png_set_swap\n");
@@ -34,7 +34,7 @@ png_set_swap(png_structp png_ptr)
#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
/* turn on pixel packing */
void
void PNGAPI
png_set_packing(png_structp png_ptr)
{
png_debug(1, "in png_set_packing\n");
@@ -48,7 +48,7 @@ png_set_packing(png_structp png_ptr)
#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
/* turn on packed pixel swapping */
void
void PNGAPI
png_set_packswap(png_structp png_ptr)
{
png_debug(1, "in png_set_packswap\n");
@@ -58,7 +58,7 @@ png_set_packswap(png_structp png_ptr)
#endif
#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
void
void PNGAPI
png_set_shift(png_structp png_ptr, png_color_8p true_bits)
{
png_debug(1, "in png_set_shift\n");
@@ -69,7 +69,7 @@ png_set_shift(png_structp png_ptr, png_color_8p true_bits)
#if defined(PNG_READ_INTERLACING_SUPPORTED) || \
defined(PNG_WRITE_INTERLACING_SUPPORTED)
int
int PNGAPI
png_set_interlace_handling(png_structp png_ptr)
{
png_debug(1, "in png_set_interlace handling\n");
@@ -89,7 +89,7 @@ png_set_interlace_handling(png_structp png_ptr)
* for 48-bit input data, as well as to avoid problems with some compilers
* that don't like bytes as parameters.
*/
void
void PNGAPI
png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
{
png_debug(1, "in png_set_filler\n");
@@ -122,7 +122,7 @@ png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
void
void PNGAPI
png_set_swap_alpha(png_structp png_ptr)
{
png_debug(1, "in png_set_swap_alpha\n");
@@ -132,7 +132,7 @@ png_set_swap_alpha(png_structp png_ptr)
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
void
void PNGAPI
png_set_invert_alpha(png_structp png_ptr)
{
png_debug(1, "in png_set_invert_alpha\n");
@@ -141,7 +141,7 @@ png_set_invert_alpha(png_structp png_ptr)
#endif
#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
void
void PNGAPI
png_set_invert_mono(png_structp png_ptr)
{
png_debug(1, "in png_set_invert_mono\n");
@@ -149,7 +149,7 @@ png_set_invert_mono(png_structp png_ptr)
}
/* invert monochrome grayscale data */
void
void /* PRIVATE */
png_do_invert(png_row_infop row_info, png_bytep row)
{
png_debug(1, "in png_do_invert\n");
@@ -174,7 +174,7 @@ png_do_invert(png_row_infop row_info, png_bytep row)
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
/* swaps byte order on 16 bit depth images */
void
void /* PRIVATE */
png_do_swap(png_row_infop row_info, png_bytep row)
{
png_debug(1, "in png_do_swap\n");
@@ -305,7 +305,7 @@ static png_byte fourbppswaptable[256] = {
};
/* swaps pixel packing order within bytes */
void
void /* PRIVATE */
png_do_packswap(png_row_infop row_info, png_bytep row)
{
png_debug(1, "in png_do_packswap\n");
@@ -337,7 +337,7 @@ png_do_packswap(png_row_infop row_info, png_bytep row)
#if defined(PNG_WRITE_FILLER_SUPPORTED) || \
defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
/* remove filler or alpha byte(s) */
void
void /* PRIVATE */
png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
{
png_debug(1, "in png_do_strip_filler\n");
@@ -495,7 +495,7 @@ png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
/* swaps red and blue bytes within a pixel */
void
void /* PRIVATE */
png_do_bgr(png_row_infop row_info, png_bytep row)
{
png_debug(1, "in png_do_bgr\n");
@@ -573,7 +573,7 @@ png_do_bgr(png_row_infop row_info, png_bytep row)
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \
defined(PNG_LEGACY_SUPPORTED)
void
void PNGAPI
png_set_user_transform_info(png_structp png_ptr, png_voidp
user_transform_ptr, int user_transform_depth, int user_transform_channels)
{
@@ -595,7 +595,7 @@ png_set_user_transform_info(png_structp png_ptr, png_voidp
* associated with this pointer before png_write_destroy and png_read_destroy
* are called.
*/
png_voidp
png_voidp PNGAPI
png_get_user_transform_ptr(png_structp png_ptr)
{
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)

35
pngtypes.h
View File

@@ -1,35 +0,0 @@
/* pngtypes.h - array of chunk-types for libpng
*
* libpng 1.0.5u - March 4, 2000
* For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
* Copyright (c) 1996, 1997 Andreas Dilger
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
*/
/* Constant strings for known chunk types. If you need to add a chunk,
* define the string in png.h and invoke it here.
*/
PNG_IHDR;
PNG_IDAT;
PNG_IEND;
PNG_PLTE;
PNG_bKGD;
PNG_cHRM;
PNG_gAMA;
PNG_hIST;
PNG_iCCP;
PNG_iTXt;
PNG_oFFs;
PNG_pCAL;
PNG_pHYs;
PNG_sBIT;
PNG_sCAL;
PNG_sPLT;
PNG_sRGB;
PNG_tEXt;
PNG_tIME;
PNG_tRNS;
PNG_zTXt;

23
pngvcrd.c
View File

@@ -2,10 +2,10 @@
*
* For Intel x86 CPU and Microsoft Visual C++ compiler
*
* libpng 1.0.6i - May 1, 2000
* libpng 1.0.7rc2 - June 28, 2000
* For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1998, Intel Corporation
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* Copyright (c) 1998, Intel Corporation
*
* Contributed by Nirav Chhatrapati, Intel Corporation, 1998
* Interface to libpng contributed by Gilles Vollant, 1999
@@ -25,7 +25,7 @@
static int mmx_supported=2;
void
void /* PRIVATE */
png_read_filter_row_c(png_structp png_ptr, png_row_infop row_info,
png_bytep row, png_bytep prev_row, int filter);
@@ -98,7 +98,7 @@ NOT_SUPPORTED:
/* Use this routine for x86 platform - uses faster MMX routine if machine
supports MMX */
void
void /* PRIVATE */
png_combine_row(png_structp png_ptr, png_bytep row, int mask)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -970,7 +970,7 @@ end48:
#if defined(PNG_READ_INTERLACING_SUPPORTED)
void
void /* PRIVATE */
png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
png_uint_32 transformations)
{
@@ -1903,7 +1903,7 @@ union uAll {
// Optimized code for PNG Average filter decoder
void
void /* PRIVATE */
png_read_filter_row_mmx_avg(png_row_infop row_info, png_bytep row
, png_bytep prev_row)
{
@@ -2336,7 +2336,7 @@ davgend:
}
// Optimized code for PNG Paeth filter decoder
void
void /* PRIVATE */
png_read_filter_row_mmx_paeth(png_row_infop row_info, png_bytep row,
png_bytep prev_row)
{
@@ -3232,7 +3232,7 @@ dpthend:
}
// Optimized code for PNG Sub filter decoder
void
void /* PRIVATE */
png_read_filter_row_mmx_sub(png_row_infop row_info, png_bytep row)
{
//int test;
@@ -3536,7 +3536,7 @@ dsubend:
}
// Optimized code for PNG Up filter decoder
void
void /* PRIVATE */
png_read_filter_row_mmx_up(png_row_infop row_info, png_bytep row,
png_bytep prev_row)
{
@@ -3651,7 +3651,7 @@ dupend:
// Optimized png_read_filter_row routines
void
void /* PRIVATE */
png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep
row, png_bytep prev_row, int filter)
{
@@ -3846,7 +3846,8 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep
break;
}
default:
png_error(png_ptr, "Bad adaptive filter type");
png_warning(png_ptr, "Ignoring bad adaptive filter type");
*row=0;
break;
}
}

18
pngwio.c
View File

@@ -1,11 +1,11 @@
/* pngwio.c - functions for data output
*
* libpng 1.0.6i - May 1, 2000
* libpng 1.0.7rc2 - June 28, 2000
* For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
* Copyright (c) 1996, 1997 Andreas Dilger
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*
* This file provides a location for all output. Users who need
* special handling are expected to write functions that have the same
@@ -24,7 +24,7 @@
buffering if you are using unbuffered writes. This should never be asked
to write more than 64K on a 16 bit machine. */
void
void /* PRIVATE */
png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
{
if (png_ptr->write_data_fn != NULL )
@@ -39,7 +39,7 @@ png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
write_data function and use it at run time with png_set_write_fn(), rather
than changing the library. */
#ifndef USE_FAR_KEYWORD
static void
static void /* PRIVATE */
png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
{
png_uint_32 check;
@@ -59,7 +59,7 @@ png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
#define NEAR_BUF_SIZE 1024
#define MIN(a,b) (a <= b ? a : b)
static void
static void /* PRIVATE */
png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
{
png_uint_32 check;
@@ -106,7 +106,7 @@ png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
to disk). After png_flush is called, there should be no data pending
writing in any buffers. */
#if defined(PNG_WRITE_FLUSH_SUPPORTED)
void
void /* PRIVATE */
png_flush(png_structp png_ptr)
{
if (png_ptr->output_flush_fn != NULL)
@@ -114,7 +114,7 @@ png_flush(png_structp png_ptr)
}
#if !defined(PNG_NO_STDIO)
static void
static void /* PRIVATE */
png_default_flush(png_structp png_ptr)
{
FILE *io_ptr;
@@ -147,7 +147,7 @@ png_default_flush(png_structp png_ptr)
PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile
time, output_flush_fn will be ignored, although it must be
supplied for compatibility. */
void
void PNGAPI
png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,
png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)
{

148
pngwrite.c
View File

@@ -1,11 +1,11 @@
/* pngwrite.c - general routines to write a PNG file
*
* libpng 1.0.6i - May 1, 2000
* libpng 1.0.7rc2 - June 28, 2000
* For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
* Copyright (c) 1996, 1997 Andreas Dilger
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*/
/* get internal access to png.h */
@@ -21,7 +21,7 @@
* write a plain PNG file. If you have long comments, I suggest writing
* them in png_write_end(), and compressing them.
*/
void
void PNGAPI
png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)
{
png_debug(1, "in png_write_info_before_PLTE\n");
@@ -57,7 +57,7 @@ png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)
#endif
#if defined(PNG_WRITE_iCCP_SUPPORTED)
if (info_ptr->valid & PNG_INFO_iCCP)
png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_TEXT_COMPRESSION_NONE,
png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_TEXT_COMPRESSION_zTXt,
info_ptr->iccp_profile, (int)info_ptr->iccp_proflen);
#endif
#if defined(PNG_WRITE_sBIT_SUPPORTED)
@@ -110,7 +110,7 @@ png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)
}
}
void
void PNGAPI
png_write_info(png_structp png_ptr, png_infop info_ptr)
{
#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
@@ -277,7 +277,7 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
* in png_write_info(), do not write them again here. If you have long
* comments, I suggest writing them here, and compressing them.
*/
void
void PNGAPI
png_write_end(png_structp png_ptr, png_infop info_ptr)
{
png_debug(1, "in png_write_end\n");
@@ -378,7 +378,7 @@ png_write_end(png_structp png_ptr, png_infop info_ptr)
}
#if defined(PNG_WRITE_tIME_SUPPORTED)
void
void PNGAPI
png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime)
{
png_debug(1, "in png_convert_from_struct_tm\n");
@@ -390,7 +390,7 @@ png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime)
ptime->second = (png_byte)ttime->tm_sec;
}
void
void PNGAPI
png_convert_from_time_t(png_timep ptime, time_t ttime)
{
struct tm *tbuf;
@@ -402,7 +402,7 @@ png_convert_from_time_t(png_timep ptime, time_t ttime)
#endif
/* Initialize png_ptr structure, and allocate any memory needed */
png_structp
png_structp PNGAPI
png_create_write_struct(png_const_charp user_png_ver, png_voidp error_ptr,
png_error_ptr error_fn, png_error_ptr warn_fn)
{
@@ -412,7 +412,7 @@ png_create_write_struct(png_const_charp user_png_ver, png_voidp error_ptr,
}
/* Alternate initialize png_ptr structure, and allocate any memory needed */
png_structp
png_structp PNGAPI
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)
@@ -424,6 +424,7 @@ png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
jmp_buf jmpbuf;
#endif
#endif
int i;
png_debug(1, "in png_create_write_struct\n");
#ifdef PNG_USER_MEM_SUPPORTED
if ((png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
@@ -456,16 +457,38 @@ png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
#endif /* PNG_USER_MEM_SUPPORTED */
png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);
/* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
* we must recompile any applications that use any older library version.
* For versions after libpng 1.0, we will be compatible, so we need
* only check the first digit.
*/
if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
(png_libpng_ver[0] == '0' && user_png_ver[2] < '9'))
i=0;
do
{
png_error(png_ptr,
"Incompatible libpng version in application and library");
if(user_png_ver[i] != png_libpng_ver[i])
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
} while (png_libpng_ver[i++]);
if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
{
/* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
* we must recompile any applications that use any older library version.
* For versions after libpng 1.0, we will be compatible, so we need
* only check the first digit.
*/
if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||
(user_png_ver[0] == '0' && user_png_ver[2] < '9'))
{
png_error(png_ptr,
"Incompatible libpng version in application and library");
}
/* Libpng 1.0.6 was not binary compatible, due to insertion of the
info_ptr->free_me member. Note to maintainer: this test can be
removed from version 2.0.0 and beyond because the previous test
would have already rejected it. */
if (user_png_ver[4] == '6' && user_png_ver[2] == '0' &&
user_png_ver[0] == '1' && user_png_ver[5] == '\0')
{
png_error(png_ptr,
"Application must be recompiled; version 1.0.6 was incompatible");
}
}
/* initialize zbuf - compression buffer */
@@ -480,20 +503,50 @@ png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
1, NULL, NULL);
#endif
png_ptr->mode |= PNG_CREATED_WRITE_STRUCT;
return ((png_structp)png_ptr);
}
/* Initialize png_ptr structure, and allocate any memory needed */
void
#undef png_write_init
void PNGAPI
png_write_init(png_structp png_ptr)
{
/* We only come here via pre-1.0.7-compiled applications */
png_write_init_2(png_ptr, "1.0.0", 10000, 10000);
}
void PNGAPI
png_write_init_2(png_structp png_ptr, png_const_charp user_png_ver,
png_size_t png_struct_size, png_size_t png_info_size)
{
#ifdef PNG_SETJMP_SUPPORTED
jmp_buf tmp_jmp; /* to save current jump buffer */
#endif
int i = 0;
do
{
if (user_png_ver[i] != png_libpng_ver[i])
{
#ifdef PNG_LEGACY_SUPPORTED
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
#else
png_ptr->error_fn=(png_error_ptr)NULL;
png_error(png_ptr,
"Application uses deprecated png_write_init() and must be recompiled.");
#endif
}
} while (png_libpng_ver[i++]);
if (sizeof(png_struct) > png_struct_size ||
sizeof(png_info) > png_info_size)
{
png_ptr->error_fn=(png_error_ptr)NULL;
png_error(png_ptr,
"Application and library have different sized structs. Please recompile.");
}
png_debug(1, "in png_write_init_2\n");
png_debug(1, "in png_write_init\n");
#ifdef PNG_SETJMP_SUPPORTED
/* save jump buffer and error functions */
png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));
@@ -507,15 +560,6 @@ png_write_init(png_structp png_ptr)
png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
#endif
#ifndef PNG_LEGACY_SUPPORTED
if(!(png_ptr->mode & PNG_CREATED_WRITE_STRUCT))
{
png_ptr->error_fn=NULL;
png_error(png_ptr,
"Write struct not properly created; use a legacy-supporting libpng.");
}
#endif
/* initialize zbuf - compression buffer */
png_ptr->zbuf_size = PNG_ZBUF_SIZE;
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
@@ -533,7 +577,7 @@ png_write_init(png_structp png_ptr)
* have called png_set_interlace_handling(), you will have to
* "write" the image seven times.
*/
void
void PNGAPI
png_write_rows(png_structp png_ptr, png_bytepp row,
png_uint_32 num_rows)
{
@@ -551,7 +595,7 @@ png_write_rows(png_structp png_ptr, png_bytepp row,
/* Write the image. You only need to call this function once, even
* if you are writing an interlaced image.
*/
void
void PNGAPI
png_write_image(png_structp png_ptr, png_bytepp image)
{
png_uint_32 i; /* row index */
@@ -578,7 +622,7 @@ png_write_image(png_structp png_ptr, png_bytepp image)
}
/* called by user to write a row of image data */
void
void PNGAPI
png_write_row(png_structp png_ptr, png_bytep row)
{
png_debug2(1, "in png_write_row (row %ld, pass %d)\n",
@@ -729,7 +773,7 @@ png_write_row(png_structp png_ptr, png_bytep row)
#if defined(PNG_WRITE_FLUSH_SUPPORTED)
/* Set the automatic flush interval or 0 to turn flushing off */
void
void PNGAPI
png_set_flush(png_structp png_ptr, int nrows)
{
png_debug(1, "in png_set_flush\n");
@@ -737,7 +781,7 @@ png_set_flush(png_structp png_ptr, int nrows)
}
/* flush the current output buffers now */
void
void PNGAPI
png_write_flush(png_structp png_ptr)
{
int wrote_IDAT;
@@ -790,7 +834,7 @@ png_write_flush(png_structp png_ptr)
#endif /* PNG_WRITE_FLUSH_SUPPORTED */
/* free all memory used by the write */
void
void PNGAPI
png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
{
png_structp png_ptr = NULL;
@@ -845,7 +889,7 @@ png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
/* Free any memory used in png_ptr struct (old method) */
void
void PNGAPI
png_write_destroy(png_structp png_ptr)
{
#ifdef PNG_SETJMP_SUPPORTED
@@ -910,7 +954,7 @@ png_write_destroy(png_structp png_ptr)
}
/* Allow the application to select one or more row filters to use. */
void
void PNGAPI
png_set_filter(png_structp png_ptr, int method, int filters)
{
png_debug(1, "in png_set_filter\n");
@@ -1010,7 +1054,7 @@ png_set_filter(png_structp png_ptr, int method, int filters)
* better compression.
*/
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* GRR 970116 */
void
void PNGAPI
png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,
int num_weights, png_doublep filter_weights,
png_doublep filter_costs)
@@ -1127,7 +1171,7 @@ png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,
}
#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */
void
void PNGAPI
png_set_compression_level(png_structp png_ptr, int level)
{
png_debug(1, "in png_set_compression_level\n");
@@ -1135,7 +1179,7 @@ png_set_compression_level(png_structp png_ptr, int level)
png_ptr->zlib_level = level;
}
void
void PNGAPI
png_set_compression_mem_level(png_structp png_ptr, int mem_level)
{
png_debug(1, "in png_set_compression_mem_level\n");
@@ -1143,7 +1187,7 @@ png_set_compression_mem_level(png_structp png_ptr, int mem_level)
png_ptr->zlib_mem_level = mem_level;
}
void
void PNGAPI
png_set_compression_strategy(png_structp png_ptr, int strategy)
{
png_debug(1, "in png_set_compression_strategy\n");
@@ -1151,7 +1195,7 @@ png_set_compression_strategy(png_structp png_ptr, int strategy)
png_ptr->zlib_strategy = strategy;
}
void
void PNGAPI
png_set_compression_window_bits(png_structp png_ptr, int window_bits)
{
if (window_bits > 15)
@@ -1170,7 +1214,7 @@ png_set_compression_window_bits(png_structp png_ptr, int window_bits)
png_ptr->zlib_window_bits = window_bits;
}
void
void PNGAPI
png_set_compression_method(png_structp png_ptr, int method)
{
png_debug(1, "in png_set_compression_method\n");
@@ -1180,14 +1224,14 @@ png_set_compression_method(png_structp png_ptr, int method)
png_ptr->zlib_method = method;
}
void
void PNGAPI
png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn)
{
png_ptr->write_row_fn = write_row_fn;
}
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
void
void PNGAPI
png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
write_user_transform_fn)
{
@@ -1199,9 +1243,9 @@ png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
#if defined(PNG_INFO_IMAGE_SUPPORTED)
void png_write_png(png_structp png_ptr, png_infop info_ptr,
int transforms,
voidp params)
void PNGAPI
png_write_png(png_structp png_ptr, png_infop info_ptr,
int transforms, voidp params)
{
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
/* invert the alpha channel from opacity to transparency */

16
pngwtran.c
View File

@@ -1,11 +1,11 @@
/* pngwtran.c - transforms the data in a row for PNG writers
*
* libpng 1.0.6i - May 1, 2000
* libpng 1.0.7rc2 - June 28, 2000
* For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
* Copyright (c) 1996, 1997 Andreas Dilger
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*/
#define PNG_INTERNAL
@@ -14,7 +14,7 @@
/* Transform the data according to the user's wishes. The order of
* transformations is significant.
*/
void
void /* PRIVATE */
png_do_write_transformations(png_structp png_ptr)
{
png_debug(1, "in png_do_write_transformations\n");
@@ -82,7 +82,7 @@ png_do_write_transformations(png_structp png_ptr)
* row_info bit depth should be 8 (one pixel per byte). The channels
* should be 1 (this only happens on grayscale and paletted images).
*/
void
void /* PRIVATE */
png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
{
png_debug(1, "in png_do_pack\n");
@@ -208,7 +208,7 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
* would pass 3 as bit_depth, and this routine would translate the
* data to 0 to 15.
*/
void
void /* PRIVATE */
png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
{
png_debug(1, "in png_do_shift\n");
@@ -332,7 +332,7 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
#endif
#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
void
void /* PRIVATE */
png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
{
png_debug(1, "in png_do_write_swap_alpha\n");
@@ -420,7 +420,7 @@ png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
#endif
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
void
void /* PRIVATE */
png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
{
png_debug(1, "in png_do_write_invert_alpha\n");

229
pngwutil.c
View File

@@ -1,11 +1,11 @@
/* pngwutil.c - utilities to write a PNG file
*
* libpng 1.0.6i - May 1, 2000
* libpng 1.0.7rc2 - June 28, 2000
* For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
* Copyright (c) 1996, 1997 Andreas Dilger
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*/
#define PNG_INTERNAL
@@ -15,7 +15,7 @@
* with unsigned numbers for convenience, although one supported
* ancillary chunk uses signed (two's complement) numbers.
*/
void
void /* PRIVATE */
png_save_uint_32(png_bytep buf, png_uint_32 i)
{
buf[0] = (png_byte)((i >> 24) & 0xff);
@@ -29,7 +29,7 @@ png_save_uint_32(png_bytep buf, png_uint_32 i)
* complement format. If this isn't the case, then this routine needs to
* be modified to write data in two's complement format.
*/
void
void /* PRIVATE */
png_save_int_32(png_bytep buf, png_int_32 i)
{
buf[0] = (png_byte)((i >> 24) & 0xff);
@@ -43,7 +43,7 @@ png_save_int_32(png_bytep buf, png_int_32 i)
* The parameter is declared unsigned int, not png_uint_16,
* just to avoid potential problems on pre-ANSI C compilers.
*/
void
void /* PRIVATE */
png_save_uint_16(png_bytep buf, unsigned int i)
{
buf[0] = (png_byte)((i >> 8) & 0xff);
@@ -59,7 +59,7 @@ png_save_uint_16(png_bytep buf, unsigned int i)
* png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end()
* functions instead.
*/
void
void PNGAPI
png_write_chunk(png_structp png_ptr, png_bytep chunk_name,
png_bytep data, png_size_t length)
{
@@ -72,7 +72,7 @@ png_write_chunk(png_structp png_ptr, png_bytep chunk_name,
* The total_length is the sum of the lengths of all the data you will be
* passing in png_write_chunk_data().
*/
void
void PNGAPI
png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,
png_uint_32 length)
{
@@ -95,7 +95,7 @@ png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,
* sum of the lengths from these calls *must* add up to the total_length
* given to png_write_chunk_start().
*/
void
void PNGAPI
png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length)
{
/* write the data, and run the CRC over it */
@@ -107,7 +107,7 @@ png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length)
}
/* Finish a chunk started with png_write_chunk_start(). */
void
void PNGAPI
png_write_chunk_end(png_structp png_ptr)
{
png_byte buf[4];
@@ -124,7 +124,7 @@ png_write_chunk_end(png_structp png_ptr)
* we should call png_set_sig_bytes() to tell libpng how many of the
* bytes have already been written.
*/
void
void /* PRIVATE */
png_write_sig(png_structp png_ptr)
{
png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
@@ -151,7 +151,7 @@ typedef struct
} compression_state;
/* compress given text into storage in the png_ptr structure */
static int
static int /* PRIVATE */
png_text_compress(png_structp png_ptr,
png_charp text, png_size_t text_len, int compression,
compression_state *comp)
@@ -260,7 +260,49 @@ png_text_compress(png_structp png_ptr,
{
/* tell zlib we are finished */
ret = deflate(&png_ptr->zstream, Z_FINISH);
if (ret != Z_OK && ret != Z_STREAM_END)
if (ret == Z_OK)
{
/* check to see if we need more room */
if (!(png_ptr->zstream.avail_out))
{
/* check to make sure our output array has room */
if (comp->num_output_ptr >= comp->max_output_ptr)
{
int old_max;
old_max = comp->max_output_ptr;
comp->max_output_ptr = comp->num_output_ptr + 4;
if (comp->output_ptr != NULL)
{
png_charpp old_ptr;
old_ptr = comp->output_ptr;
/* This could be optimized to realloc() */
comp->output_ptr = (png_charpp)png_malloc(png_ptr,
(png_uint_32)(comp->max_output_ptr * sizeof (png_charpp)));
png_memcpy(comp->output_ptr, old_ptr,
old_max * sizeof (png_charp));
png_free(png_ptr, old_ptr);
}
else
comp->output_ptr = (png_charpp)png_malloc(png_ptr,
(png_uint_32)(comp->max_output_ptr * sizeof (png_charp)));
}
/* save off the data */
comp->output_ptr[comp->num_output_ptr] =
(png_charp)png_malloc(png_ptr, (png_uint_32)png_ptr->zbuf_size);
png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,
png_ptr->zbuf_size);
comp->num_output_ptr++;
/* and reset the buffer pointers */
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
png_ptr->zstream.next_out = png_ptr->zbuf;
}
}
else if (ret != Z_STREAM_END)
{
/* we got an error */
if (png_ptr->zstream.msg != NULL)
@@ -268,45 +310,6 @@ png_text_compress(png_structp png_ptr,
else
png_error(png_ptr, "zlib error");
}
/* check to see if we need more room */
if (!(png_ptr->zstream.avail_out) && ret == Z_OK)
{
/* check to make sure our output array has room */
if (comp->num_output_ptr >= comp->max_output_ptr)
{
int old_max;
old_max = comp->max_output_ptr;
comp->max_output_ptr = comp->num_output_ptr + 4;
if (comp->output_ptr != NULL)
{
png_charpp old_ptr;
old_ptr = comp->output_ptr;
/* This could be optimized to realloc() */
comp->output_ptr = (png_charpp)png_malloc(png_ptr,
(png_uint_32)(comp->max_output_ptr * sizeof (png_charpp)));
png_memcpy(comp->output_ptr, old_ptr,
old_max * sizeof (png_charp));
png_free(png_ptr, old_ptr);
}
else
comp->output_ptr = (png_charpp)png_malloc(png_ptr,
(png_uint_32)(comp->max_output_ptr * sizeof (png_charp)));
}
/* save off the data */
comp->output_ptr[comp->num_output_ptr] = (png_charp)png_malloc(png_ptr,
(png_uint_32)png_ptr->zbuf_size);
png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,
png_ptr->zbuf_size);
comp->num_output_ptr++;
/* and reset the buffer pointers */
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
png_ptr->zstream.next_out = png_ptr->zbuf;
}
} while (ret != Z_STREAM_END);
/* text length is number of buffers plus last buffer */
@@ -318,7 +321,7 @@ png_text_compress(png_structp png_ptr,
}
/* ship the compressed text out via chunk writes */
static void
static void /* PRIVATE */
png_write_compressed_data_out(png_structp png_ptr, compression_state *comp)
{
int i;
@@ -354,7 +357,7 @@ png_write_compressed_data_out(png_structp png_ptr, compression_state *comp)
* information. Note that the rest of this code depends upon this
* information being correct.
*/
void
void /* PRIVATE */
png_write_IHDR(png_structp 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)
@@ -497,7 +500,7 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
* correct order for PNG, so people can redefine it to any convenient
* structure.
*/
void
void /* PRIVATE */
png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -529,6 +532,7 @@ png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)
png_debug1(3, "num_palette = %d\n", png_ptr->num_palette);
png_write_chunk_start(png_ptr, (png_bytep)png_PLTE, num_pal * 3);
#ifndef PNG_NO_POINTER_INDEXING
for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)
{
buf[0] = pal_ptr->red;
@@ -536,12 +540,23 @@ png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)
buf[2] = pal_ptr->blue;
png_write_chunk_data(png_ptr, buf, (png_size_t)3);
}
#else
/* This is a little slower but some buggy compilers need to do this instead */
pal_ptr=palette;
for (i = 0; i < num_pal; i++)
{
buf[0] = pal_ptr[i].red;
buf[1] = pal_ptr[i].green;
buf[2] = pal_ptr[i].blue;
png_write_chunk_data(png_ptr, buf, (png_size_t)3);
}
#endif
png_write_chunk_end(png_ptr);
png_ptr->mode |= PNG_HAVE_PLTE;
}
/* write an IDAT chunk */
void
void /* PRIVATE */
png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -553,7 +568,7 @@ png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)
}
/* write an IEND chunk */
void
void /* PRIVATE */
png_write_IEND(png_structp png_ptr)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -567,7 +582,7 @@ png_write_IEND(png_structp png_ptr)
#if defined(PNG_WRITE_gAMA_SUPPORTED)
/* write a gAMA chunk */
#ifdef PNG_FLOATING_POINT_SUPPORTED
void
void /* PRIVATE */
png_write_gAMA(png_structp png_ptr, double file_gamma)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -584,7 +599,7 @@ png_write_gAMA(png_structp png_ptr, double file_gamma)
}
#endif
#ifdef PNG_FIXED_POINT_SUPPORTED
void
void /* PRIVATE */
png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -602,7 +617,7 @@ png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma)
#if defined(PNG_WRITE_sRGB_SUPPORTED)
/* write a sRGB chunk */
void
void /* PRIVATE */
png_write_sRGB(png_structp png_ptr, int srgb_intent)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -621,7 +636,7 @@ png_write_sRGB(png_structp png_ptr, int srgb_intent)
#if defined(PNG_WRITE_iCCP_SUPPORTED)
/* write an iCCP chunk */
void
void /* PRIVATE */
png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,
png_charp profile, int profile_len)
{
@@ -643,7 +658,7 @@ png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,
if (compression_type)
png_warning(png_ptr, "Unknown compression type in iCCP chunk");
if (profile == NULL || *profile == '\0')
if (profile == NULL)
profile_len = 0;
if (profile_len)
@@ -665,7 +680,7 @@ png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,
#if defined(PNG_WRITE_sPLT_SUPPORTED)
/* write a sPLT chunk */
void
void /* PRIVATE */
png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -677,6 +692,9 @@ png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)
int entry_size = (spalette->depth == 8 ? 6 : 10);
int palette_size = entry_size * spalette->nentries;
png_sPLT_entryp ep;
#ifdef PNG_NO_POINTER_INDEXING
int i;
#endif
png_debug(1, "in png_write_sPLT\n");
if (spalette->name == NULL || (name_len = png_check_keyword(png_ptr,
@@ -693,6 +711,7 @@ png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)
png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, 1);
/* loop through each palette entry, writing appropriately */
#ifndef PNG_NO_POINTER_INDEXING
for (ep = spalette->entries; ep<spalette->entries+spalette->nentries; ep++)
{
if (spalette->depth == 8)
@@ -713,6 +732,29 @@ png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)
}
png_write_chunk_data(png_ptr, entrybuf, entry_size);
}
#else
ep=spalette->entries;
for (i=0; i>spalette->nentries; i++)
{
if (spalette->depth == 8)
{
entrybuf[0] = (png_byte)ep[i].red;
entrybuf[1] = (png_byte)ep[i].green;
entrybuf[2] = (png_byte)ep[i].blue;
entrybuf[3] = (png_byte)ep[i].alpha;
png_save_uint_16(entrybuf + 4, ep[i].frequency);
}
else
{
png_save_uint_16(entrybuf + 0, ep[i].red);
png_save_uint_16(entrybuf + 2, ep[i].green);
png_save_uint_16(entrybuf + 4, ep[i].blue);
png_save_uint_16(entrybuf + 6, ep[i].alpha);
png_save_uint_16(entrybuf + 8, ep[i].frequency);
}
png_write_chunk_data(png_ptr, entrybuf, entry_size);
}
#endif
png_write_chunk_end(png_ptr);
png_free(png_ptr, new_name);
@@ -721,7 +763,7 @@ png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)
#if defined(PNG_WRITE_sBIT_SUPPORTED)
/* write the sBIT chunk */
void
void /* PRIVATE */
png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -778,7 +820,7 @@ png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type)
#if defined(PNG_WRITE_cHRM_SUPPORTED)
/* write the cHRM chunk */
#ifdef PNG_FLOATING_POINT_SUPPORTED
void
void /* PRIVATE */
png_write_cHRM(png_structp png_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)
@@ -842,7 +884,7 @@ png_write_cHRM(png_structp png_ptr, double white_x, double white_y,
}
#endif
#ifdef PNG_FIXED_POINT_SUPPORTED
void
void /* PRIVATE */
png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x,
png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y,
png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x,
@@ -897,7 +939,7 @@ png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x,
#if defined(PNG_WRITE_tRNS_SUPPORTED)
/* write the tRNS chunk */
void
void /* PRIVATE */
png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,
int num_trans, int color_type)
{
@@ -940,7 +982,7 @@ png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,
#if defined(PNG_WRITE_bKGD_SUPPORTED)
/* write the background chunk */
void
void /* PRIVATE */
png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -981,7 +1023,7 @@ png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)
#if defined(PNG_WRITE_hIST_SUPPORTED)
/* write the histogram */
void
void /* PRIVATE */
png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -1021,7 +1063,7 @@ png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist)
* by the calling routine. This avoids problems with trying to write to
* static keywords without having to have duplicate copies of the strings.
*/
png_size_t
png_size_t /* PRIVATE */
png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)
{
png_size_t key_len;
@@ -1131,7 +1173,7 @@ png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)
#if defined(PNG_WRITE_tEXt_SUPPORTED)
/* write a tEXt chunk */
void
void /* PRIVATE */
png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,
png_size_t text_len)
{
@@ -1172,7 +1214,7 @@ png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,
#if defined(PNG_WRITE_zTXt_SUPPORTED)
/* write a compressed text chunk */
void
void /* PRIVATE */
png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
png_size_t text_len, int compression)
{
@@ -1225,7 +1267,7 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
#if defined(PNG_WRITE_iTXt_SUPPORTED)
/* write an iTXt chunk */
void
void /* PRIVATE */
png_write_iTXt(png_structp png_ptr, int compression, png_charp key,
png_charp lang, png_charp lang_key, png_charp text)
{
@@ -1303,7 +1345,7 @@ png_write_iTXt(png_structp png_ptr, int compression, png_charp key,
#if defined(PNG_WRITE_oFFs_SUPPORTED)
/* write the oFFs chunk */
void
void /* PRIVATE */
png_write_oFFs(png_structp png_ptr, png_uint_32 x_offset,
png_uint_32 y_offset,
int unit_type)
@@ -1327,7 +1369,7 @@ png_write_oFFs(png_structp png_ptr, png_uint_32 x_offset,
#if defined(PNG_WRITE_pCAL_SUPPORTED)
/* write the pCAL chunk (png-scivis-19970203) */
void
void /* PRIVATE */
png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
png_int_32 X1, int type, int nparams, png_charp units, png_charpp params)
{
@@ -1388,7 +1430,7 @@ png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
#if defined(PNG_WRITE_sCAL_SUPPORTED)
/* write the sCAL chunk */
#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)
void
void /* PRIVATE */
png_write_sCAL(png_structp png_ptr, int unit, double width,double height)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -1413,7 +1455,7 @@ png_write_sCAL(png_structp png_ptr, int unit, double width,double height)
}
#else
#ifdef PNG_FIXED_POINT_SUPPORTED
void
void /* PRIVATE */
png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width,
png_charp height)
{
@@ -1443,7 +1485,7 @@ png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width,
#if defined(PNG_WRITE_pHYs_SUPPORTED)
/* write the pHYs chunk */
void
void /* PRIVATE */
png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit,
png_uint_32 y_pixels_per_unit,
int unit_type)
@@ -1469,7 +1511,7 @@ png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit,
/* Write the tIME chunk. Use either png_convert_from_struct_tm()
* or png_convert_from_time_t(), or fill in the structure yourself.
*/
void
void /* PRIVATE */
png_write_tIME(png_structp png_ptr, png_timep mod_time)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -1498,7 +1540,7 @@ png_write_tIME(png_structp png_ptr, png_timep mod_time)
#endif
/* initializes the row writing capability of libpng */
void
void /* PRIVATE */
png_write_start_row(png_structp png_ptr)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -1592,7 +1634,7 @@ png_write_start_row(png_structp png_ptr)
}
/* Internal use only. Called when finished processing a row of data. */
void
void /* PRIVATE */
png_write_finish_row(png_structp png_ptr)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -1672,20 +1714,23 @@ png_write_finish_row(png_structp png_ptr)
/* tell the compressor we are done */
ret = deflate(&png_ptr->zstream, Z_FINISH);
/* check for an error */
if (ret != Z_OK && ret != Z_STREAM_END)
if (ret == Z_OK)
{
/* check to see if we need more room */
if (!(png_ptr->zstream.avail_out))
{
png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
png_ptr->zstream.next_out = png_ptr->zbuf;
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
}
}
else if (ret != Z_STREAM_END)
{
if (png_ptr->zstream.msg != NULL)
png_error(png_ptr, png_ptr->zstream.msg);
else
png_error(png_ptr, "zlib error");
}
/* check to see if we need more room */
if (!(png_ptr->zstream.avail_out) && ret == Z_OK)
{
png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);
png_ptr->zstream.next_out = png_ptr->zbuf;
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
}
} while (ret != Z_STREAM_END);
/* write any extra space */
@@ -1706,7 +1751,7 @@ png_write_finish_row(png_structp png_ptr)
* sp will always be >= dp, so we should never overwrite anything.
* See the default: case for the easiest code to understand.
*/
void
void /* PRIVATE */
png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
{
#ifdef PNG_USE_LOCAL_ARRAYS
@@ -1877,7 +1922,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
#define PNG_HISHIFT 10
#define PNG_LOMASK ((png_uint_32)0xffffL)
#define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT))
void
void /* PRIVATE */
png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
{
png_bytep prev_row, best_row, row_buf;
@@ -2489,7 +2534,7 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
/* Do the actual writing of a previously filtered row. */
void
void /* PRIVATE */
png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row)
{
png_debug(1, "in png_write_filtered_row\n");

10
zlib.h
View File

@@ -1,5 +1,5 @@
/* zlib.h -- interface of the 'zlib' general purpose compression library
version 1.1.3, July 9th, 1998
version 1.1.3pc, May 2000
Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler
@@ -28,6 +28,12 @@
(zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
*/
/* Changes from version 1.1.3 to version 1.1.3pc
*
* The default value of TOO_FAR has been changed to 32767 in deflate.c
* Glenn Randers-Pehrson, February 2000.
*/
#ifndef _ZLIB_H
#define _ZLIB_H
@@ -37,7 +43,7 @@
extern "C" {
#endif
#define ZLIB_VERSION "1.1.3"
#define ZLIB_VERSION "1.1.3pc"
/*
The 'zlib' compression library provides in-memory compression and