fries/GRRLIB
1
0
Fork 0
mirror of https://github.com/GRRLIB/GRRLIB.git synced 2024-11-22 15:02:20 +00:00
Code Issues Projects Releases Packages Wiki Activity

[CHG] libpng updated to version 1.4.2

Browse source
This commit is contained in:
Crayon2000 2010-05-10 15:40:06 +00:00
parent 957e2fe2c0
commit 2ad5794867
11 changed files with 227 additions and 188 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
GRRLIB/lib/png/png.c
View file

@ -1,7 +1,7 @@
/* png.c - location for general purpose libpng functions /* png.c - location for general purpose libpng functions
* *
* Last changed in libpng 1.4.1 [February 25, 2010] * Last changed in libpng 1.4.2 [May 6, 2010]
* Copyright (c) 1998-2010 Glenn Randers-Pehrson * Copyright (c) 1998-2010 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -17,7 +17,7 @@
#include "pngpriv.h" #include "pngpriv.h"
/* Generate a compiler error if there is an old png.h in the search path. */ /* Generate a compiler error if there is an old png.h in the search path. */
typedef version_1_4_1 Your_png_h_is_not_version_1_4_1; typedef version_1_4_2 Your_png_h_is_not_version_1_4_2;
/* Version information for C files. This had better match the version /* Version information for C files. This had better match the version
* string defined in png.h. * string defined in png.h.
@ -551,13 +551,13 @@ png_get_copyright(png_structp png_ptr)
#else #else
#ifdef __STDC__ #ifdef __STDC__
return ((png_charp) PNG_STRING_NEWLINE \ return ((png_charp) PNG_STRING_NEWLINE \
"libpng version 1.4.1 - February 25, 2010" PNG_STRING_NEWLINE \ "libpng version 1.4.2 - May 6, 2010" PNG_STRING_NEWLINE \
"Copyright (c) 1998-2010 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \ "Copyright (c) 1998-2010 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \
"Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \ "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
"Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \ "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
PNG_STRING_NEWLINE); PNG_STRING_NEWLINE);
#else #else
return ((png_charp) "libpng version 1.4.1 - February 25, 2010\ return ((png_charp) "libpng version 1.4.2 - May 6, 2010\
Copyright (c) 1998-2010 Glenn Randers-Pehrson\ Copyright (c) 1998-2010 Glenn Randers-Pehrson\
Copyright (c) 1996-1997 Andreas Dilger\ Copyright (c) 1996-1997 Andreas Dilger\
Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc."); Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.");
@ -622,7 +622,9 @@ png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)
return 0; return 0;
} }
#endif #endif
#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
#ifdef PNG_READ_SUPPORTED
/* This function, added to libpng-1.0.6g, is untested. */ /* This function, added to libpng-1.0.6g, is untested. */
int PNGAPI int PNGAPI
png_reset_zstream(png_structp png_ptr) png_reset_zstream(png_structp png_ptr)
@ -631,7 +633,7 @@ png_reset_zstream(png_structp png_ptr)
return Z_STREAM_ERROR; return Z_STREAM_ERROR;
return (inflateReset(&png_ptr->zstream)); return (inflateReset(&png_ptr->zstream));
} }
#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */ #endif /* PNG_READ_SUPPORTED */
/* This function was added to libpng-1.0.7 */ /* This function was added to libpng-1.0.7 */
png_uint_32 PNGAPI png_uint_32 PNGAPI

54
GRRLIB/lib/png/png.h
View file

@ -1,7 +1,7 @@
/* png.h - header file for PNG reference library /* png.h - header file for PNG reference library
* *
* libpng version 1.4.1 - February 25, 2010 * libpng version 1.4.2 - May 6, 2010
* Copyright (c) 1998-2010 Glenn Randers-Pehrson * Copyright (c) 1998-2010 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -11,7 +11,7 @@
* Authors and maintainers: * Authors and maintainers:
* libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat * 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.89c, June 1996, through 0.96, May 1997: Andreas Dilger
* libpng versions 0.97, January 1998, through 1.4.1 - February 25, 2010: Glenn * libpng versions 0.97, January 1998, through 1.4.2 - May 6, 2010: Glenn
* See also "Contributing Authors", below. * See also "Contributing Authors", below.
* *
* Note about libpng version numbers: * Note about libpng version numbers:
@ -139,6 +139,9 @@
* 1.4.1beta04-12 14 10401 14.so.14.1[.0] * 1.4.1beta04-12 14 10401 14.so.14.1[.0]
* 1.4.1rc02-04 14 10401 14.so.14.1[.0] * 1.4.1rc02-04 14 10401 14.so.14.1[.0]
* 1.4.1 14 10401 14.so.14.1[.0] * 1.4.1 14 10401 14.so.14.1[.0]
* 1.4.2beta01 14 10402 14.so.14.2[.0]
* 1.4.2rc02-06 14 10402 14.so.14.2[.0]
* 1.4.2 14 10402 14.so.14.2[.0]
* *
* Henceforth the source version will match the shared-library major * Henceforth the source version will match the shared-library major
* and minor numbers; the shared-library major version number will be * and minor numbers; the shared-library major version number will be
@ -170,7 +173,7 @@
* *
* This code is released under the libpng license. * This code is released under the libpng license.
* *
* libpng versions 1.2.6, August 15, 2004, through 1.4.1, February 25, 2010, are * libpng versions 1.2.6, August 15, 2004, through 1.4.2, May 6, 2010, are
* Copyright (c) 2004, 2006-2010 Glenn Randers-Pehrson, and are * Copyright (c) 2004, 2006-2010 Glenn Randers-Pehrson, and are
* distributed according to the same disclaimer and license as libpng-1.2.5 * distributed according to the same disclaimer and license as libpng-1.2.5
* with the following individual added to the list of Contributing Authors: * with the following individual added to the list of Contributing Authors:
@ -282,13 +285,13 @@
* Y2K compliance in libpng: * Y2K compliance in libpng:
* ========================= * =========================
* *
* February 25, 2010 * May 6, 2010
* *
* Since the PNG Development group is an ad-hoc body, we can't make * Since the PNG Development group is an ad-hoc body, we can't make
* an official declaration. * an official declaration.
* *
* This is your unofficial assurance that libpng from version 0.71 and * This is your unofficial assurance that libpng from version 0.71 and
* upward through 1.4.1 are Y2K compliant. It is my belief that earlier * upward through 1.4.2 are Y2K compliant. It is my belief that earlier
* versions were also Y2K compliant. * versions were also Y2K compliant.
* *
* Libpng only has three year fields. One is a 2-byte unsigned integer * Libpng only has three year fields. One is a 2-byte unsigned integer
@ -344,9 +347,9 @@
*/ */
/* Version information for png.h - this should match the version in png.c */ /* Version information for png.h - this should match the version in png.c */
#define PNG_LIBPNG_VER_STRING "1.4.1" #define PNG_LIBPNG_VER_STRING "1.4.2"
#define PNG_HEADER_VERSION_STRING \ #define PNG_HEADER_VERSION_STRING \
" libpng version 1.4.1 - February 25, 2010\n" " libpng version 1.4.2 - May 6, 2010\n"
#define PNG_LIBPNG_VER_SONUM 14 #define PNG_LIBPNG_VER_SONUM 14
#define PNG_LIBPNG_VER_DLLNUM 14 #define PNG_LIBPNG_VER_DLLNUM 14
@ -354,7 +357,7 @@
/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */ /* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */
#define PNG_LIBPNG_VER_MAJOR 1 #define PNG_LIBPNG_VER_MAJOR 1
#define PNG_LIBPNG_VER_MINOR 4 #define PNG_LIBPNG_VER_MINOR 4
#define PNG_LIBPNG_VER_RELEASE 1 #define PNG_LIBPNG_VER_RELEASE 2
/* This should match the numeric part of the final component of /* This should match the numeric part of the final component of
* PNG_LIBPNG_VER_STRING, omitting any leading zero: * PNG_LIBPNG_VER_STRING, omitting any leading zero:
*/ */
@ -384,7 +387,7 @@
* version 1.0.0 was mis-numbered 100 instead of 10000). From * 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 * version 1.0.1 it's xxyyzz, where x=major, y=minor, z=release
*/ */
#define PNG_LIBPNG_VER 10401 /* 1.4.1 */ #define PNG_LIBPNG_VER 10402 /* 1.4.2 */
#ifndef PNG_VERSION_INFO_ONLY #ifndef PNG_VERSION_INFO_ONLY
/* Include the compression library's header */ /* Include the compression library's header */
@ -1332,13 +1335,13 @@ struct png_struct_def
png_uint_16 offset_table_count_free PNG_DEPSTRUCT; png_uint_16 offset_table_count_free PNG_DEPSTRUCT;
#endif #endif
#ifdef PNG_READ_DITHER_SUPPORTED #ifdef PNG_READ_QUANTIZE_SUPPORTED
png_bytep palette_lookup PNG_DEPSTRUCT; /* lookup table for dithering */ png_bytep palette_lookup PNG_DEPSTRUCT; /* lookup table for quantizing */
png_bytep dither_index PNG_DEPSTRUCT; /* index translation for palette png_bytep quantize_index PNG_DEPSTRUCT; /* index translation for palette
files */ files */
#endif #endif
#if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_hIST_SUPPORTED) #if defined(PNG_READ_QUANTIZE_SUPPORTED) || defined(PNG_hIST_SUPPORTED)
png_uint_16p hist PNG_DEPSTRUCT; /* histogram */ png_uint_16p hist PNG_DEPSTRUCT; /* histogram */
#endif #endif
@ -1422,9 +1425,9 @@ struct png_struct_def
png_bytep big_row_buf PNG_DEPSTRUCT; /* buffer to save current png_bytep big_row_buf PNG_DEPSTRUCT; /* buffer to save current
(unfiltered) row */ (unfiltered) row */
#ifdef PNG_READ_DITHER_SUPPORTED #ifdef PNG_READ_QUANTIZE_SUPPORTED
/* The following three members were added at version 1.0.14 and 1.2.4 */ /* The following three members were added at version 1.0.14 and 1.2.4 */
png_bytep dither_sort PNG_DEPSTRUCT; /* working sort array */ png_bytep quantize_sort PNG_DEPSTRUCT; /* working sort array */
png_bytep index_to_palette PNG_DEPSTRUCT; /* where the original png_bytep index_to_palette PNG_DEPSTRUCT; /* where the original
index currently is index currently is
in the palette */ in the palette */
@ -1468,7 +1471,7 @@ struct png_struct_def
/* This triggers a compiler error in png.c, if png.c and png.h /* This triggers a compiler error in png.c, if png.c and png.h
* do not agree upon the version number. * do not agree upon the version number.
*/ */
typedef png_structp version_1_4_1; typedef png_structp version_1_4_2;
typedef png_struct FAR * FAR * png_structpp; typedef png_struct FAR * FAR * png_structpp;
@ -1495,6 +1498,11 @@ extern PNG_EXPORT(void,png_set_sig_bytes) PNGARG((png_structp png_ptr,
extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start, extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start,
png_size_t num_to_check)); png_size_t num_to_check));
/* Simple signature checking function. This is the same as calling
* png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n).
*/
#define png_check_sig(sig,n) !png_sig_cmp((sig), 0, (n))
/* Allocate and initialize png_ptr struct for reading, and any other memory. */ /* Allocate and initialize png_ptr struct for reading, and any other memory. */
extern PNG_EXPORT(png_structp,png_create_read_struct) extern PNG_EXPORT(png_structp,png_create_read_struct)
PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,
@ -1532,8 +1540,10 @@ extern PNG_EXPORT(jmp_buf*, png_set_longjmp_fn)
(LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP) (LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP)
#endif #endif
#ifdef PNG_READ_SUPPORTED
/* Reset the compression stream */ /* Reset the compression stream */
extern PNG_EXPORT(int,png_reset_zstream) PNGARG((png_structp png_ptr)); extern PNG_EXPORT(int,png_reset_zstream) PNGARG((png_structp png_ptr));
#endif
/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */ /* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */
#ifdef PNG_USER_MEM_SUPPORTED #ifdef PNG_USER_MEM_SUPPORTED
@ -1710,14 +1720,16 @@ extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr,
extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr)); extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr));
#endif #endif
#ifdef PNG_READ_DITHER_SUPPORTED #ifdef PNG_READ_QUANTIZE_SUPPORTED
/* Turn on dithering, and reduce the palette to the number of colors /* Turn on quantizing, and reduce the palette to the number of colors
* available. * available. Prior to libpng-1.4.2, this was png_set_dither().
*/ */
extern PNG_EXPORT(void,png_set_dither) PNGARG((png_structp png_ptr, extern PNG_EXPORT(void,png_set_quantize) PNGARG((png_structp png_ptr,
png_colorp palette, int num_palette, int maximum_colors, png_colorp palette, int num_palette, int maximum_colors,
png_uint_16p histogram, int full_dither)); png_uint_16p histogram, int full_quantize));
#endif #endif
/* This migration aid will be removed from libpng-1.5.0 */
#define png_set_dither png_set_quantize
#ifdef PNG_READ_GAMMA_SUPPORTED #ifdef PNG_READ_GAMMA_SUPPORTED
/* Handle gamma correction. Screen_gamma=(display_exponent) */ /* Handle gamma correction. Screen_gamma=(display_exponent) */

41
GRRLIB/lib/png/pngconf.h
View file

@ -1,7 +1,7 @@
/* pngconf.h - machine configurable file for libpng /* pngconf.h - machine configurable file for libpng
* *
* libpng version 1.4.1 - February 25, 2010 * libpng version 1.4.2 - May 6, 2010
* For conditions of distribution and use, see copyright notice in png.h * For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1998-2010 Glenn Randers-Pehrson * Copyright (c) 1998-2010 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@ -391,18 +391,32 @@
/* Other defines for things like memory and the like can go here. */ /* Other defines for things like memory and the like can go here. */
/* This controls how fine the dithering gets. As this allocates /* This controls how fine the quantizing gets. As this allocates
* a largish chunk of memory (32K), those who are not as concerned * a largish chunk of memory (32K), those who are not as concerned
* with dithering quality can decrease some or all of these. * with quantizing quality can decrease some or all of these.
*/ */
#ifndef PNG_DITHER_RED_BITS
# define PNG_DITHER_RED_BITS 5 /* Prior to libpng-1.4.2, these were PNG_DITHER_*_BITS
* These migration aids will be removed from libpng-1.5.0.
*/
#ifdef PNG_DITHER_RED_BITS
# define PNG_QUANTIZE_RED_BITS PNG_DITHER_RED_BITS
#endif #endif
#ifndef PNG_DITHER_GREEN_BITS #ifdef PNG_DITHER_GREEN_BITS
# define PNG_DITHER_GREEN_BITS 5 # define PNG_QUANTIZE_GREEN_BITS PNG_DITHER_GREEN_BITS
#endif #endif
#ifndef PNG_DITHER_BLUE_BITS #ifdef PNG_DITHER_BLUE_BITS
# define PNG_DITHER_BLUE_BITS 5 # define PNG_QUANTIZE_BLUE_BITS PNG_DITHER_BLUE_BITS
#endif
#ifndef PNG_QUANTIZE_RED_BITS
# define PNG_QUANTIZE_RED_BITS 5
#endif
#ifndef PNG_QUANTIZE_GREEN_BITS
# define PNG_QUANTIZE_GREEN_BITS 5
#endif
#ifndef PNG_QUANTIZE_BLUE_BITS
# define PNG_QUANTIZE_BLUE_BITS 5
#endif #endif
/* This controls how fine the gamma correction becomes when you /* This controls how fine the gamma correction becomes when you
@ -499,11 +513,12 @@
# ifndef PNG_NO_READ_INVERT # ifndef PNG_NO_READ_INVERT
# define PNG_READ_INVERT_SUPPORTED # define PNG_READ_INVERT_SUPPORTED
# endif # endif
#if 0 /* removed from libpng-1.4.0 */ # ifndef PNG_NO_READ_QUANTIZE
# ifndef PNG_NO_READ_DITHER /* Prior to libpng-1.4.0 this was PNG_READ_DITHER_SUPPORTED */
# define PNG_READ_DITHER_SUPPORTED # ifndef PNG_NO_READ_DITHER /* This migration aid will be removed */
# define PNG_READ_QUANTIZE_SUPPORTED
# endif
# endif # endif
#endif /* 0 */
# ifndef PNG_NO_READ_BACKGROUND # ifndef PNG_NO_READ_BACKGROUND
# define PNG_READ_BACKGROUND_SUPPORTED # define PNG_READ_BACKGROUND_SUPPORTED
# endif # endif

2
GRRLIB/lib/png/pngget.c
View file

@ -1,7 +1,7 @@
/* pngget.c - retrieval of values from info struct /* pngget.c - retrieval of values from info struct
* *
* Last changed in libpng 1.4.1 [February 25, 2010] * Last changed in libpng 1.4.2 [May 6, 2010]
* Copyright (c) 1998-2010 Glenn Randers-Pehrson * Copyright (c) 1998-2010 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

2
GRRLIB/lib/png/pngmem.c
View file

@ -1,7 +1,7 @@
/* pngmem.c - stub functions for memory allocation /* pngmem.c - stub functions for memory allocation
* *
* Last changed in libpng 1.4.0 [February 25, 2010] * Last changed in libpng 1.4.2 [May 6, 2010]
* Copyright (c) 1998-2010 Glenn Randers-Pehrson * Copyright (c) 1998-2010 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

10
GRRLIB/lib/png/pngpriv.h
View file

@ -1,7 +1,7 @@
/* pngpriv.h - private declarations for use inside libpng /* pngpriv.h - private declarations for use inside libpng
* *
* libpng version 1.4.1 - February 25, 2010 * libpng version 1.4.2 - May 6, 2010
* For conditions of distribution and use, see copyright notice in png.h * For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1998-2010 Glenn Randers-Pehrson * Copyright (c) 1998-2010 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@ -106,7 +106,7 @@
#define PNG_SHIFT 0x0008 #define PNG_SHIFT 0x0008
#define PNG_SWAP_BYTES 0x0010 #define PNG_SWAP_BYTES 0x0010
#define PNG_INVERT_MONO 0x0020 #define PNG_INVERT_MONO 0x0020
#define PNG_DITHER 0x0040 #define PNG_QUANTIZE 0x0040 /* formerly PNG_DITHER */
#define PNG_BACKGROUND 0x0080 #define PNG_BACKGROUND 0x0080
#define PNG_BACKGROUND_EXPAND 0x0100 #define PNG_BACKGROUND_EXPAND 0x0100
/* 0x0200 unused */ /* 0x0200 unused */
@ -588,9 +588,9 @@ PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, png_bytep row));
PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, png_bytep row)); PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, png_bytep row));
#endif #endif
#ifdef PNG_READ_DITHER_SUPPORTED #ifdef PNG_READ_QUANTIZE_SUPPORTED
PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info, PNG_EXTERN void png_do_quantize PNGARG((png_row_infop row_info,
png_bytep row, png_bytep palette_lookup, png_bytep dither_lookup)); png_bytep row, png_bytep palette_lookup, png_bytep quantize_lookup));
# ifdef PNG_CORRECT_PALETTE_SUPPORTED # ifdef PNG_CORRECT_PALETTE_SUPPORTED
PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr, PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr,

6
GRRLIB/lib/png/pngread.c
View file

@ -1080,9 +1080,9 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr,
png_free(png_ptr, png_ptr->big_row_buf); png_free(png_ptr, png_ptr->big_row_buf);
png_free(png_ptr, png_ptr->prev_row); png_free(png_ptr, png_ptr->prev_row);
png_free(png_ptr, png_ptr->chunkdata); png_free(png_ptr, png_ptr->chunkdata);
#ifdef PNG_READ_DITHER_SUPPORTED #ifdef PNG_READ_QUANTIZE_SUPPORTED
png_free(png_ptr, png_ptr->palette_lookup); png_free(png_ptr, png_ptr->palette_lookup);
png_free(png_ptr, png_ptr->dither_index); png_free(png_ptr, png_ptr->quantize_index);
#endif #endif
#ifdef PNG_READ_GAMMA_SUPPORTED #ifdef PNG_READ_GAMMA_SUPPORTED
png_free(png_ptr, png_ptr->gamma_table); png_free(png_ptr, png_ptr->gamma_table);
@ -1257,7 +1257,7 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
png_set_expand(png_ptr); png_set_expand(png_ptr);
#endif #endif
/* We don't handle background color or gamma transformation or dithering. /* We don't handle background color or gamma transformation or quantizing.
*/ */
#ifdef PNG_READ_INVERT_SUPPORTED #ifdef PNG_READ_INVERT_SUPPORTED

158
GRRLIB/lib/png/pngrtran.c
View file

@ -1,7 +1,7 @@
/* pngrtran.c - transforms the data in a row for PNG readers /* pngrtran.c - transforms the data in a row for PNG readers
* *
* Last changed in libpng 1.4.1 [February 25, 2010] * Last changed in libpng 1.4.2 [May 6, 2010]
* Copyright (c) 1998-2010 Glenn Randers-Pehrson * Copyright (c) 1998-2010 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -141,13 +141,13 @@ png_set_strip_alpha(png_structp png_ptr)
} }
#endif #endif
#ifdef PNG_READ_DITHER_SUPPORTED #ifdef PNG_READ_QUANTIZE_SUPPORTED
/* Dither file to 8 bit. Supply a palette, the current number /* Quantize file to 8 bit. Supply a palette, the current number
* of elements in the palette, the maximum number of elements * of elements in the palette, the maximum number of elements
* allowed, and a histogram if possible. If the current number * allowed, and a histogram if possible. If the current number
* of colors is greater then the maximum number, the palette will be * of colors is greater then the maximum number, the palette will be
* modified to fit in the maximum number. "full_dither" indicates * modified to fit in the maximum number. "full_quantize" indicates
* whether we need a dithering cube set up for RGB images, or if we * whether we need a quantizeing cube set up for RGB images, or if we
* simply are reducing the number of colors in a paletted image. * simply are reducing the number of colors in a paletted image.
*/ */
@ -161,24 +161,24 @@ typedef png_dsort FAR * png_dsortp;
typedef png_dsort FAR * FAR * png_dsortpp; typedef png_dsort FAR * FAR * png_dsortpp;
void PNGAPI void PNGAPI
png_set_dither(png_structp png_ptr, png_colorp palette, png_set_quantize(png_structp png_ptr, png_colorp palette,
int num_palette, int maximum_colors, png_uint_16p histogram, int num_palette, int maximum_colors, png_uint_16p histogram,
int full_dither) int full_quantize)
{ {
png_debug(1, "in png_set_dither"); png_debug(1, "in png_set_quantize");
if (png_ptr == NULL) if (png_ptr == NULL)
return; return;
png_ptr->transformations |= PNG_DITHER; png_ptr->transformations |= PNG_QUANTIZE;
if (!full_dither) if (!full_quantize)
{ {
int i; int i;
png_ptr->dither_index = (png_bytep)png_malloc(png_ptr, png_ptr->quantize_index = (png_bytep)png_malloc(png_ptr,
(png_uint_32)(num_palette * png_sizeof(png_byte))); (png_uint_32)(num_palette * png_sizeof(png_byte)));
for (i = 0; i < num_palette; i++) for (i = 0; i < num_palette; i++)
png_ptr->dither_index[i] = (png_byte)i; png_ptr->quantize_index[i] = (png_byte)i;
} }
if (num_palette > maximum_colors) if (num_palette > maximum_colors)
@ -192,12 +192,12 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
int i; int i;
/* Initialize an array to sort colors */ /* Initialize an array to sort colors */
png_ptr->dither_sort = (png_bytep)png_malloc(png_ptr, png_ptr->quantize_sort = (png_bytep)png_malloc(png_ptr,
(png_uint_32)(num_palette * png_sizeof(png_byte))); (png_uint_32)(num_palette * png_sizeof(png_byte)));
/* Initialize the dither_sort array */ /* Initialize the quantize_sort array */
for (i = 0; i < num_palette; i++) for (i = 0; i < num_palette; i++)
png_ptr->dither_sort[i] = (png_byte)i; png_ptr->quantize_sort[i] = (png_byte)i;
/* Find the least used palette entries by starting a /* Find the least used palette entries by starting a
* bubble sort, and running it until we have sorted * bubble sort, and running it until we have sorted
@ -214,14 +214,14 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
done = 1; done = 1;
for (j = 0; j < i; j++) for (j = 0; j < i; j++)
{ {
if (histogram[png_ptr->dither_sort[j]] if (histogram[png_ptr->quantize_sort[j]]
< histogram[png_ptr->dither_sort[j + 1]]) < histogram[png_ptr->quantize_sort[j + 1]])
{ {
png_byte t; png_byte t;
t = png_ptr->dither_sort[j]; t = png_ptr->quantize_sort[j];
png_ptr->dither_sort[j] = png_ptr->dither_sort[j + 1]; png_ptr->quantize_sort[j] = png_ptr->quantize_sort[j + 1];
png_ptr->dither_sort[j + 1] = t; png_ptr->quantize_sort[j + 1] = t;
done = 0; done = 0;
} }
} }
@ -230,7 +230,7 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
} }
/* Swap the palette around, and set up a table, if necessary */ /* Swap the palette around, and set up a table, if necessary */
if (full_dither) if (full_quantize)
{ {
int j = num_palette; int j = num_palette;
@ -239,11 +239,11 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
*/ */
for (i = 0; i < maximum_colors; i++) for (i = 0; i < maximum_colors; i++)
{ {
if ((int)png_ptr->dither_sort[i] >= maximum_colors) if ((int)png_ptr->quantize_sort[i] >= maximum_colors)
{ {
do do
j--; j--;
while ((int)png_ptr->dither_sort[j] >= maximum_colors); while ((int)png_ptr->quantize_sort[j] >= maximum_colors);
palette[i] = palette[j]; palette[i] = palette[j];
} }
} }
@ -258,32 +258,32 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
for (i = 0; i < maximum_colors; i++) for (i = 0; i < maximum_colors; i++)
{ {
/* Only move the colors we need to */ /* Only move the colors we need to */
if ((int)png_ptr->dither_sort[i] >= maximum_colors) if ((int)png_ptr->quantize_sort[i] >= maximum_colors)
{ {
png_color tmp_color; png_color tmp_color;
do do
j--; j--;
while ((int)png_ptr->dither_sort[j] >= maximum_colors); while ((int)png_ptr->quantize_sort[j] >= maximum_colors);
tmp_color = palette[j]; tmp_color = palette[j];
palette[j] = palette[i]; palette[j] = palette[i];
palette[i] = tmp_color; palette[i] = tmp_color;
/* Indicate where the color went */ /* Indicate where the color went */
png_ptr->dither_index[j] = (png_byte)i; png_ptr->quantize_index[j] = (png_byte)i;
png_ptr->dither_index[i] = (png_byte)j; png_ptr->quantize_index[i] = (png_byte)j;
} }
} }
/* Find closest color for those colors we are not using */ /* Find closest color for those colors we are not using */
for (i = 0; i < num_palette; i++) for (i = 0; i < num_palette; i++)
{ {
if ((int)png_ptr->dither_index[i] >= maximum_colors) if ((int)png_ptr->quantize_index[i] >= maximum_colors)
{ {
int min_d, k, min_k, d_index; int min_d, k, min_k, d_index;
/* Find the closest color to one we threw out */ /* Find the closest color to one we threw out */
d_index = png_ptr->dither_index[i]; d_index = png_ptr->quantize_index[i];
min_d = PNG_COLOR_DIST(palette[d_index], palette[0]); min_d = PNG_COLOR_DIST(palette[d_index], palette[0]);
for (k = 1, min_k = 0; k < maximum_colors; k++) for (k = 1, min_k = 0; k < maximum_colors; k++)
{ {
@ -298,12 +298,12 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
} }
} }
/* Point to closest color */ /* Point to closest color */
png_ptr->dither_index[i] = (png_byte)min_k; png_ptr->quantize_index[i] = (png_byte)min_k;
} }
} }
} }
png_free(png_ptr, png_ptr->dither_sort); png_free(png_ptr, png_ptr->quantize_sort);
png_ptr->dither_sort = NULL; png_ptr->quantize_sort = NULL;
} }
else else
{ {
@ -410,19 +410,19 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
num_new_palette--; num_new_palette--;
palette[png_ptr->index_to_palette[j]] palette[png_ptr->index_to_palette[j]]
= palette[num_new_palette]; = palette[num_new_palette];
if (!full_dither) if (!full_quantize)
{ {
int k; int k;
for (k = 0; k < num_palette; k++) for (k = 0; k < num_palette; k++)
{ {
if (png_ptr->dither_index[k] == if (png_ptr->quantize_index[k] ==
png_ptr->index_to_palette[j]) png_ptr->index_to_palette[j])
png_ptr->dither_index[k] = png_ptr->quantize_index[k] =
png_ptr->index_to_palette[next_j]; png_ptr->index_to_palette[next_j];
if ((int)png_ptr->dither_index[k] == if ((int)png_ptr->quantize_index[k] ==
num_new_palette) num_new_palette)
png_ptr->dither_index[k] = png_ptr->quantize_index[k] =
png_ptr->index_to_palette[j]; png_ptr->index_to_palette[j];
} }
} }
@ -475,15 +475,15 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
} }
png_ptr->num_palette = (png_uint_16)num_palette; png_ptr->num_palette = (png_uint_16)num_palette;
if (full_dither) if (full_quantize)
{ {
int i; int i;
png_bytep distance; png_bytep distance;
int total_bits = PNG_DITHER_RED_BITS + PNG_DITHER_GREEN_BITS + int total_bits = PNG_QUANTIZE_RED_BITS + PNG_QUANTIZE_GREEN_BITS +
PNG_DITHER_BLUE_BITS; PNG_QUANTIZE_BLUE_BITS;
int num_red = (1 << PNG_DITHER_RED_BITS); int num_red = (1 << PNG_QUANTIZE_RED_BITS);
int num_green = (1 << PNG_DITHER_GREEN_BITS); int num_green = (1 << PNG_QUANTIZE_GREEN_BITS);
int num_blue = (1 << PNG_DITHER_BLUE_BITS); int num_blue = (1 << PNG_QUANTIZE_BLUE_BITS);
png_size_t num_entries = ((png_size_t)1 << total_bits); png_size_t num_entries = ((png_size_t)1 << total_bits);
png_ptr->palette_lookup = (png_bytep )png_calloc(png_ptr, png_ptr->palette_lookup = (png_bytep )png_calloc(png_ptr,
@ -496,16 +496,16 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
for (i = 0; i < num_palette; i++) for (i = 0; i < num_palette; i++)
{ {
int ir, ig, ib; int ir, ig, ib;
int r = (palette[i].red >> (8 - PNG_DITHER_RED_BITS)); int r = (palette[i].red >> (8 - PNG_QUANTIZE_RED_BITS));
int g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS)); int g = (palette[i].green >> (8 - PNG_QUANTIZE_GREEN_BITS));
int b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS)); int b = (palette[i].blue >> (8 - PNG_QUANTIZE_BLUE_BITS));
for (ir = 0; ir < num_red; ir++) for (ir = 0; ir < num_red; ir++)
{ {
/* int dr = abs(ir - r); */ /* int dr = abs(ir - r); */
int dr = ((ir > r) ? ir - r : r - ir); int dr = ((ir > r) ? ir - r : r - ir);
int index_r = (ir << (PNG_DITHER_BLUE_BITS + int index_r = (ir << (PNG_QUANTIZE_BLUE_BITS +
PNG_DITHER_GREEN_BITS)); PNG_QUANTIZE_GREEN_BITS));
for (ig = 0; ig < num_green; ig++) for (ig = 0; ig < num_green; ig++)
{ {
@ -513,7 +513,7 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
int dg = ((ig > g) ? ig - g : g - ig); int dg = ((ig > g) ? ig - g : g - ig);
int dt = dr + dg; int dt = dr + dg;
int dm = ((dr > dg) ? dr : dg); int dm = ((dr > dg) ? dr : dg);
int index_g = index_r | (ig << PNG_DITHER_BLUE_BITS); int index_g = index_r | (ig << PNG_QUANTIZE_BLUE_BITS);
for (ib = 0; ib < num_blue; ib++) for (ib = 0; ib < num_blue; ib++)
{ {
@ -536,7 +536,7 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
png_free(png_ptr, distance); png_free(png_ptr, distance);
} }
} }
#endif #endif /* PNG_READ_QUANTIZE_SUPPORTED */
#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) #if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
/* Transform the image from the file_gamma to the screen_gamma. We /* Transform the image from the file_gamma to the screen_gamma. We
@ -1229,8 +1229,8 @@ png_read_transform_info(png_structp png_ptr, png_infop info_ptr)
info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR; info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR;
#endif #endif
#ifdef PNG_READ_DITHER_SUPPORTED #ifdef PNG_READ_QUANTIZE_SUPPORTED
if (png_ptr->transformations & PNG_DITHER) if (png_ptr->transformations & PNG_QUANTIZE)
{ {
if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) || if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
(info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) && (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&
@ -1451,13 +1451,13 @@ png_do_read_transformations(png_structp png_ptr)
png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1); png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1);
#endif #endif
#ifdef PNG_READ_DITHER_SUPPORTED #ifdef PNG_READ_QUANTIZE_SUPPORTED
if (png_ptr->transformations & PNG_DITHER) if (png_ptr->transformations & PNG_QUANTIZE)
{ {
png_do_dither((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1, png_do_quantize((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1,
png_ptr->palette_lookup, png_ptr->dither_index); png_ptr->palette_lookup, png_ptr->quantize_index);
if (png_ptr->row_info.rowbytes == (png_uint_32)0) if (png_ptr->row_info.rowbytes == (png_uint_32)0)
png_error(png_ptr, "png_do_dither returned rowbytes=0"); png_error(png_ptr, "png_do_quantize returned rowbytes=0");
} }
#endif #endif
@ -3790,16 +3790,16 @@ png_do_expand(png_row_infop row_info, png_bytep row,
} }
#endif #endif
#ifdef PNG_READ_DITHER_SUPPORTED #ifdef PNG_READ_QUANTIZE_SUPPORTED
void /* PRIVATE */ void /* PRIVATE */
png_do_dither(png_row_infop row_info, png_bytep row, png_do_quantize(png_row_infop row_info, png_bytep row,
png_bytep palette_lookup, png_bytep dither_lookup) png_bytep palette_lookup, png_bytep quantize_lookup)
{ {
png_bytep sp, dp; png_bytep sp, dp;
png_uint_32 i; png_uint_32 i;
png_uint_32 row_width=row_info->width; png_uint_32 row_width=row_info->width;
png_debug(1, "in png_do_dither"); png_debug(1, "in png_do_quantize");
{ {
if (row_info->color_type == PNG_COLOR_TYPE_RGB && if (row_info->color_type == PNG_COLOR_TYPE_RGB &&
@ -3821,14 +3821,14 @@ png_do_dither(png_row_infop row_info, png_bytep row,
* (((g >> 3) & 0x1f) << 5) | * (((g >> 3) & 0x1f) << 5) |
* ((b >> 3) & 0x1f); * ((b >> 3) & 0x1f);
*/ */
p = (((r >> (8 - PNG_DITHER_RED_BITS)) & p = (((r >> (8 - PNG_QUANTIZE_RED_BITS)) &
((1 << PNG_DITHER_RED_BITS) - 1)) << ((1 << PNG_QUANTIZE_RED_BITS) - 1)) <<
(PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) | (PNG_QUANTIZE_GREEN_BITS + PNG_QUANTIZE_BLUE_BITS)) |
(((g >> (8 - PNG_DITHER_GREEN_BITS)) & (((g >> (8 - PNG_QUANTIZE_GREEN_BITS)) &
((1 << PNG_DITHER_GREEN_BITS) - 1)) << ((1 << PNG_QUANTIZE_GREEN_BITS) - 1)) <<
(PNG_DITHER_BLUE_BITS)) | (PNG_QUANTIZE_BLUE_BITS)) |
((b >> (8 - PNG_DITHER_BLUE_BITS)) & ((b >> (8 - PNG_QUANTIZE_BLUE_BITS)) &
((1 << PNG_DITHER_BLUE_BITS) - 1)); ((1 << PNG_QUANTIZE_BLUE_BITS) - 1));
*dp++ = palette_lookup[p]; *dp++ = palette_lookup[p];
} }
@ -3850,14 +3850,14 @@ png_do_dither(png_row_infop row_info, png_bytep row,
b = *sp++; b = *sp++;
sp++; sp++;
p = (((r >> (8 - PNG_DITHER_RED_BITS)) & p = (((r >> (8 - PNG_QUANTIZE_RED_BITS)) &
((1 << PNG_DITHER_RED_BITS) - 1)) << ((1 << PNG_QUANTIZE_RED_BITS) - 1)) <<
(PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) | (PNG_QUANTIZE_GREEN_BITS + PNG_QUANTIZE_BLUE_BITS)) |
(((g >> (8 - PNG_DITHER_GREEN_BITS)) & (((g >> (8 - PNG_QUANTIZE_GREEN_BITS)) &
((1 << PNG_DITHER_GREEN_BITS) - 1)) << ((1 << PNG_QUANTIZE_GREEN_BITS) - 1)) <<
(PNG_DITHER_BLUE_BITS)) | (PNG_QUANTIZE_BLUE_BITS)) |
((b >> (8 - PNG_DITHER_BLUE_BITS)) & ((b >> (8 - PNG_QUANTIZE_BLUE_BITS)) &
((1 << PNG_DITHER_BLUE_BITS) - 1)); ((1 << PNG_QUANTIZE_BLUE_BITS) - 1));
*dp++ = palette_lookup[p]; *dp++ = palette_lookup[p];
} }
@ -3867,12 +3867,12 @@ png_do_dither(png_row_infop row_info, png_bytep row,
row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);
} }
else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE && else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE &&
dither_lookup && row_info->bit_depth == 8) quantize_lookup && row_info->bit_depth == 8)
{ {
sp = row; sp = row;
for (i = 0; i < row_width; i++, sp++) for (i = 0; i < row_width; i++, sp++)
{ {
*sp = dither_lookup[*sp]; *sp = quantize_lookup[*sp];
} }
} }
} }

123
GRRLIB/lib/png/pngrutil.c
View file

@ -203,7 +203,7 @@ png_crc_error(png_structp png_ptr)
defined(PNG_READ_iCCP_SUPPORTED) defined(PNG_READ_iCCP_SUPPORTED)
static png_size_t static png_size_t
png_inflate(png_structp png_ptr, const png_byte *data, png_size_t size, png_inflate(png_structp png_ptr, const png_byte *data, png_size_t size,
png_bytep output, png_size_t output_size) png_bytep output, png_size_t output_size)
{ {
png_size_t count = 0; png_size_t count = 0;
@ -229,11 +229,11 @@ png_inflate(png_structp png_ptr, const png_byte *data, png_size_t size,
if ((ret == Z_OK || ret == Z_STREAM_END) && avail > 0) if ((ret == Z_OK || ret == Z_STREAM_END) && avail > 0)
{ {
if (output != 0 && output_size > count) if (output != 0 && output_size > count)
{ {
int copy = output_size - count; int copy = output_size - count;
if (avail < copy) copy = avail; if (avail < copy) copy = avail;
png_memcpy(output + count, png_ptr->zbuf, copy); png_memcpy(output + count, png_ptr->zbuf, copy);
} }
count += avail; count += avail;
} }
@ -254,31 +254,33 @@ png_inflate(png_structp png_ptr, const png_byte *data, png_size_t size,
* buffer if available. * buffer if available.
*/ */
{ {
char *msg, umsg[52]; char *msg;
if (png_ptr->zstream.msg != 0) if (png_ptr->zstream.msg != 0)
msg = png_ptr->zstream.msg; msg = png_ptr->zstream.msg;
else else
{ {
#ifdef PNG_STDIO_SUPPORTED #ifdef PNG_STDIO_SUPPORTED
switch (ret) char umsg[52];
{
case Z_BUF_ERROR:
msg = "Buffer error in compressed datastream in %s chunk";
break;
case Z_DATA_ERROR:
msg = "Data error in compressed datastream in %s chunk";
break;
default:
msg = "Incomplete compressed datastream in %s chunk";
break;
}
png_snprintf(umsg, sizeof umsg, msg, png_ptr->chunk_name); switch (ret)
msg = umsg; {
case Z_BUF_ERROR:
msg = "Buffer error in compressed datastream in %s chunk";
break;
case Z_DATA_ERROR:
msg = "Data error in compressed datastream in %s chunk";
break;
default:
msg = "Incomplete compressed datastream in %s chunk";
break;
}
png_snprintf(umsg, sizeof umsg, msg, png_ptr->chunk_name);
msg = umsg;
#else #else
msg = "Damaged compressed datastream in chunk other than IDAT"; msg = "Damaged compressed datastream in chunk other than IDAT";
#endif #endif
} }
png_warning(png_ptr, msg); png_warning(png_ptr, msg);
} }
@ -313,9 +315,9 @@ png_decompress_chunk(png_structp png_ptr, int comp_type,
else if (comp_type == PNG_COMPRESSION_TYPE_BASE) else if (comp_type == PNG_COMPRESSION_TYPE_BASE)
{ {
png_size_t expanded_size = png_inflate(png_ptr, png_size_t expanded_size = png_inflate(png_ptr,
(png_bytep)(png_ptr->chunkdata + prefix_size), (png_bytep)(png_ptr->chunkdata + prefix_size),
chunklength - prefix_size, chunklength - prefix_size,
0/*output*/, 0/*output size*/); 0/*output*/, 0/*output size*/);
/* Now check the limits on this chunk - if the limit fails the /* Now check the limits on this chunk - if the limit fails the
* compressed data will be removed, the prefix will remain. * compressed data will be removed, the prefix will remain.
@ -334,44 +336,49 @@ png_decompress_chunk(png_structp png_ptr, int comp_type,
* and we have nothing to do - the code will exit through the * and we have nothing to do - the code will exit through the
* error case below. * error case below.
*/ */
else if (expanded_size > 0) #if defined(PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED) || \
defined(PNG_USER_CHUNK_MALLOC_MAX)
else
#endif
if (expanded_size > 0)
{ {
/* Success (maybe) - really uncompress the chunk. */ /* Success (maybe) - really uncompress the chunk. */
png_size_t new_size = 0; png_size_t new_size = 0;
png_charp text = png_malloc_warn(png_ptr, png_charp text = png_malloc_warn(png_ptr,
prefix_size + expanded_size + 1); prefix_size + expanded_size + 1);
if (text != NULL) if (text != NULL)
{ {
png_memcpy(text, png_ptr->chunkdata, prefix_size); png_memcpy(text, png_ptr->chunkdata, prefix_size);
new_size = png_inflate(png_ptr, new_size = png_inflate(png_ptr,
(png_bytep)(png_ptr->chunkdata + prefix_size), (png_bytep)(png_ptr->chunkdata + prefix_size),
chunklength - prefix_size, chunklength - prefix_size,
(png_bytep)(text + prefix_size), expanded_size); (png_bytep)(text + prefix_size), expanded_size);
text[prefix_size + expanded_size] = 0; /* just in case */ text[prefix_size + expanded_size] = 0; /* just in case */
if (new_size == expanded_size) if (new_size == expanded_size)
{ {
png_free(png_ptr, png_ptr->chunkdata); png_free(png_ptr, png_ptr->chunkdata);
png_ptr->chunkdata = text; png_ptr->chunkdata = text;
*newlength = prefix_size + expanded_size; *newlength = prefix_size + expanded_size;
return; /* The success return! */ return; /* The success return! */
} }
png_warning(png_ptr, "png_inflate logic error"); png_warning(png_ptr, "png_inflate logic error");
png_free(png_ptr, text); png_free(png_ptr, text);
} }
else else
png_warning(png_ptr, "Not enough memory to decompress chunk"); png_warning(png_ptr, "Not enough memory to decompress chunk");
} }
} }
else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */ else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */
{ {
#ifdef PNG_STDIO_SUPPORTED
char umsg[50]; char umsg[50];
#ifdef PNG_STDIO_SUPPORTED png_snprintf(umsg, sizeof umsg, "Unknown zTXt compression type %d",
png_snprintf(umsg, sizeof umsg, "Unknown zTXt compression type %d", comp_type); comp_type);
png_warning(png_ptr, umsg); png_warning(png_ptr, umsg);
#else #else
png_warning(png_ptr, "Unknown zTXt compression type"); png_warning(png_ptr, "Unknown zTXt compression type");
@ -388,13 +395,13 @@ png_decompress_chunk(png_structp png_ptr, int comp_type,
png_charp text = png_malloc_warn(png_ptr, prefix_size + 1); png_charp text = png_malloc_warn(png_ptr, prefix_size + 1);
if (text != NULL) if (text != NULL)
{ {
if (prefix_size > 0) if (prefix_size > 0)
png_memcpy(text, png_ptr->chunkdata, prefix_size); png_memcpy(text, png_ptr->chunkdata, prefix_size);
png_free(png_ptr, png_ptr->chunkdata); png_free(png_ptr, png_ptr->chunkdata);
png_ptr->chunkdata = text; png_ptr->chunkdata = text;
/* This is an extra zero in the 'uncompressed' part. */ /* This is an extra zero in the 'uncompressed' part. */
*(png_ptr->chunkdata + prefix_size) = 0x00; *(png_ptr->chunkdata + prefix_size) = 0x00;
} }
/* Ignore a malloc error here - it is safe. */ /* Ignore a malloc error here - it is safe. */
} }
@ -890,9 +897,11 @@ png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
green_x, green_y, blue_x, blue_y); green_x, green_y, blue_x, blue_y);
#else #else
fprintf(stderr, "wx=%ld, wy=%ld, rx=%ld, ry=%ld\n", fprintf(stderr, "wx=%ld, wy=%ld, rx=%ld, ry=%ld\n",
int_x_white, int_y_white, int_x_red, int_y_red); (long)int_x_white, (long)int_y_white,
(long)int_x_red, (long)int_y_red);
fprintf(stderr, "gx=%ld, gy=%ld, bx=%ld, by=%ld\n", fprintf(stderr, "gx=%ld, gy=%ld, bx=%ld, by=%ld\n",
int_x_green, int_y_green, int_x_blue, int_y_blue); (long)int_x_green, (long)int_y_green,
(long)int_x_blue, (long)int_y_blue);
#endif #endif
#endif /* PNG_CONSOLE_IO_SUPPORTED */ #endif /* PNG_CONSOLE_IO_SUPPORTED */
} }

5
GRRLIB/lib/png/pngtrans.c
View file

@ -1,7 +1,7 @@
/* pngtrans.c - transforms the data in a row (used by both readers and writers) /* pngtrans.c - transforms the data in a row (used by both readers and writers)
* *
* Last changed in libpng 1.4.0 [January 3, 2010] * Last changed in libpng 1.4.2 [April 29, 2010]
* Copyright (c) 1998-2010 Glenn Randers-Pehrson * Copyright (c) 1998-2010 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@ -655,7 +655,6 @@ png_set_user_transform_info(png_structp png_ptr, png_voidp
"This version of libpng does not support user transform info"); "This version of libpng does not support user transform info");
#endif #endif
} }
#endif
/* This function returns a pointer to the user_transform_ptr associated with /* This function returns a pointer to the user_transform_ptr associated with
* the user transform functions. The application should free any memory * the user transform functions. The application should free any memory
@ -673,4 +672,6 @@ png_get_user_transform_ptr(png_structp png_ptr)
return (NULL); return (NULL);
#endif #endif
} }
#endif /* PNG_READ_USER_TRANSFORM_SUPPORTED ||
PNG_WRITE_USER_TRANSFORM_SUPPORTED */
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

2
GRRLIB/lib/png/pngwio.c
View file

@ -155,7 +155,7 @@ png_default_flush(png_structp png_ptr)
* arguments a pointer to a png_struct. After a call to * arguments a pointer to a png_struct. After a call to
* the flush function, there should be no data in any buffers * the flush function, there should be no data in any buffers
* or pending transmission. If the output method doesn't do * or pending transmission. If the output method doesn't do
* any buffering of ouput, a function prototype must still be * any buffering of output, a function prototype must still be
* supplied although it doesn't have to do anything. If * supplied although it doesn't have to do anything. If
* PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile * PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile
* time, output_flush_fn will be ignored, although it must be * time, output_flush_fn will be ignored, although it must be