mirror of
https://github.com/GRRLIB/GRRLIB.git
synced 2024-11-22 15:02:20 +00:00
[CHG] libpng updated to version 1.4.2
This commit is contained in:
Crayon2000
parent
957e2fe2c0
commit
2ad5794867
11 changed files with 227 additions and 188 deletions
|
|
@ -1,7 +1,7 @@
|
|||
|
||||
/* 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
|
||||
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
|
||||
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
|
||||
|
|
@ -17,7 +17,7 @@
|
|||
#include "pngpriv.h"
|
||||
|
||||
/* 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
|
||||
* string defined in png.h.
|
||||
|
|
@ -551,13 +551,13 @@ png_get_copyright(png_structp png_ptr)
|
|||
#else
|
||||
#ifdef __STDC__
|
||||
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) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
|
||||
"Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
|
||||
PNG_STRING_NEWLINE);
|
||||
#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) 1996-1997 Andreas Dilger\
|
||||
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;
|
||||
}
|
||||
#endif
|
||||
#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
|
||||
|
||||
#ifdef PNG_READ_SUPPORTED
|
||||
/* This function, added to libpng-1.0.6g, is untested. */
|
||||
int PNGAPI
|
||||
png_reset_zstream(png_structp png_ptr)
|
||||
|
|
@ -631,7 +633,7 @@ png_reset_zstream(png_structp png_ptr)
|
|||
return Z_STREAM_ERROR;
|
||||
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 */
|
||||
png_uint_32 PNGAPI
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
|
||||
/* 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
|
||||
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
|
||||
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
|
||||
|
|
@ -11,7 +11,7 @@
|
|||
* 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.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.
|
||||
*
|
||||
* Note about libpng version numbers:
|
||||
|
|
@ -139,6 +139,9 @@
|
|||
* 1.4.1beta04-12 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.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
|
||||
* and minor numbers; the shared-library major version number will be
|
||||
|
|
@ -170,7 +173,7 @@
|
|||
*
|
||||
* 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
|
||||
* distributed according to the same disclaimer and license as libpng-1.2.5
|
||||
* with the following individual added to the list of Contributing Authors:
|
||||
|
|
@ -282,13 +285,13 @@
|
|||
* Y2K compliance in libpng:
|
||||
* =========================
|
||||
*
|
||||
* February 25, 2010
|
||||
* May 6, 2010
|
||||
*
|
||||
* 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.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.
|
||||
*
|
||||
* 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 */
|
||||
#define PNG_LIBPNG_VER_STRING "1.4.1"
|
||||
#define PNG_LIBPNG_VER_STRING "1.4.2"
|
||||
#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_DLLNUM 14
|
||||
|
|
@ -354,7 +357,7 @@
|
|||
/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */
|
||||
#define PNG_LIBPNG_VER_MAJOR 1
|
||||
#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
|
||||
* 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.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
|
||||
/* Include the compression library's header */
|
||||
|
|
@ -1332,13 +1335,13 @@ struct png_struct_def
|
|||
png_uint_16 offset_table_count_free PNG_DEPSTRUCT;
|
||||
#endif
|
||||
|
||||
#ifdef PNG_READ_DITHER_SUPPORTED
|
||||
png_bytep palette_lookup PNG_DEPSTRUCT; /* lookup table for dithering */
|
||||
png_bytep dither_index PNG_DEPSTRUCT; /* index translation for palette
|
||||
#ifdef PNG_READ_QUANTIZE_SUPPORTED
|
||||
png_bytep palette_lookup PNG_DEPSTRUCT; /* lookup table for quantizing */
|
||||
png_bytep quantize_index PNG_DEPSTRUCT; /* index translation for palette
|
||||
files */
|
||||
#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 */
|
||||
#endif
|
||||
|
||||
|
|
@ -1422,9 +1425,9 @@ struct png_struct_def
|
|||
png_bytep big_row_buf PNG_DEPSTRUCT; /* buffer to save current
|
||||
(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 */
|
||||
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
|
||||
index currently is
|
||||
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
|
||||
* 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;
|
||||
|
||||
|
|
@ -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,
|
||||
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. */
|
||||
extern PNG_EXPORT(png_structp,png_create_read_struct)
|
||||
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)
|
||||
#endif
|
||||
|
||||
#ifdef PNG_READ_SUPPORTED
|
||||
/* Reset the compression stream */
|
||||
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) */
|
||||
#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));
|
||||
#endif
|
||||
|
||||
#ifdef PNG_READ_DITHER_SUPPORTED
|
||||
/* Turn on dithering, and reduce the palette to the number of colors
|
||||
* available.
|
||||
#ifdef PNG_READ_QUANTIZE_SUPPORTED
|
||||
/* Turn on quantizing, and reduce the palette to the number of colors
|
||||
* 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_uint_16p histogram, int full_dither));
|
||||
png_uint_16p histogram, int full_quantize));
|
||||
#endif
|
||||
/* This migration aid will be removed from libpng-1.5.0 */
|
||||
#define png_set_dither png_set_quantize
|
||||
|
||||
#ifdef PNG_READ_GAMMA_SUPPORTED
|
||||
/* Handle gamma correction. Screen_gamma=(display_exponent) */
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
|
||||
/* 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
|
||||
* Copyright (c) 1998-2010 Glenn Randers-Pehrson
|
||||
* (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. */
|
||||
|
||||
/* 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
|
||||
* 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
|
||||
#ifndef PNG_DITHER_GREEN_BITS
|
||||
# define PNG_DITHER_GREEN_BITS 5
|
||||
#ifdef PNG_DITHER_GREEN_BITS
|
||||
# define PNG_QUANTIZE_GREEN_BITS PNG_DITHER_GREEN_BITS
|
||||
#endif
|
||||
#ifndef PNG_DITHER_BLUE_BITS
|
||||
# define PNG_DITHER_BLUE_BITS 5
|
||||
#ifdef PNG_DITHER_BLUE_BITS
|
||||
# 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
|
||||
|
||||
/* This controls how fine the gamma correction becomes when you
|
||||
|
|
@ -499,11 +513,12 @@
|
|||
# ifndef PNG_NO_READ_INVERT
|
||||
# define PNG_READ_INVERT_SUPPORTED
|
||||
# endif
|
||||
#if 0 /* removed from libpng-1.4.0 */
|
||||
# ifndef PNG_NO_READ_DITHER
|
||||
# define PNG_READ_DITHER_SUPPORTED
|
||||
# ifndef PNG_NO_READ_QUANTIZE
|
||||
/* Prior to libpng-1.4.0 this was PNG_READ_DITHER_SUPPORTED */
|
||||
# ifndef PNG_NO_READ_DITHER /* This migration aid will be removed */
|
||||
# define PNG_READ_QUANTIZE_SUPPORTED
|
||||
# endif
|
||||
# endif
|
||||
#endif /* 0 */
|
||||
# ifndef PNG_NO_READ_BACKGROUND
|
||||
# define PNG_READ_BACKGROUND_SUPPORTED
|
||||
# endif
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
|
||||
/* 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
|
||||
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
|
||||
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
|
||||
/* 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
|
||||
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
|
||||
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
|
||||
/* 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
|
||||
* Copyright (c) 1998-2010 Glenn Randers-Pehrson
|
||||
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
|
||||
|
|
@ -106,7 +106,7 @@
|
|||
#define PNG_SHIFT 0x0008
|
||||
#define PNG_SWAP_BYTES 0x0010
|
||||
#define PNG_INVERT_MONO 0x0020
|
||||
#define PNG_DITHER 0x0040
|
||||
#define PNG_QUANTIZE 0x0040 /* formerly PNG_DITHER */
|
||||
#define PNG_BACKGROUND 0x0080
|
||||
#define PNG_BACKGROUND_EXPAND 0x0100
|
||||
/* 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));
|
||||
#endif
|
||||
|
||||
#ifdef PNG_READ_DITHER_SUPPORTED
|
||||
PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info,
|
||||
png_bytep row, png_bytep palette_lookup, png_bytep dither_lookup));
|
||||
#ifdef PNG_READ_QUANTIZE_SUPPORTED
|
||||
PNG_EXTERN void png_do_quantize PNGARG((png_row_infop row_info,
|
||||
png_bytep row, png_bytep palette_lookup, png_bytep quantize_lookup));
|
||||
|
||||
# ifdef PNG_CORRECT_PALETTE_SUPPORTED
|
||||
PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr,
|
||||
|
|
|
|||
|
|
@ -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->prev_row);
|
||||
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->dither_index);
|
||||
png_free(png_ptr, png_ptr->quantize_index);
|
||||
#endif
|
||||
#ifdef PNG_READ_GAMMA_SUPPORTED
|
||||
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);
|
||||
#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
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
|
||||
/* 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
|
||||
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
|
||||
* (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
|
||||
|
||||
#ifdef PNG_READ_DITHER_SUPPORTED
|
||||
/* Dither file to 8 bit. Supply a palette, the current number
|
||||
#ifdef PNG_READ_QUANTIZE_SUPPORTED
|
||||
/* Quantize file to 8 bit. Supply a palette, the current number
|
||||
* of elements in the palette, the maximum number of elements
|
||||
* allowed, and a histogram if possible. If the current number
|
||||
* of colors is greater then the maximum number, the palette will be
|
||||
* modified to fit in the maximum number. "full_dither" indicates
|
||||
* whether we need a dithering cube set up for RGB images, or if we
|
||||
* modified to fit in the maximum number. "full_quantize" indicates
|
||||
* 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.
|
||||
*/
|
||||
|
||||
|
|
@ -161,24 +161,24 @@ typedef png_dsort FAR * png_dsortp;
|
|||
typedef png_dsort FAR * FAR * png_dsortpp;
|
||||
|
||||
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 full_dither)
|
||||
int full_quantize)
|
||||
{
|
||||
png_debug(1, "in png_set_dither");
|
||||
png_debug(1, "in png_set_quantize");
|
||||
|
||||
if (png_ptr == NULL)
|
||||
return;
|
||||
png_ptr->transformations |= PNG_DITHER;
|
||||
png_ptr->transformations |= PNG_QUANTIZE;
|
||||
|
||||
if (!full_dither)
|
||||
if (!full_quantize)
|
||||
{
|
||||
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)));
|
||||
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)
|
||||
|
|
@ -192,12 +192,12 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
|
|||
int i;
|
||||
|
||||
/* 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)));
|
||||
|
||||
/* Initialize the dither_sort array */
|
||||
/* Initialize the quantize_sort array */
|
||||
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
|
||||
* 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;
|
||||
for (j = 0; j < i; j++)
|
||||
{
|
||||
if (histogram[png_ptr->dither_sort[j]]
|
||||
< histogram[png_ptr->dither_sort[j + 1]])
|
||||
if (histogram[png_ptr->quantize_sort[j]]
|
||||
< histogram[png_ptr->quantize_sort[j + 1]])
|
||||
{
|
||||
png_byte t;
|
||||
|
||||
t = png_ptr->dither_sort[j];
|
||||
png_ptr->dither_sort[j] = png_ptr->dither_sort[j + 1];
|
||||
png_ptr->dither_sort[j + 1] = t;
|
||||
t = png_ptr->quantize_sort[j];
|
||||
png_ptr->quantize_sort[j] = png_ptr->quantize_sort[j + 1];
|
||||
png_ptr->quantize_sort[j + 1] = t;
|
||||
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 */
|
||||
if (full_dither)
|
||||
if (full_quantize)
|
||||
{
|
||||
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++)
|
||||
{
|
||||
if ((int)png_ptr->dither_sort[i] >= maximum_colors)
|
||||
if ((int)png_ptr->quantize_sort[i] >= maximum_colors)
|
||||
{
|
||||
do
|
||||
j--;
|
||||
while ((int)png_ptr->dither_sort[j] >= maximum_colors);
|
||||
while ((int)png_ptr->quantize_sort[j] >= maximum_colors);
|
||||
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++)
|
||||
{
|
||||
/* 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;
|
||||
|
||||
do
|
||||
j--;
|
||||
while ((int)png_ptr->dither_sort[j] >= maximum_colors);
|
||||
while ((int)png_ptr->quantize_sort[j] >= maximum_colors);
|
||||
|
||||
tmp_color = palette[j];
|
||||
palette[j] = palette[i];
|
||||
palette[i] = tmp_color;
|
||||
/* Indicate where the color went */
|
||||
png_ptr->dither_index[j] = (png_byte)i;
|
||||
png_ptr->dither_index[i] = (png_byte)j;
|
||||
png_ptr->quantize_index[j] = (png_byte)i;
|
||||
png_ptr->quantize_index[i] = (png_byte)j;
|
||||
}
|
||||
}
|
||||
|
||||
/* Find closest color for those colors we are not using */
|
||||
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;
|
||||
|
||||
/* 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]);
|
||||
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 */
|
||||
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_ptr->dither_sort = NULL;
|
||||
png_free(png_ptr, png_ptr->quantize_sort);
|
||||
png_ptr->quantize_sort = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -410,19 +410,19 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
|
|||
num_new_palette--;
|
||||
palette[png_ptr->index_to_palette[j]]
|
||||
= palette[num_new_palette];
|
||||
if (!full_dither)
|
||||
if (!full_quantize)
|
||||
{
|
||||
int 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->dither_index[k] =
|
||||
png_ptr->quantize_index[k] =
|
||||
png_ptr->index_to_palette[next_j];
|
||||
if ((int)png_ptr->dither_index[k] ==
|
||||
if ((int)png_ptr->quantize_index[k] ==
|
||||
num_new_palette)
|
||||
png_ptr->dither_index[k] =
|
||||
png_ptr->quantize_index[k] =
|
||||
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;
|
||||
|
||||
if (full_dither)
|
||||
if (full_quantize)
|
||||
{
|
||||
int i;
|
||||
png_bytep distance;
|
||||
int total_bits = PNG_DITHER_RED_BITS + PNG_DITHER_GREEN_BITS +
|
||||
PNG_DITHER_BLUE_BITS;
|
||||
int num_red = (1 << PNG_DITHER_RED_BITS);
|
||||
int num_green = (1 << PNG_DITHER_GREEN_BITS);
|
||||
int num_blue = (1 << PNG_DITHER_BLUE_BITS);
|
||||
int total_bits = PNG_QUANTIZE_RED_BITS + PNG_QUANTIZE_GREEN_BITS +
|
||||
PNG_QUANTIZE_BLUE_BITS;
|
||||
int num_red = (1 << PNG_QUANTIZE_RED_BITS);
|
||||
int num_green = (1 << PNG_QUANTIZE_GREEN_BITS);
|
||||
int num_blue = (1 << PNG_QUANTIZE_BLUE_BITS);
|
||||
png_size_t num_entries = ((png_size_t)1 << total_bits);
|
||||
|
||||
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++)
|
||||
{
|
||||
int ir, ig, ib;
|
||||
int r = (palette[i].red >> (8 - PNG_DITHER_RED_BITS));
|
||||
int g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS));
|
||||
int b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS));
|
||||
int r = (palette[i].red >> (8 - PNG_QUANTIZE_RED_BITS));
|
||||
int g = (palette[i].green >> (8 - PNG_QUANTIZE_GREEN_BITS));
|
||||
int b = (palette[i].blue >> (8 - PNG_QUANTIZE_BLUE_BITS));
|
||||
|
||||
for (ir = 0; ir < num_red; ir++)
|
||||
{
|
||||
/* int dr = abs(ir - r); */
|
||||
int dr = ((ir > r) ? ir - r : r - ir);
|
||||
int index_r = (ir << (PNG_DITHER_BLUE_BITS +
|
||||
PNG_DITHER_GREEN_BITS));
|
||||
int index_r = (ir << (PNG_QUANTIZE_BLUE_BITS +
|
||||
PNG_QUANTIZE_GREEN_BITS));
|
||||
|
||||
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 dt = 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++)
|
||||
{
|
||||
|
|
@ -536,7 +536,7 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
|
|||
png_free(png_ptr, distance);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#endif /* PNG_READ_QUANTIZE_SUPPORTED */
|
||||
|
||||
#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
|
||||
/* 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;
|
||||
#endif
|
||||
|
||||
#ifdef PNG_READ_DITHER_SUPPORTED
|
||||
if (png_ptr->transformations & PNG_DITHER)
|
||||
#ifdef PNG_READ_QUANTIZE_SUPPORTED
|
||||
if (png_ptr->transformations & PNG_QUANTIZE)
|
||||
{
|
||||
if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
|
||||
(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);
|
||||
#endif
|
||||
|
||||
#ifdef PNG_READ_DITHER_SUPPORTED
|
||||
if (png_ptr->transformations & PNG_DITHER)
|
||||
#ifdef PNG_READ_QUANTIZE_SUPPORTED
|
||||
if (png_ptr->transformations & PNG_QUANTIZE)
|
||||
{
|
||||
png_do_dither((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1,
|
||||
png_ptr->palette_lookup, png_ptr->dither_index);
|
||||
png_do_quantize((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1,
|
||||
png_ptr->palette_lookup, png_ptr->quantize_index);
|
||||
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
|
||||
|
||||
|
|
@ -3790,16 +3790,16 @@ png_do_expand(png_row_infop row_info, png_bytep row,
|
|||
}
|
||||
#endif
|
||||
|
||||
#ifdef PNG_READ_DITHER_SUPPORTED
|
||||
#ifdef PNG_READ_QUANTIZE_SUPPORTED
|
||||
void /* PRIVATE */
|
||||
png_do_dither(png_row_infop row_info, png_bytep row,
|
||||
png_bytep palette_lookup, png_bytep dither_lookup)
|
||||
png_do_quantize(png_row_infop row_info, png_bytep row,
|
||||
png_bytep palette_lookup, png_bytep quantize_lookup)
|
||||
{
|
||||
png_bytep sp, dp;
|
||||
png_uint_32 i;
|
||||
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 &&
|
||||
|
|
@ -3821,14 +3821,14 @@ png_do_dither(png_row_infop row_info, png_bytep row,
|
|||
* (((g >> 3) & 0x1f) << 5) |
|
||||
* ((b >> 3) & 0x1f);
|
||||
*/
|
||||
p = (((r >> (8 - PNG_DITHER_RED_BITS)) &
|
||||
((1 << PNG_DITHER_RED_BITS) - 1)) <<
|
||||
(PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |
|
||||
(((g >> (8 - PNG_DITHER_GREEN_BITS)) &
|
||||
((1 << PNG_DITHER_GREEN_BITS) - 1)) <<
|
||||
(PNG_DITHER_BLUE_BITS)) |
|
||||
((b >> (8 - PNG_DITHER_BLUE_BITS)) &
|
||||
((1 << PNG_DITHER_BLUE_BITS) - 1));
|
||||
p = (((r >> (8 - PNG_QUANTIZE_RED_BITS)) &
|
||||
((1 << PNG_QUANTIZE_RED_BITS) - 1)) <<
|
||||
(PNG_QUANTIZE_GREEN_BITS + PNG_QUANTIZE_BLUE_BITS)) |
|
||||
(((g >> (8 - PNG_QUANTIZE_GREEN_BITS)) &
|
||||
((1 << PNG_QUANTIZE_GREEN_BITS) - 1)) <<
|
||||
(PNG_QUANTIZE_BLUE_BITS)) |
|
||||
((b >> (8 - PNG_QUANTIZE_BLUE_BITS)) &
|
||||
((1 << PNG_QUANTIZE_BLUE_BITS) - 1));
|
||||
|
||||
*dp++ = palette_lookup[p];
|
||||
}
|
||||
|
|
@ -3850,14 +3850,14 @@ png_do_dither(png_row_infop row_info, png_bytep row,
|
|||
b = *sp++;
|
||||
sp++;
|
||||
|
||||
p = (((r >> (8 - PNG_DITHER_RED_BITS)) &
|
||||
((1 << PNG_DITHER_RED_BITS) - 1)) <<
|
||||
(PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |
|
||||
(((g >> (8 - PNG_DITHER_GREEN_BITS)) &
|
||||
((1 << PNG_DITHER_GREEN_BITS) - 1)) <<
|
||||
(PNG_DITHER_BLUE_BITS)) |
|
||||
((b >> (8 - PNG_DITHER_BLUE_BITS)) &
|
||||
((1 << PNG_DITHER_BLUE_BITS) - 1));
|
||||
p = (((r >> (8 - PNG_QUANTIZE_RED_BITS)) &
|
||||
((1 << PNG_QUANTIZE_RED_BITS) - 1)) <<
|
||||
(PNG_QUANTIZE_GREEN_BITS + PNG_QUANTIZE_BLUE_BITS)) |
|
||||
(((g >> (8 - PNG_QUANTIZE_GREEN_BITS)) &
|
||||
((1 << PNG_QUANTIZE_GREEN_BITS) - 1)) <<
|
||||
(PNG_QUANTIZE_BLUE_BITS)) |
|
||||
((b >> (8 - PNG_QUANTIZE_BLUE_BITS)) &
|
||||
((1 << PNG_QUANTIZE_BLUE_BITS) - 1));
|
||||
|
||||
*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);
|
||||
}
|
||||
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;
|
||||
for (i = 0; i < row_width; i++, sp++)
|
||||
{
|
||||
*sp = dither_lookup[*sp];
|
||||
*sp = quantize_lookup[*sp];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -254,12 +254,14 @@ png_inflate(png_structp png_ptr, const png_byte *data, png_size_t size,
|
|||
* buffer if available.
|
||||
*/
|
||||
{
|
||||
char *msg, umsg[52];
|
||||
char *msg;
|
||||
if (png_ptr->zstream.msg != 0)
|
||||
msg = png_ptr->zstream.msg;
|
||||
else
|
||||
{
|
||||
#ifdef PNG_STDIO_SUPPORTED
|
||||
char umsg[52];
|
||||
|
||||
switch (ret)
|
||||
{
|
||||
case Z_BUF_ERROR:
|
||||
|
|
@ -334,7 +336,11 @@ png_decompress_chunk(png_structp png_ptr, int comp_type,
|
|||
* and we have nothing to do - the code will exit through the
|
||||
* 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. */
|
||||
png_size_t new_size = 0;
|
||||
|
|
@ -368,10 +374,11 @@ png_decompress_chunk(png_structp png_ptr, int comp_type,
|
|||
|
||||
else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */
|
||||
{
|
||||
#ifdef PNG_STDIO_SUPPORTED
|
||||
char umsg[50];
|
||||
|
||||
#ifdef PNG_STDIO_SUPPORTED
|
||||
png_snprintf(umsg, sizeof umsg, "Unknown zTXt compression type %d", comp_type);
|
||||
png_snprintf(umsg, sizeof umsg, "Unknown zTXt compression type %d",
|
||||
comp_type);
|
||||
png_warning(png_ptr, umsg);
|
||||
#else
|
||||
png_warning(png_ptr, "Unknown zTXt compression type");
|
||||
|
|
@ -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);
|
||||
#else
|
||||
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",
|
||||
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 /* PNG_CONSOLE_IO_SUPPORTED */
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
|
||||
/* 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
|
||||
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
|
||||
* (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");
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
/* This function returns a pointer to the user_transform_ptr associated with
|
||||
* 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);
|
||||
#endif
|
||||
}
|
||||
#endif /* PNG_READ_USER_TRANSFORM_SUPPORTED ||
|
||||
PNG_WRITE_USER_TRANSFORM_SUPPORTED */
|
||||
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
|
||||
|
|
|
|||
|
|
@ -155,7 +155,7 @@ png_default_flush(png_structp png_ptr)
|
|||
* arguments a pointer to a png_struct. After a call to
|
||||
* the flush function, there should be no data in any buffers
|
||||
* 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
|
||||
* PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile
|
||||
* time, output_flush_fn will be ignored, although it must be
|
||||
|
|
|
|||
Loading…
Reference in a new issue