updated libpng to 1.2.34
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28927 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
parent
f98eee6e83
commit
1ae36cc173
@ -1,6 +1,6 @@
|
||||
/* png.h - header file for PNG reference library
|
||||
*
|
||||
* libpng version 1.2.33 - October 31, 2008
|
||||
* libpng version 1.2.34 - December 18, 2008
|
||||
* Copyright (c) 1998-2008 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.)
|
||||
@ -8,7 +8,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.2.33 - October 31, 2008: Glenn
|
||||
* libpng versions 0.97, January 1998, through 1.2.34 - December 18, 2008: Glenn
|
||||
* See also "Contributing Authors", below.
|
||||
*
|
||||
* Note about libpng version numbers:
|
||||
@ -212,6 +212,11 @@
|
||||
* 1.0.41rc01 10 10041 10.so.0.41[.0]
|
||||
* 1.2.33 13 10233 12.so.0.33[.0]
|
||||
* 1.0.41 10 10041 10.so.0.41[.0]
|
||||
* 1.2.34beta01-07 13 10234 12.so.0.34[.0]
|
||||
* 1.0.42rc01 10 10042 10.so.0.42[.0]
|
||||
* 1.2.34rc01 13 10234 12.so.0.34[.0]
|
||||
* 1.0.42 10 10042 10.so.0.42[.0]
|
||||
* 1.2.34 13 10234 12.so.0.34[.0]
|
||||
*
|
||||
* Henceforth the source version will match the shared-library major
|
||||
* and minor numbers; the shared-library major version number will be
|
||||
@ -241,7 +246,7 @@
|
||||
* If you modify libpng you may insert additional notices immediately following
|
||||
* this sentence.
|
||||
*
|
||||
* libpng versions 1.2.6, August 15, 2004, through 1.2.33, October 31, 2008, are
|
||||
* libpng versions 1.2.6, August 15, 2004, through 1.2.34, December 18, 2008, are
|
||||
* Copyright (c) 2004, 2006-2008 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:
|
||||
@ -353,13 +358,13 @@
|
||||
* Y2K compliance in libpng:
|
||||
* =========================
|
||||
*
|
||||
* October 31, 2008
|
||||
* December 18, 2008
|
||||
*
|
||||
* 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.2.33 are Y2K compliant. It is my belief that earlier
|
||||
* upward through 1.2.34 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
|
||||
@ -415,9 +420,9 @@
|
||||
*/
|
||||
|
||||
/* Version information for png.h - this should match the version in png.c */
|
||||
#define PNG_LIBPNG_VER_STRING "1.2.33"
|
||||
#define PNG_LIBPNG_VER_STRING "1.2.34"
|
||||
#define PNG_HEADER_VERSION_STRING \
|
||||
" libpng version 1.2.33 - October 31, 2008\n"
|
||||
" libpng version 1.2.34 - December 18, 2008\n"
|
||||
|
||||
#define PNG_LIBPNG_VER_SONUM 0
|
||||
#define PNG_LIBPNG_VER_DLLNUM 13
|
||||
@ -425,7 +430,7 @@
|
||||
/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */
|
||||
#define PNG_LIBPNG_VER_MAJOR 1
|
||||
#define PNG_LIBPNG_VER_MINOR 2
|
||||
#define PNG_LIBPNG_VER_RELEASE 33
|
||||
#define PNG_LIBPNG_VER_RELEASE 34
|
||||
/* This should match the numeric part of the final component of
|
||||
* PNG_LIBPNG_VER_STRING, omitting any leading zero: */
|
||||
|
||||
@ -453,7 +458,7 @@
|
||||
* 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 10233 /* 1.2.33 */
|
||||
#define PNG_LIBPNG_VER 10234 /* 1.2.34 */
|
||||
|
||||
#ifndef PNG_VERSION_INFO_ONLY
|
||||
/* include the compression library's header */
|
||||
@ -1154,7 +1159,10 @@ typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp));
|
||||
#define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */
|
||||
#define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */
|
||||
#define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */
|
||||
#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* WRITE only */
|
||||
#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* WRITE only, deprecated */
|
||||
/* Added to libpng-1.2.34 */
|
||||
#define PNG_TRANSFORM_STRIP_FILLER_BEFORE 0x0800 /* WRITE only */
|
||||
#define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* WRITE only */
|
||||
|
||||
/* Flags for MNG supported features */
|
||||
#define PNG_FLAG_MNG_EMPTY_PLTE 0x01
|
||||
@ -1474,7 +1482,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_2_33;
|
||||
typedef png_structp version_1_2_34;
|
||||
|
||||
typedef png_struct FAR * FAR * png_structpp;
|
||||
|
||||
@ -2526,33 +2534,80 @@ extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr,
|
||||
#if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER)
|
||||
#include <crtdbg.h>
|
||||
#if (PNG_DEBUG > 1)
|
||||
#define png_debug(l,m) _RPT0(_CRT_WARN,m)
|
||||
#define png_debug1(l,m,p1) _RPT1(_CRT_WARN,m,p1)
|
||||
#define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m,p1,p2)
|
||||
#ifndef _DEBUG
|
||||
# define _DEBUG
|
||||
#endif
|
||||
#ifndef png_debug
|
||||
#define png_debug(l,m) _RPT0(_CRT_WARN,m PNG_STRING_NEWLINE)
|
||||
#endif
|
||||
#ifndef png_debug1
|
||||
#define png_debug1(l,m,p1) _RPT1(_CRT_WARN,m PNG_STRING_NEWLINE,p1)
|
||||
#endif
|
||||
#ifndef png_debug2
|
||||
#define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m PNG_STRING_NEWLINE,p1,p2)
|
||||
#endif
|
||||
#endif
|
||||
#else /* PNG_DEBUG_FILE || !_MSC_VER */
|
||||
#ifndef PNG_DEBUG_FILE
|
||||
#define PNG_DEBUG_FILE stderr
|
||||
#endif /* PNG_DEBUG_FILE */
|
||||
#if (PNG_DEBUG > 1)
|
||||
#ifndef png_debug
|
||||
/* Note: ["%s"m PNG_STRING_NEWLINE] probably does not work on
|
||||
* non-ISO compilers */
|
||||
#ifdef __STDC__
|
||||
#define png_debug(l,m) \
|
||||
{ \
|
||||
int num_tabs=l; \
|
||||
fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \
|
||||
fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \
|
||||
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \
|
||||
}
|
||||
#endif
|
||||
#ifndef png_debug1
|
||||
#define png_debug1(l,m,p1) \
|
||||
{ \
|
||||
int num_tabs=l; \
|
||||
fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \
|
||||
fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \
|
||||
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \
|
||||
}
|
||||
#endif
|
||||
#ifndef png_debug2
|
||||
#define png_debug2(l,m,p1,p2) \
|
||||
{ \
|
||||
int num_tabs=l; \
|
||||
fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \
|
||||
fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \
|
||||
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \
|
||||
}
|
||||
#endif
|
||||
#else /* __STDC __ */
|
||||
#ifndef png_debug
|
||||
#define png_debug(l,m) \
|
||||
int num_tabs=l; \
|
||||
char format[256]; \
|
||||
snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \
|
||||
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \
|
||||
m,PNG_STRING_NEWLINE); \
|
||||
fprintf(PNG_DEBUG_FILE,format);
|
||||
#endif
|
||||
#ifndef png_debug1
|
||||
#define png_debug1(l,m,p1) \
|
||||
int num_tabs=l; \
|
||||
char format[256]; \
|
||||
snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \
|
||||
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \
|
||||
m,PNG_STRING_NEWLINE); \
|
||||
fprintf(PNG_DEBUG_FILE,format,p1);
|
||||
#endif
|
||||
#ifndef png_debug2
|
||||
#define png_debug2(l,m,p1,p2) \
|
||||
int num_tabs=l; \
|
||||
char format[256]; \
|
||||
snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \
|
||||
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \
|
||||
m,PNG_STRING_NEWLINE); \
|
||||
fprintf(PNG_DEBUG_FILE,format,p1,p2);
|
||||
#endif
|
||||
#endif /* __STDC __ */
|
||||
#endif /* (PNG_DEBUG > 1) */
|
||||
#endif /* _MSC_VER */
|
||||
#endif /* (PNG_DEBUG > 0) */
|
||||
@ -3584,6 +3639,15 @@ png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type));
|
||||
/* Read the chunk header (length + type name) */
|
||||
PNG_EXTERN png_uint_32 png_read_chunk_header PNGARG((png_structp png_ptr));
|
||||
|
||||
/* Added at libpng version 1.2.34 */
|
||||
#if defined(PNG_cHRM_SUPPORTED)
|
||||
PNG_EXTERN int png_check_cHRM_fixed PNGARG((png_structp png_ptr,
|
||||
png_fixed_point int_white_x, png_fixed_point int_white_y,
|
||||
png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point
|
||||
int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,
|
||||
png_fixed_point int_blue_y));
|
||||
#endif
|
||||
|
||||
/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */
|
||||
|
||||
#endif /* PNG_INTERNAL */
|
||||
|
@ -1,7 +1,7 @@
|
||||
|
||||
/* pngconf.h - machine configurable file for libpng
|
||||
*
|
||||
* libpng version 1.2.33 - October 31, 2008
|
||||
* libpng version 1.2.34 - December 18, 2008
|
||||
* For conditions of distribution and use, see copyright notice in png.h
|
||||
* Copyright (c) 1998-2008 Glenn Randers-Pehrson
|
||||
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
|
||||
@ -798,6 +798,12 @@
|
||||
# define PNG_USER_HEIGHT_MAX 1000000L
|
||||
#endif
|
||||
|
||||
|
||||
/* Added at libpng-1.2.34 and 1.4.0 */
|
||||
#ifndef PNG_STRING_NEWLINE
|
||||
#define PNG_STRING_NEWLINE "\n"
|
||||
#endif
|
||||
|
||||
/* These are currently experimental features, define them if you want */
|
||||
|
||||
/* very little testing */
|
||||
|
@ -1,7 +1,7 @@
|
||||
|
||||
/* png.c - location for general purpose libpng functions
|
||||
*
|
||||
* Last changed in libpng 1.2.30 [August 15, 2008]
|
||||
* Last changed in libpng 1.2.34 [December 18, 2008]
|
||||
* For conditions of distribution and use, see copyright notice in png.h
|
||||
* Copyright (c) 1998-2008 Glenn Randers-Pehrson
|
||||
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
|
||||
@ -13,7 +13,7 @@
|
||||
#include "png.h"
|
||||
|
||||
/* Generate a compiler error if there is an old png.h in the search path. */
|
||||
typedef version_1_2_33 Your_png_h_is_not_version_1_2_33;
|
||||
typedef version_1_2_34 Your_png_h_is_not_version_1_2_34;
|
||||
|
||||
/* Version information for C files. This had better match the version
|
||||
* string defined in png.h. */
|
||||
@ -93,7 +93,7 @@ void PNGAPI
|
||||
png_set_sig_bytes(png_structp png_ptr, int num_bytes)
|
||||
{
|
||||
if (png_ptr == NULL) return;
|
||||
png_debug(1, "in png_set_sig_bytes\n");
|
||||
png_debug(1, "in png_set_sig_bytes");
|
||||
if (num_bytes > 8)
|
||||
png_error(png_ptr, "Too many bytes for PNG signature.");
|
||||
|
||||
@ -240,7 +240,7 @@ png_create_info_struct(png_structp png_ptr)
|
||||
{
|
||||
png_infop info_ptr;
|
||||
|
||||
png_debug(1, "in png_create_info_struct\n");
|
||||
png_debug(1, "in png_create_info_struct");
|
||||
if (png_ptr == NULL) return (NULL);
|
||||
#ifdef PNG_USER_MEM_SUPPORTED
|
||||
info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
|
||||
@ -265,7 +265,7 @@ png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
|
||||
png_infop info_ptr = NULL;
|
||||
if (png_ptr == NULL) return;
|
||||
|
||||
png_debug(1, "in png_destroy_info_struct\n");
|
||||
png_debug(1, "in png_destroy_info_struct");
|
||||
if (info_ptr_ptr != NULL)
|
||||
info_ptr = *info_ptr_ptr;
|
||||
|
||||
@ -304,7 +304,7 @@ png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)
|
||||
|
||||
if (info_ptr == NULL) return;
|
||||
|
||||
png_debug(1, "in png_info_init_3\n");
|
||||
png_debug(1, "in png_info_init_3");
|
||||
|
||||
if (png_sizeof(png_info) > png_info_struct_size)
|
||||
{
|
||||
@ -322,7 +322,7 @@ void PNGAPI
|
||||
png_data_freer(png_structp png_ptr, png_infop info_ptr,
|
||||
int freer, png_uint_32 mask)
|
||||
{
|
||||
png_debug(1, "in png_data_freer\n");
|
||||
png_debug(1, "in png_data_freer");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
if (freer == PNG_DESTROY_WILL_FREE_DATA)
|
||||
@ -339,7 +339,7 @@ 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");
|
||||
png_debug(1, "in png_free_data");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
|
||||
@ -593,7 +593,7 @@ if (mask & PNG_FREE_ROWS)
|
||||
void /* PRIVATE */
|
||||
png_info_destroy(png_structp png_ptr, png_infop info_ptr)
|
||||
{
|
||||
png_debug(1, "in png_info_destroy\n");
|
||||
png_debug(1, "in png_info_destroy");
|
||||
|
||||
png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
|
||||
|
||||
@ -632,7 +632,7 @@ png_get_io_ptr(png_structp png_ptr)
|
||||
void PNGAPI
|
||||
png_init_io(png_structp png_ptr, png_FILE_p fp)
|
||||
{
|
||||
png_debug(1, "in png_init_io\n");
|
||||
png_debug(1, "in png_init_io");
|
||||
if (png_ptr == NULL) return;
|
||||
png_ptr->io_ptr = (png_voidp)fp;
|
||||
}
|
||||
@ -694,7 +694,7 @@ png_charp PNGAPI
|
||||
png_get_copyright(png_structp png_ptr)
|
||||
{
|
||||
png_ptr = png_ptr; /* silence compiler warning about unused png_ptr */
|
||||
return ((png_charp) "\n libpng version 1.2.33 - October 31, 2008\n\
|
||||
return ((png_charp) "\n libpng version 1.2.34 - December 18, 2008\n\
|
||||
Copyright (c) 1998-2008 Glenn Randers-Pehrson\n\
|
||||
Copyright (c) 1996-1997 Andreas Dilger\n\
|
||||
Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n");
|
||||
@ -796,4 +796,116 @@ png_convert_size(size_t size)
|
||||
return ((png_size_t)size);
|
||||
}
|
||||
#endif /* PNG_SIZE_T */
|
||||
|
||||
/* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */
|
||||
#if defined(PNG_cHRM_SUPPORTED)
|
||||
#if !defined(PNG_NO_CHECK_cHRM)
|
||||
/*
|
||||
Multiply two 32-bit numbers, V1 and V2, using 32-bit
|
||||
arithmetic, to produce a 64 bit result in the HI/LO words.
|
||||
|
||||
A B
|
||||
x C D
|
||||
------
|
||||
AD || BD
|
||||
AC || CB || 0
|
||||
|
||||
where A and B are the high and low 16-bit words of V1,
|
||||
C and D are the 16-bit words of V2, AD is the product of
|
||||
A and D, and X || Y is (X << 16) + Y.
|
||||
*/
|
||||
|
||||
void png_64bit_product (long v1, long v2, unsigned long *hi_product,
|
||||
unsigned long *lo_product)
|
||||
{
|
||||
int a, b, c, d;
|
||||
long lo, hi, x, y;
|
||||
|
||||
a = (v1 >> 16) & 0xffff;
|
||||
b = v1 & 0xffff;
|
||||
c = (v2 >> 16) & 0xffff;
|
||||
d = v2 & 0xffff;
|
||||
|
||||
lo = b * d; /* BD */
|
||||
x = a * d + c * b; /* AD + CB */
|
||||
y = ((lo >> 16) & 0xffff) + x;
|
||||
|
||||
lo = (lo & 0xffff) | ((y & 0xffff) << 16);
|
||||
hi = (y >> 16) & 0xffff;
|
||||
|
||||
hi += a * c; /* AC */
|
||||
|
||||
*hi_product = (unsigned long)hi;
|
||||
*lo_product = (unsigned long)lo;
|
||||
}
|
||||
int /* private */
|
||||
png_check_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, png_fixed_point blue_y)
|
||||
{
|
||||
int ret = 1;
|
||||
unsigned long xy_hi,xy_lo,yx_hi,yx_lo;
|
||||
|
||||
png_debug(1, "in function png_check_cHRM_fixed");
|
||||
if (png_ptr == NULL)
|
||||
return 0;
|
||||
|
||||
if (white_x < 0 || white_y <= 0 ||
|
||||
red_x < 0 || red_y < 0 ||
|
||||
green_x < 0 || green_y < 0 ||
|
||||
blue_x < 0 || blue_y < 0)
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Ignoring attempt to set negative chromaticity value");
|
||||
ret = 0;
|
||||
}
|
||||
if (white_x > (png_fixed_point) PNG_UINT_31_MAX ||
|
||||
white_y > (png_fixed_point) PNG_UINT_31_MAX ||
|
||||
red_x > (png_fixed_point) PNG_UINT_31_MAX ||
|
||||
red_y > (png_fixed_point) PNG_UINT_31_MAX ||
|
||||
green_x > (png_fixed_point) PNG_UINT_31_MAX ||
|
||||
green_y > (png_fixed_point) PNG_UINT_31_MAX ||
|
||||
blue_x > (png_fixed_point) PNG_UINT_31_MAX ||
|
||||
blue_y > (png_fixed_point) PNG_UINT_31_MAX )
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Ignoring attempt to set chromaticity value exceeding 21474.83");
|
||||
ret = 0;
|
||||
}
|
||||
if (white_x > 100000L - white_y)
|
||||
{
|
||||
png_warning(png_ptr, "Invalid cHRM white point");
|
||||
ret = 0;
|
||||
}
|
||||
if (red_x > 100000L - red_y)
|
||||
{
|
||||
png_warning(png_ptr, "Invalid cHRM red point");
|
||||
ret = 0;
|
||||
}
|
||||
if (green_x > 100000L - green_y)
|
||||
{
|
||||
png_warning(png_ptr, "Invalid cHRM green point");
|
||||
ret = 0;
|
||||
}
|
||||
if (blue_x > 100000L - blue_y)
|
||||
{
|
||||
png_warning(png_ptr, "Invalid cHRM blue point");
|
||||
ret = 0;
|
||||
}
|
||||
|
||||
png_64bit_product(green_x - red_x, blue_y - red_y, &xy_hi, &xy_lo);
|
||||
png_64bit_product(green_y - red_y, blue_x - red_x, &yx_hi, &yx_lo);
|
||||
|
||||
if (xy_hi == yx_hi && xy_lo == yx_lo)
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Ignoring attempt to set cHRM RGB triangle with zero area");
|
||||
ret = 0;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
#endif /* NO_PNG_CHECK_cHRM */
|
||||
#endif /* PNG_cHRM_SUPPORTED */
|
||||
#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
|
||||
|
@ -1,7 +1,7 @@
|
||||
|
||||
/* pngerror.c - stub functions for i/o and memory allocation
|
||||
*
|
||||
* Last changed in libpng 1.2.30 [August 15, 2008]
|
||||
* Last changed in libpng 1.2.34 [December 18, 2008]
|
||||
* For conditions of distribution and use, see copyright notice in png.h
|
||||
* Copyright (c) 1998-2008 Glenn Randers-Pehrson
|
||||
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
|
||||
@ -116,9 +116,9 @@ png_warning(png_structp png_ptr, png_const_charp warning_message)
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (png_ptr != NULL && png_ptr->warning_fn != NULL)
|
||||
(*(png_ptr->warning_fn))(png_ptr, warning_message + offset);
|
||||
}
|
||||
if (png_ptr != NULL && png_ptr->warning_fn != NULL)
|
||||
(*(png_ptr->warning_fn))(png_ptr, warning_message + offset);
|
||||
else
|
||||
png_default_warning(png_ptr, warning_message + offset);
|
||||
}
|
||||
|
@ -120,7 +120,7 @@ png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
|
||||
#if defined(PNG_pHYs_SUPPORTED)
|
||||
if (info_ptr->valid & PNG_INFO_pHYs)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "png_get_x_pixels_per_meter");
|
||||
png_debug1(1, "in %s retrieval function", "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);
|
||||
@ -138,7 +138,7 @@ png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
|
||||
#if defined(PNG_pHYs_SUPPORTED)
|
||||
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", "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);
|
||||
@ -156,7 +156,7 @@ png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
|
||||
#if defined(PNG_pHYs_SUPPORTED)
|
||||
if (info_ptr->valid & PNG_INFO_pHYs)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "png_get_pixels_per_meter");
|
||||
png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");
|
||||
if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER ||
|
||||
info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit)
|
||||
return (0);
|
||||
@ -176,7 +176,7 @@ png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr)
|
||||
#if defined(PNG_pHYs_SUPPORTED)
|
||||
if (info_ptr->valid & PNG_INFO_pHYs)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "png_get_aspect_ratio");
|
||||
png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");
|
||||
if (info_ptr->x_pixels_per_unit == 0)
|
||||
return ((float)0.0);
|
||||
else
|
||||
@ -197,7 +197,7 @@ png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr)
|
||||
#if defined(PNG_oFFs_SUPPORTED)
|
||||
if (info_ptr->valid & PNG_INFO_oFFs)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns");
|
||||
png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
|
||||
if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
|
||||
return (0);
|
||||
else return (info_ptr->x_offset);
|
||||
@ -215,7 +215,7 @@ png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr)
|
||||
#if defined(PNG_oFFs_SUPPORTED)
|
||||
if (info_ptr->valid & PNG_INFO_oFFs)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns");
|
||||
png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
|
||||
if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
|
||||
return (0);
|
||||
else return (info_ptr->y_offset);
|
||||
@ -233,7 +233,7 @@ png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr)
|
||||
#if defined(PNG_oFFs_SUPPORTED)
|
||||
if (info_ptr->valid & PNG_INFO_oFFs)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns");
|
||||
png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
|
||||
if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
|
||||
return (0);
|
||||
else return (info_ptr->x_offset);
|
||||
@ -251,7 +251,7 @@ png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr)
|
||||
#if defined(PNG_oFFs_SUPPORTED)
|
||||
if (info_ptr->valid & PNG_INFO_oFFs)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns");
|
||||
png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
|
||||
if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
|
||||
return (0);
|
||||
else return (info_ptr->y_offset);
|
||||
@ -307,7 +307,7 @@ png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr,
|
||||
|
||||
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "pHYs");
|
||||
png_debug1(1, "in %s retrieval function", "pHYs");
|
||||
if (res_x != NULL)
|
||||
{
|
||||
*res_x = info_ptr->x_pixels_per_unit;
|
||||
@ -364,7 +364,7 @@ png_get_bKGD(png_structp png_ptr, png_infop info_ptr,
|
||||
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)
|
||||
&& background != NULL)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "bKGD");
|
||||
png_debug1(1, "in %s retrieval function", "bKGD");
|
||||
*background = &(info_ptr->background);
|
||||
return (PNG_INFO_bKGD);
|
||||
}
|
||||
@ -381,7 +381,7 @@ png_get_cHRM(png_structp png_ptr, png_infop info_ptr,
|
||||
{
|
||||
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "cHRM");
|
||||
png_debug1(1, "in %s retrieval function", "cHRM");
|
||||
if (white_x != NULL)
|
||||
*white_x = (double)info_ptr->x_white;
|
||||
if (white_y != NULL)
|
||||
@ -412,7 +412,7 @@ png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
|
||||
{
|
||||
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "cHRM");
|
||||
png_debug1(1, "in %s retrieval function", "cHRM");
|
||||
if (white_x != NULL)
|
||||
*white_x = info_ptr->int_x_white;
|
||||
if (white_y != NULL)
|
||||
@ -444,7 +444,7 @@ 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)
|
||||
&& file_gamma != NULL)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "gAMA");
|
||||
png_debug1(1, "in %s retrieval function", "gAMA");
|
||||
*file_gamma = (double)info_ptr->gamma;
|
||||
return (PNG_INFO_gAMA);
|
||||
}
|
||||
@ -459,7 +459,7 @@ png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr,
|
||||
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
|
||||
&& int_file_gamma != NULL)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "gAMA");
|
||||
png_debug1(1, "in %s retrieval function", "gAMA");
|
||||
*int_file_gamma = info_ptr->int_gamma;
|
||||
return (PNG_INFO_gAMA);
|
||||
}
|
||||
@ -475,7 +475,7 @@ 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)
|
||||
&& file_srgb_intent != NULL)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "sRGB");
|
||||
png_debug1(1, "in %s retrieval function", "sRGB");
|
||||
*file_srgb_intent = (int)info_ptr->srgb_intent;
|
||||
return (PNG_INFO_sRGB);
|
||||
}
|
||||
@ -492,7 +492,7 @@ png_get_iCCP(png_structp png_ptr, png_infop info_ptr,
|
||||
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)
|
||||
&& name != NULL && profile != NULL && proflen != NULL)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "iCCP");
|
||||
png_debug1(1, "in %s retrieval function", "iCCP");
|
||||
*name = info_ptr->iccp_name;
|
||||
*profile = info_ptr->iccp_profile;
|
||||
/* compression_type is a dummy so the API won't have to change
|
||||
@ -526,7 +526,7 @@ 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)
|
||||
&& hist != NULL)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "hIST");
|
||||
png_debug1(1, "in %s retrieval function", "hIST");
|
||||
*hist = info_ptr->hist;
|
||||
return (PNG_INFO_hIST);
|
||||
}
|
||||
@ -544,7 +544,7 @@ png_get_IHDR(png_structp png_ptr, png_infop info_ptr,
|
||||
if (png_ptr != NULL && info_ptr != NULL && width != NULL && height != NULL &&
|
||||
bit_depth != NULL && color_type != NULL)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "IHDR");
|
||||
png_debug1(1, "in %s retrieval function", "IHDR");
|
||||
*width = info_ptr->width;
|
||||
*height = info_ptr->height;
|
||||
*bit_depth = info_ptr->bit_depth;
|
||||
@ -588,7 +588,7 @@ png_get_oFFs(png_structp png_ptr, png_infop info_ptr,
|
||||
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)
|
||||
&& offset_x != NULL && offset_y != NULL && unit_type != NULL)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "oFFs");
|
||||
png_debug1(1, "in %s retrieval function", "oFFs");
|
||||
*offset_x = info_ptr->x_offset;
|
||||
*offset_y = info_ptr->y_offset;
|
||||
*unit_type = (int)info_ptr->offset_unit_type;
|
||||
@ -608,7 +608,7 @@ png_get_pCAL(png_structp png_ptr, png_infop info_ptr,
|
||||
&& purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
|
||||
nparams != NULL && units != NULL && params != NULL)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "pCAL");
|
||||
png_debug1(1, "in %s retrieval function", "pCAL");
|
||||
*purpose = info_ptr->pcal_purpose;
|
||||
*X0 = info_ptr->pcal_X0;
|
||||
*X1 = info_ptr->pcal_X1;
|
||||
@ -668,7 +668,7 @@ png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
|
||||
if (png_ptr != NULL && info_ptr != NULL &&
|
||||
(info_ptr->valid & PNG_INFO_pHYs))
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "pHYs");
|
||||
png_debug1(1, "in %s retrieval function", "pHYs");
|
||||
if (res_x != NULL)
|
||||
{
|
||||
*res_x = info_ptr->x_pixels_per_unit;
|
||||
@ -696,10 +696,10 @@ png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette,
|
||||
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)
|
||||
&& palette != NULL)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "PLTE");
|
||||
png_debug1(1, "in %s retrieval function", "PLTE");
|
||||
*palette = info_ptr->palette;
|
||||
*num_palette = info_ptr->num_palette;
|
||||
png_debug1(3, "num_palette = %d\n", *num_palette);
|
||||
png_debug1(3, "num_palette = %d", *num_palette);
|
||||
return (PNG_INFO_PLTE);
|
||||
}
|
||||
return (0);
|
||||
@ -712,7 +712,7 @@ 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)
|
||||
&& sig_bit != NULL)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "sBIT");
|
||||
png_debug1(1, "in %s retrieval function", "sBIT");
|
||||
*sig_bit = &(info_ptr->sig_bit);
|
||||
return (PNG_INFO_sBIT);
|
||||
}
|
||||
@ -727,7 +727,7 @@ png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,
|
||||
{
|
||||
if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n",
|
||||
png_debug1(1, "in %s retrieval function",
|
||||
(png_ptr->chunk_name[0] == '\0' ? "text"
|
||||
: (png_const_charp)png_ptr->chunk_name));
|
||||
if (text_ptr != NULL)
|
||||
@ -749,7 +749,7 @@ 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)
|
||||
&& mod_time != NULL)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "tIME");
|
||||
png_debug1(1, "in %s retrieval function", "tIME");
|
||||
*mod_time = &(info_ptr->mod_time);
|
||||
return (PNG_INFO_tIME);
|
||||
}
|
||||
@ -765,7 +765,7 @@ png_get_tRNS(png_structp png_ptr, png_infop info_ptr,
|
||||
png_uint_32 retval = 0;
|
||||
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "tRNS");
|
||||
png_debug1(1, "in %s retrieval function", "tRNS");
|
||||
if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
|
||||
{
|
||||
if (trans != NULL)
|
||||
|
@ -47,7 +47,7 @@ png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
|
||||
|
||||
int i;
|
||||
|
||||
png_debug(1, "in png_create_read_struct\n");
|
||||
png_debug(1, "in png_create_read_struct");
|
||||
#ifdef PNG_USER_MEM_SUPPORTED
|
||||
png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
|
||||
(png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);
|
||||
@ -263,7 +263,7 @@ png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
|
||||
}
|
||||
} while (png_libpng_ver[i++]);
|
||||
|
||||
png_debug(1, "in png_read_init_3\n");
|
||||
png_debug(1, "in png_read_init_3");
|
||||
|
||||
#ifdef PNG_SETJMP_SUPPORTED
|
||||
/* save jump buffer and error functions */
|
||||
@ -327,7 +327,7 @@ void PNGAPI
|
||||
png_read_info(png_structp png_ptr, png_infop info_ptr)
|
||||
{
|
||||
if (png_ptr == NULL || info_ptr == NULL) return;
|
||||
png_debug(1, "in png_read_info\n");
|
||||
png_debug(1, "in png_read_info");
|
||||
/* If we haven't checked all of the PNG signature bytes, do so now. */
|
||||
if (png_ptr->sig_bytes < 8)
|
||||
{
|
||||
@ -533,7 +533,7 @@ png_read_info(png_structp png_ptr, png_infop info_ptr)
|
||||
void PNGAPI
|
||||
png_read_update_info(png_structp png_ptr, png_infop info_ptr)
|
||||
{
|
||||
png_debug(1, "in png_read_update_info\n");
|
||||
png_debug(1, "in png_read_update_info");
|
||||
if (png_ptr == NULL) return;
|
||||
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
|
||||
png_read_start_row(png_ptr);
|
||||
@ -552,7 +552,7 @@ png_read_update_info(png_structp png_ptr, png_infop info_ptr)
|
||||
void PNGAPI
|
||||
png_start_read_image(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_start_read_image\n");
|
||||
png_debug(1, "in png_start_read_image");
|
||||
if (png_ptr == NULL) return;
|
||||
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
|
||||
png_read_start_row(png_ptr);
|
||||
@ -571,7 +571,7 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
|
||||
#endif
|
||||
int ret;
|
||||
if (png_ptr == NULL) return;
|
||||
png_debug2(1, "in png_read_row (row %lu, pass %d)\n",
|
||||
png_debug2(1, "in png_read_row (row %lu, pass %d)",
|
||||
png_ptr->row_number, png_ptr->pass);
|
||||
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
|
||||
png_read_start_row(png_ptr);
|
||||
@ -822,7 +822,7 @@ png_read_rows(png_structp png_ptr, png_bytepp row,
|
||||
png_bytepp rp;
|
||||
png_bytepp dp;
|
||||
|
||||
png_debug(1, "in png_read_rows\n");
|
||||
png_debug(1, "in png_read_rows");
|
||||
if (png_ptr == NULL) return;
|
||||
rp = row;
|
||||
dp = display_row;
|
||||
@ -871,7 +871,7 @@ png_read_image(png_structp png_ptr, png_bytepp image)
|
||||
int pass, j;
|
||||
png_bytepp rp;
|
||||
|
||||
png_debug(1, "in png_read_image\n");
|
||||
png_debug(1, "in png_read_image");
|
||||
if (png_ptr == NULL) return;
|
||||
|
||||
#ifdef PNG_READ_INTERLACING_SUPPORTED
|
||||
@ -907,7 +907,7 @@ png_read_image(png_structp png_ptr, png_bytepp image)
|
||||
void PNGAPI
|
||||
png_read_end(png_structp png_ptr, png_infop info_ptr)
|
||||
{
|
||||
png_debug(1, "in png_read_end\n");
|
||||
png_debug(1, "in png_read_end");
|
||||
if (png_ptr == NULL) return;
|
||||
png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */
|
||||
|
||||
@ -1087,7 +1087,7 @@ png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
|
||||
png_voidp mem_ptr = NULL;
|
||||
#endif
|
||||
|
||||
png_debug(1, "in png_destroy_read_struct\n");
|
||||
png_debug(1, "in png_destroy_read_struct");
|
||||
if (png_ptr_ptr != NULL)
|
||||
png_ptr = *png_ptr_ptr;
|
||||
if (png_ptr == NULL)
|
||||
@ -1161,7 +1161,7 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr
|
||||
png_free_ptr free_fn;
|
||||
#endif
|
||||
|
||||
png_debug(1, "in png_read_destroy\n");
|
||||
png_debug(1, "in png_read_destroy");
|
||||
if (info_ptr != NULL)
|
||||
png_info_destroy(png_ptr, info_ptr);
|
||||
|
||||
|
@ -27,7 +27,7 @@
|
||||
void /* PRIVATE */
|
||||
png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
|
||||
{
|
||||
png_debug1(4, "reading %d bytes\n", (int)length);
|
||||
png_debug1(4, "reading %d bytes", (int)length);
|
||||
if (png_ptr->read_data_fn != NULL)
|
||||
(*(png_ptr->read_data_fn))(png_ptr, data, length);
|
||||
else
|
||||
|
@ -21,7 +21,7 @@
|
||||
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");
|
||||
png_debug(1, "in png_set_crc_action");
|
||||
/* Tell libpng how we react to CRC errors in critical chunks */
|
||||
if (png_ptr == NULL) return;
|
||||
switch (crit_action)
|
||||
@ -80,7 +80,7 @@ png_set_background(png_structp png_ptr,
|
||||
png_color_16p background_color, int background_gamma_code,
|
||||
int need_expand, double background_gamma)
|
||||
{
|
||||
png_debug(1, "in png_set_background\n");
|
||||
png_debug(1, "in png_set_background");
|
||||
if (png_ptr == NULL) return;
|
||||
if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN)
|
||||
{
|
||||
@ -102,7 +102,7 @@ png_set_background(png_structp png_ptr,
|
||||
void PNGAPI
|
||||
png_set_strip_16(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_set_strip_16\n");
|
||||
png_debug(1, "in png_set_strip_16");
|
||||
if (png_ptr == NULL) return;
|
||||
png_ptr->transformations |= PNG_16_TO_8;
|
||||
}
|
||||
@ -112,7 +112,7 @@ png_set_strip_16(png_structp png_ptr)
|
||||
void PNGAPI
|
||||
png_set_strip_alpha(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_set_strip_alpha\n");
|
||||
png_debug(1, "in png_set_strip_alpha");
|
||||
if (png_ptr == NULL) return;
|
||||
png_ptr->flags |= PNG_FLAG_STRIP_ALPHA;
|
||||
}
|
||||
@ -142,7 +142,7 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
|
||||
int num_palette, int maximum_colors, png_uint_16p histogram,
|
||||
int full_dither)
|
||||
{
|
||||
png_debug(1, "in png_set_dither\n");
|
||||
png_debug(1, "in png_set_dither");
|
||||
if (png_ptr == NULL) return;
|
||||
png_ptr->transformations |= PNG_DITHER;
|
||||
|
||||
@ -526,7 +526,7 @@ png_set_dither(png_structp png_ptr, png_colorp palette,
|
||||
void PNGAPI
|
||||
png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)
|
||||
{
|
||||
png_debug(1, "in png_set_gamma\n");
|
||||
png_debug(1, "in png_set_gamma");
|
||||
if (png_ptr == NULL) return;
|
||||
if ((fabs(scrn_gamma * file_gamma - 1.0) > PNG_GAMMA_THRESHOLD) ||
|
||||
(png_ptr->color_type & PNG_COLOR_MASK_ALPHA) ||
|
||||
@ -545,7 +545,7 @@ png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)
|
||||
void PNGAPI
|
||||
png_set_expand(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_set_expand\n");
|
||||
png_debug(1, "in png_set_expand");
|
||||
if (png_ptr == NULL) return;
|
||||
png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
|
||||
png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
|
||||
@ -572,7 +572,7 @@ png_set_expand(png_structp png_ptr)
|
||||
void PNGAPI
|
||||
png_set_palette_to_rgb(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_set_palette_to_rgb\n");
|
||||
png_debug(1, "in png_set_palette_to_rgb");
|
||||
if (png_ptr == NULL) return;
|
||||
png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
|
||||
png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
|
||||
@ -583,7 +583,7 @@ png_set_palette_to_rgb(png_structp png_ptr)
|
||||
void PNGAPI
|
||||
png_set_expand_gray_1_2_4_to_8(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_set_expand_gray_1_2_4_to_8\n");
|
||||
png_debug(1, "in png_set_expand_gray_1_2_4_to_8");
|
||||
if (png_ptr == NULL) return;
|
||||
png_ptr->transformations |= PNG_EXPAND;
|
||||
png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
|
||||
@ -596,7 +596,7 @@ png_set_expand_gray_1_2_4_to_8(png_structp png_ptr)
|
||||
void PNGAPI
|
||||
png_set_gray_1_2_4_to_8(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_set_gray_1_2_4_to_8\n");
|
||||
png_debug(1, "in png_set_gray_1_2_4_to_8");
|
||||
if (png_ptr == NULL) return;
|
||||
png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
|
||||
}
|
||||
@ -607,7 +607,7 @@ png_set_gray_1_2_4_to_8(png_structp png_ptr)
|
||||
void PNGAPI
|
||||
png_set_tRNS_to_alpha(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_set_tRNS_to_alpha\n");
|
||||
png_debug(1, "in png_set_tRNS_to_alpha");
|
||||
png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
|
||||
png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
|
||||
}
|
||||
@ -617,7 +617,7 @@ png_set_tRNS_to_alpha(png_structp png_ptr)
|
||||
void PNGAPI
|
||||
png_set_gray_to_rgb(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_set_gray_to_rgb\n");
|
||||
png_debug(1, "in png_set_gray_to_rgb");
|
||||
png_ptr->transformations |= PNG_GRAY_TO_RGB;
|
||||
png_ptr->flags &= ~PNG_FLAG_ROW_INIT;
|
||||
}
|
||||
@ -644,7 +644,7 @@ void PNGAPI
|
||||
png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action,
|
||||
png_fixed_point red, png_fixed_point green)
|
||||
{
|
||||
png_debug(1, "in png_set_rgb_to_gray\n");
|
||||
png_debug(1, "in png_set_rgb_to_gray");
|
||||
if (png_ptr == NULL) return;
|
||||
switch(error_action)
|
||||
{
|
||||
@ -697,7 +697,7 @@ void PNGAPI
|
||||
png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
|
||||
read_user_transform_fn)
|
||||
{
|
||||
png_debug(1, "in png_set_read_user_transform_fn\n");
|
||||
png_debug(1, "in png_set_read_user_transform_fn");
|
||||
if (png_ptr == NULL) return;
|
||||
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
|
||||
png_ptr->transformations |= PNG_USER_TRANSFORM;
|
||||
@ -717,7 +717,7 @@ png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
|
||||
void /* PRIVATE */
|
||||
png_init_read_transformations(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_init_read_transformations\n");
|
||||
png_debug(1, "in png_init_read_transformations");
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
if (png_ptr != NULL)
|
||||
#endif
|
||||
@ -1124,7 +1124,7 @@ png_init_read_transformations(png_structp png_ptr)
|
||||
void /* PRIVATE */
|
||||
png_read_transform_info(png_structp png_ptr, png_infop info_ptr)
|
||||
{
|
||||
png_debug(1, "in png_read_transform_info\n");
|
||||
png_debug(1, "in png_read_transform_info");
|
||||
#if defined(PNG_READ_EXPAND_SUPPORTED)
|
||||
if (png_ptr->transformations & PNG_EXPAND)
|
||||
{
|
||||
@ -1268,7 +1268,7 @@ defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
|
||||
void /* PRIVATE */
|
||||
png_do_read_transformations(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_do_read_transformations\n");
|
||||
png_debug(1, "in png_do_read_transformations");
|
||||
if (png_ptr->row_buf == NULL)
|
||||
{
|
||||
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
|
||||
@ -1514,7 +1514,7 @@ From Andreas Dilger e-mail to png-implement, 26 March 1998:
|
||||
void /* PRIVATE */
|
||||
png_do_unpack(png_row_infop row_info, png_bytep row)
|
||||
{
|
||||
png_debug(1, "in png_do_unpack\n");
|
||||
png_debug(1, "in png_do_unpack");
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
if (row != NULL && row_info != NULL && row_info->bit_depth < 8)
|
||||
#else
|
||||
@ -1604,7 +1604,7 @@ png_do_unpack(png_row_infop row_info, png_bytep row)
|
||||
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");
|
||||
png_debug(1, "in png_do_unshift");
|
||||
if (
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
row != NULL && row_info != NULL && sig_bits != NULL &&
|
||||
@ -1710,7 +1710,7 @@ png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)
|
||||
void /* PRIVATE */
|
||||
png_do_chop(png_row_infop row_info, png_bytep row)
|
||||
{
|
||||
png_debug(1, "in png_do_chop\n");
|
||||
png_debug(1, "in png_do_chop");
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
if (row != NULL && row_info != NULL && row_info->bit_depth == 16)
|
||||
#else
|
||||
@ -1764,7 +1764,7 @@ png_do_chop(png_row_infop row_info, png_bytep row)
|
||||
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");
|
||||
png_debug(1, "in png_do_read_swap_alpha");
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
if (row != NULL && row_info != NULL)
|
||||
#endif
|
||||
@ -1856,7 +1856,7 @@ png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)
|
||||
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");
|
||||
png_debug(1, "in png_do_read_invert_alpha");
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
if (row != NULL && row_info != NULL)
|
||||
#endif
|
||||
@ -1962,7 +1962,7 @@ png_do_read_filler(png_row_infop row_info, png_bytep row,
|
||||
png_byte hi_filler = (png_byte)((filler>>8) & 0xff);
|
||||
png_byte lo_filler = (png_byte)(filler & 0xff);
|
||||
|
||||
png_debug(1, "in png_do_read_filler\n");
|
||||
png_debug(1, "in png_do_read_filler");
|
||||
if (
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
row != NULL && row_info != NULL &&
|
||||
@ -2134,7 +2134,7 @@ png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)
|
||||
png_uint_32 i;
|
||||
png_uint_32 row_width = row_info->width;
|
||||
|
||||
png_debug(1, "in png_do_gray_to_rgb\n");
|
||||
png_debug(1, "in png_do_gray_to_rgb");
|
||||
if (row_info->bit_depth >= 8 &&
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
row != NULL && row_info != NULL &&
|
||||
@ -2240,7 +2240,7 @@ png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row)
|
||||
png_uint_32 row_width = row_info->width;
|
||||
int rgb_error = 0;
|
||||
|
||||
png_debug(1, "in png_do_rgb_to_gray\n");
|
||||
png_debug(1, "in png_do_rgb_to_gray");
|
||||
if (
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
row != NULL && row_info != NULL &&
|
||||
@ -2478,7 +2478,7 @@ png_build_grayscale_palette(int bit_depth, png_colorp palette)
|
||||
int i;
|
||||
int v;
|
||||
|
||||
png_debug(1, "in png_do_build_grayscale_palette\n");
|
||||
png_debug(1, "in png_do_build_grayscale_palette");
|
||||
if (palette == NULL)
|
||||
return;
|
||||
|
||||
@ -2520,7 +2520,7 @@ void /* PRIVATE */
|
||||
png_correct_palette(png_structp png_ptr, png_colorp palette,
|
||||
int num_palette)
|
||||
{
|
||||
png_debug(1, "in png_correct_palette\n");
|
||||
png_debug(1, "in png_correct_palette");
|
||||
#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
|
||||
defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
|
||||
if (png_ptr->transformations & (PNG_GAMMA | PNG_BACKGROUND))
|
||||
@ -2717,7 +2717,7 @@ png_do_background(png_row_infop row_info, png_bytep row,
|
||||
png_uint_32 row_width=row_info->width;
|
||||
int shift;
|
||||
|
||||
png_debug(1, "in png_do_background\n");
|
||||
png_debug(1, "in png_do_background");
|
||||
if (background != NULL &&
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
row != NULL && row_info != NULL &&
|
||||
@ -3399,7 +3399,7 @@ png_do_gamma(png_row_infop row_info, png_bytep row,
|
||||
png_uint_32 i;
|
||||
png_uint_32 row_width=row_info->width;
|
||||
|
||||
png_debug(1, "in png_do_gamma\n");
|
||||
png_debug(1, "in png_do_gamma");
|
||||
if (
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
row != NULL && row_info != NULL &&
|
||||
@ -3581,7 +3581,7 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row,
|
||||
png_uint_32 i;
|
||||
png_uint_32 row_width=row_info->width;
|
||||
|
||||
png_debug(1, "in png_do_expand_palette\n");
|
||||
png_debug(1, "in png_do_expand_palette");
|
||||
if (
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
row != NULL && row_info != NULL &&
|
||||
@ -3724,7 +3724,7 @@ png_do_expand(png_row_infop row_info, png_bytep row,
|
||||
png_uint_32 i;
|
||||
png_uint_32 row_width=row_info->width;
|
||||
|
||||
png_debug(1, "in png_do_expand\n");
|
||||
png_debug(1, "in png_do_expand");
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
if (row != NULL && row_info != NULL)
|
||||
#endif
|
||||
@ -3930,7 +3930,7 @@ png_do_dither(png_row_infop row_info, png_bytep row,
|
||||
png_uint_32 i;
|
||||
png_uint_32 row_width=row_info->width;
|
||||
|
||||
png_debug(1, "in png_do_dither\n");
|
||||
png_debug(1, "in png_do_dither");
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
if (row != NULL && row_info != NULL)
|
||||
#endif
|
||||
@ -4025,7 +4025,7 @@ static PNG_CONST int png_gamma_shift[] =
|
||||
void /* PRIVATE */
|
||||
png_build_gamma_table(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_build_gamma_table\n");
|
||||
png_debug(1, "in png_build_gamma_table");
|
||||
|
||||
if (png_ptr->bit_depth <= 8)
|
||||
{
|
||||
@ -4238,7 +4238,7 @@ png_build_gamma_table(png_structp png_ptr)
|
||||
void /* PRIVATE */
|
||||
png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
|
||||
{
|
||||
png_debug(1, "in png_do_read_intrapixel\n");
|
||||
png_debug(1, "in png_do_read_intrapixel");
|
||||
if (
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
row != NULL && row_info != NULL &&
|
||||
|
@ -1,7 +1,7 @@
|
||||
|
||||
/* pngrutil.c - utilities to read a PNG file
|
||||
*
|
||||
* Last changed in libpng 1.2.33 [October 31, 2008]
|
||||
* Last changed in libpng 1.2.34 [December 18, 2008]
|
||||
* For conditions of distribution and use, see copyright notice in png.h
|
||||
* Copyright (c) 1998-2008 Glenn Randers-Pehrson
|
||||
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
|
||||
@ -115,7 +115,7 @@ png_read_chunk_header(png_structp png_ptr)
|
||||
/* put the chunk name into png_ptr->chunk_name */
|
||||
png_memcpy(png_ptr->chunk_name, buf + 4, 4);
|
||||
|
||||
png_debug2(0, "Reading %s chunk, length = %lu\n",
|
||||
png_debug2(0, "Reading %s chunk, length = %lu",
|
||||
png_ptr->chunk_name, length);
|
||||
|
||||
/* reset the crc and run it over the chunk name */
|
||||
@ -392,7 +392,7 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
int bit_depth, color_type, compression_type, filter_type;
|
||||
int interlace_type;
|
||||
|
||||
png_debug(1, "in png_handle_IHDR\n");
|
||||
png_debug(1, "in png_handle_IHDR");
|
||||
|
||||
if (png_ptr->mode & PNG_HAVE_IHDR)
|
||||
png_error(png_ptr, "Out of place IHDR");
|
||||
@ -447,9 +447,9 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *
|
||||
png_ptr->channels);
|
||||
png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width);
|
||||
png_debug1(3, "bit_depth = %d\n", png_ptr->bit_depth);
|
||||
png_debug1(3, "channels = %d\n", png_ptr->channels);
|
||||
png_debug1(3, "rowbytes = %lu\n", png_ptr->rowbytes);
|
||||
png_debug1(3, "bit_depth = %d", png_ptr->bit_depth);
|
||||
png_debug1(3, "channels = %d", png_ptr->channels);
|
||||
png_debug1(3, "rowbytes = %lu", png_ptr->rowbytes);
|
||||
png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
|
||||
color_type, interlace_type, compression_type, filter_type);
|
||||
}
|
||||
@ -464,7 +464,7 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
png_colorp pal_ptr;
|
||||
#endif
|
||||
|
||||
png_debug(1, "in png_handle_PLTE\n");
|
||||
png_debug(1, "in png_handle_PLTE");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR))
|
||||
png_error(png_ptr, "Missing IHDR before PLTE");
|
||||
@ -596,7 +596,7 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
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");
|
||||
png_debug(1, "in png_handle_IEND");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT))
|
||||
{
|
||||
@ -624,7 +624,7 @@ png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
#endif
|
||||
png_byte buf[4];
|
||||
|
||||
png_debug(1, "in png_handle_gAMA\n");
|
||||
png_debug(1, "in png_handle_gAMA");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR))
|
||||
png_error(png_ptr, "Missing IHDR before gAMA");
|
||||
@ -676,7 +676,7 @@ png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
png_warning(png_ptr,
|
||||
"Ignoring incorrect gAMA value when sRGB is also present");
|
||||
#ifndef PNG_NO_CONSOLE_IO
|
||||
fprintf(stderr, "gamma = (%d/100000)\n", (int)igamma);
|
||||
fprintf(stderr, "gamma = (%d/100000)", (int)igamma);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
@ -702,7 +702,7 @@ png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
png_size_t truelen;
|
||||
png_byte buf[4];
|
||||
|
||||
png_debug(1, "in png_handle_sBIT\n");
|
||||
png_debug(1, "in png_handle_sBIT");
|
||||
|
||||
buf[0] = buf[1] = buf[2] = buf[3] = 0;
|
||||
|
||||
@ -774,7 +774,7 @@ png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
|
||||
png_uint_32 uint_x, uint_y;
|
||||
|
||||
png_debug(1, "in png_handle_cHRM\n");
|
||||
png_debug(1, "in png_handle_cHRM");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR))
|
||||
png_error(png_ptr, "Missing IHDR before cHRM");
|
||||
@ -812,42 +812,21 @@ png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
|
||||
uint_x = png_get_uint_32(buf);
|
||||
uint_y = png_get_uint_32(buf + 4);
|
||||
if (uint_x > 80000L || uint_y > 80000L ||
|
||||
uint_x + uint_y > 100000L)
|
||||
{
|
||||
png_warning(png_ptr, "Invalid cHRM white point");
|
||||
return;
|
||||
}
|
||||
int_x_white = (png_fixed_point)uint_x;
|
||||
int_y_white = (png_fixed_point)uint_y;
|
||||
|
||||
uint_x = png_get_uint_32(buf + 8);
|
||||
uint_y = png_get_uint_32(buf + 12);
|
||||
if (uint_x + uint_y > 100000L)
|
||||
{
|
||||
png_warning(png_ptr, "Invalid cHRM red point");
|
||||
return;
|
||||
}
|
||||
int_x_red = (png_fixed_point)uint_x;
|
||||
int_y_red = (png_fixed_point)uint_y;
|
||||
|
||||
uint_x = png_get_uint_32(buf + 16);
|
||||
uint_y = png_get_uint_32(buf + 20);
|
||||
if (uint_x + uint_y > 100000L)
|
||||
{
|
||||
png_warning(png_ptr, "Invalid cHRM green point");
|
||||
return;
|
||||
}
|
||||
int_x_green = (png_fixed_point)uint_x;
|
||||
int_y_green = (png_fixed_point)uint_y;
|
||||
|
||||
uint_x = png_get_uint_32(buf + 24);
|
||||
uint_y = png_get_uint_32(buf + 28);
|
||||
if (uint_x + uint_y > 100000L)
|
||||
{
|
||||
png_warning(png_ptr, "Invalid cHRM blue point");
|
||||
return;
|
||||
}
|
||||
int_x_blue = (png_fixed_point)uint_x;
|
||||
int_y_blue = (png_fixed_point)uint_y;
|
||||
|
||||
@ -913,7 +892,7 @@ png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
int intent;
|
||||
png_byte buf[1];
|
||||
|
||||
png_debug(1, "in png_handle_sRGB\n");
|
||||
png_debug(1, "in png_handle_sRGB");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR))
|
||||
png_error(png_ptr, "Missing IHDR before sRGB");
|
||||
@ -1016,7 +995,7 @@ png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
png_uint_32 profile_size, profile_length;
|
||||
png_size_t slength, prefix_length, data_length;
|
||||
|
||||
png_debug(1, "in png_handle_iCCP\n");
|
||||
png_debug(1, "in png_handle_iCCP");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR))
|
||||
png_error(png_ptr, "Missing IHDR before iCCP");
|
||||
@ -1137,7 +1116,7 @@ png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
png_uint_32 skip = 0;
|
||||
png_size_t slength;
|
||||
|
||||
png_debug(1, "in png_handle_sPLT\n");
|
||||
png_debug(1, "in png_handle_sPLT");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR))
|
||||
png_error(png_ptr, "Missing IHDR before sPLT");
|
||||
@ -1273,7 +1252,7 @@ png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
{
|
||||
png_byte readbuf[PNG_MAX_PALETTE_LENGTH];
|
||||
|
||||
png_debug(1, "in png_handle_tRNS\n");
|
||||
png_debug(1, "in png_handle_tRNS");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR))
|
||||
png_error(png_ptr, "Missing IHDR before tRNS");
|
||||
@ -1369,7 +1348,7 @@ png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
png_size_t truelen;
|
||||
png_byte buf[6];
|
||||
|
||||
png_debug(1, "in png_handle_bKGD\n");
|
||||
png_debug(1, "in png_handle_bKGD");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR))
|
||||
png_error(png_ptr, "Missing IHDR before bKGD");
|
||||
@ -1420,7 +1399,7 @@ png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
png_ptr->background.index = buf[0];
|
||||
if (info_ptr && info_ptr->num_palette)
|
||||
{
|
||||
if (buf[0] > info_ptr->num_palette)
|
||||
if (buf[0] >= info_ptr->num_palette)
|
||||
{
|
||||
png_warning(png_ptr, "Incorrect bKGD chunk index value");
|
||||
return;
|
||||
@ -1458,7 +1437,7 @@ png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
unsigned int num, i;
|
||||
png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH];
|
||||
|
||||
png_debug(1, "in png_handle_hIST\n");
|
||||
png_debug(1, "in png_handle_hIST");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR))
|
||||
png_error(png_ptr, "Missing IHDR before hIST");
|
||||
@ -1513,7 +1492,7 @@ png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
png_uint_32 res_x, res_y;
|
||||
int unit_type;
|
||||
|
||||
png_debug(1, "in png_handle_pHYs\n");
|
||||
png_debug(1, "in png_handle_pHYs");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR))
|
||||
png_error(png_ptr, "Missing IHDR before pHYs");
|
||||
@ -1556,7 +1535,7 @@ png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
png_int_32 offset_x, offset_y;
|
||||
int unit_type;
|
||||
|
||||
png_debug(1, "in png_handle_oFFs\n");
|
||||
png_debug(1, "in png_handle_oFFs");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR))
|
||||
png_error(png_ptr, "Missing IHDR before oFFs");
|
||||
@ -1603,7 +1582,7 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
png_size_t slength;
|
||||
int i;
|
||||
|
||||
png_debug(1, "in png_handle_pCAL\n");
|
||||
png_debug(1, "in png_handle_pCAL");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR))
|
||||
png_error(png_ptr, "Missing IHDR before pCAL");
|
||||
@ -1620,7 +1599,7 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
return;
|
||||
}
|
||||
|
||||
png_debug1(2, "Allocating and reading pCAL chunk data (%lu bytes)\n",
|
||||
png_debug1(2, "Allocating and reading pCAL chunk data (%lu bytes)",
|
||||
length + 1);
|
||||
png_free(png_ptr, png_ptr->chunkdata);
|
||||
png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
|
||||
@ -1641,7 +1620,7 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
|
||||
png_ptr->chunkdata[slength] = 0x00; /* null terminate the last string */
|
||||
|
||||
png_debug(3, "Finding end of pCAL purpose string\n");
|
||||
png_debug(3, "Finding end of pCAL purpose string");
|
||||
for (buf = png_ptr->chunkdata; *buf; buf++)
|
||||
/* empty loop */ ;
|
||||
|
||||
@ -1657,14 +1636,14 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
return;
|
||||
}
|
||||
|
||||
png_debug(3, "Reading pCAL X0, X1, type, nparams, and units\n");
|
||||
png_debug(3, "Reading pCAL X0, X1, type, nparams, and units");
|
||||
X0 = png_get_int_32((png_bytep)buf+1);
|
||||
X1 = png_get_int_32((png_bytep)buf+5);
|
||||
type = buf[9];
|
||||
nparams = buf[10];
|
||||
units = buf + 11;
|
||||
|
||||
png_debug(3, "Checking pCAL equation type and number of parameters\n");
|
||||
png_debug(3, "Checking pCAL equation type and number of parameters");
|
||||
/* Check that we have the right number of parameters for known
|
||||
equation types. */
|
||||
if ((type == PNG_EQUATION_LINEAR && nparams != 2) ||
|
||||
@ -1685,7 +1664,7 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
for (buf = units; *buf; buf++)
|
||||
/* Empty loop to move past the units string. */ ;
|
||||
|
||||
png_debug(3, "Allocating pCAL parameters array\n");
|
||||
png_debug(3, "Allocating pCAL parameters array");
|
||||
params = (png_charpp)png_malloc_warn(png_ptr,
|
||||
(png_uint_32)(nparams * png_sizeof(png_charp))) ;
|
||||
if (params == NULL)
|
||||
@ -1701,7 +1680,7 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
{
|
||||
buf++; /* Skip the null string terminator from previous parameter. */
|
||||
|
||||
png_debug1(3, "Reading pCAL parameter %d\n", i);
|
||||
png_debug1(3, "Reading pCAL parameter %d", i);
|
||||
for (params[i] = buf; buf <= endptr && *buf != 0x00; buf++)
|
||||
/* Empty loop to move past each parameter string */ ;
|
||||
|
||||
@ -1741,7 +1720,7 @@ png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
#endif
|
||||
png_size_t slength;
|
||||
|
||||
png_debug(1, "in png_handle_sCAL\n");
|
||||
png_debug(1, "in png_handle_sCAL");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR))
|
||||
png_error(png_ptr, "Missing IHDR before sCAL");
|
||||
@ -1758,7 +1737,7 @@ png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
return;
|
||||
}
|
||||
|
||||
png_debug1(2, "Allocating and reading sCAL chunk data (%lu bytes)\n",
|
||||
png_debug1(2, "Allocating and reading sCAL chunk data (%lu bytes)",
|
||||
length + 1);
|
||||
png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);
|
||||
if (png_ptr->chunkdata == NULL)
|
||||
@ -1875,7 +1854,7 @@ png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
png_byte buf[7];
|
||||
png_time mod_time;
|
||||
|
||||
png_debug(1, "in png_handle_tIME\n");
|
||||
png_debug(1, "in png_handle_tIME");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR))
|
||||
png_error(png_ptr, "Out of place tIME chunk");
|
||||
@ -1923,7 +1902,7 @@ png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
png_size_t slength;
|
||||
int ret;
|
||||
|
||||
png_debug(1, "in png_handle_tEXt\n");
|
||||
png_debug(1, "in png_handle_tEXt");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR))
|
||||
png_error(png_ptr, "Missing IHDR before tEXt");
|
||||
@ -2006,7 +1985,7 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
int ret;
|
||||
png_size_t slength, prefix_len, data_len;
|
||||
|
||||
png_debug(1, "in png_handle_zTXt\n");
|
||||
png_debug(1, "in png_handle_zTXt");
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR))
|
||||
png_error(png_ptr, "Missing IHDR before zTXt");
|
||||
|
||||
@ -2109,7 +2088,7 @@ png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
int ret;
|
||||
png_size_t slength, prefix_len, data_len;
|
||||
|
||||
png_debug(1, "in png_handle_iTXt\n");
|
||||
png_debug(1, "in png_handle_iTXt");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR))
|
||||
png_error(png_ptr, "Missing IHDR before iTXt");
|
||||
@ -2235,7 +2214,7 @@ png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
{
|
||||
png_uint_32 skip = 0;
|
||||
|
||||
png_debug(1, "in png_handle_unknown\n");
|
||||
png_debug(1, "in png_handle_unknown");
|
||||
|
||||
if (png_ptr->mode & PNG_HAVE_IDAT)
|
||||
{
|
||||
@ -2330,7 +2309,7 @@ png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
void /* PRIVATE */
|
||||
png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name)
|
||||
{
|
||||
png_debug(1, "in png_check_chunk_name\n");
|
||||
png_debug(1, "in png_check_chunk_name");
|
||||
if (isnonalpha(chunk_name[0]) || isnonalpha(chunk_name[1]) ||
|
||||
isnonalpha(chunk_name[2]) || isnonalpha(chunk_name[3]))
|
||||
{
|
||||
@ -2352,7 +2331,7 @@ png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name)
|
||||
void /* PRIVATE */
|
||||
png_combine_row(png_structp png_ptr, png_bytep row, int mask)
|
||||
{
|
||||
png_debug(1, "in png_combine_row\n");
|
||||
png_debug(1, "in png_combine_row");
|
||||
if (mask == 0xff)
|
||||
{
|
||||
png_memcpy(row, png_ptr->row_buf + 1,
|
||||
@ -2568,7 +2547,7 @@ png_do_read_interlace(png_structp png_ptr)
|
||||
PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
|
||||
#endif
|
||||
|
||||
png_debug(1, "in png_do_read_interlace\n");
|
||||
png_debug(1, "in png_do_read_interlace");
|
||||
if (row != NULL && row_info != NULL)
|
||||
{
|
||||
png_uint_32 final_width;
|
||||
@ -2781,8 +2760,8 @@ void /* PRIVATE */
|
||||
png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
|
||||
png_bytep prev_row, int filter)
|
||||
{
|
||||
png_debug(1, "in png_read_filter_row\n");
|
||||
png_debug2(2, "row = %lu, filter = %d\n", png_ptr->row_number, filter);
|
||||
png_debug(1, "in png_read_filter_row");
|
||||
png_debug2(2, "row = %lu, filter = %d", png_ptr->row_number, filter);
|
||||
switch (filter)
|
||||
{
|
||||
case PNG_FILTER_VALUE_NONE:
|
||||
@ -2921,7 +2900,7 @@ png_read_finish_row(png_structp png_ptr)
|
||||
#endif /* PNG_READ_INTERLACING_SUPPORTED */
|
||||
#endif
|
||||
|
||||
png_debug(1, "in png_read_finish_row\n");
|
||||
png_debug(1, "in png_read_finish_row");
|
||||
png_ptr->row_number++;
|
||||
if (png_ptr->row_number < png_ptr->num_rows)
|
||||
return;
|
||||
@ -3056,7 +3035,7 @@ png_read_start_row(png_structp png_ptr)
|
||||
int max_pixel_depth;
|
||||
png_size_t row_bytes;
|
||||
|
||||
png_debug(1, "in png_read_start_row\n");
|
||||
png_debug(1, "in png_read_start_row");
|
||||
png_ptr->zstream.avail_in = 0;
|
||||
png_init_read_transformations(png_ptr);
|
||||
#ifdef PNG_READ_INTERLACING_SUPPORTED
|
||||
@ -3222,12 +3201,12 @@ defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
|
||||
|
||||
png_memset_check(png_ptr, png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
|
||||
|
||||
png_debug1(3, "width = %lu,\n", png_ptr->width);
|
||||
png_debug1(3, "height = %lu,\n", png_ptr->height);
|
||||
png_debug1(3, "iwidth = %lu,\n", png_ptr->iwidth);
|
||||
png_debug1(3, "num_rows = %lu\n", png_ptr->num_rows);
|
||||
png_debug1(3, "rowbytes = %lu,\n", png_ptr->rowbytes);
|
||||
png_debug1(3, "irowbytes = %lu,\n", png_ptr->irowbytes);
|
||||
png_debug1(3, "width = %lu,", png_ptr->width);
|
||||
png_debug1(3, "height = %lu,", png_ptr->height);
|
||||
png_debug1(3, "iwidth = %lu,", png_ptr->iwidth);
|
||||
png_debug1(3, "num_rows = %lu", png_ptr->num_rows);
|
||||
png_debug1(3, "rowbytes = %lu,", png_ptr->rowbytes);
|
||||
png_debug1(3, "irowbytes = %lu,", png_ptr->irowbytes);
|
||||
|
||||
png_ptr->flags |= PNG_FLAG_ROW_INIT;
|
||||
}
|
||||
|
@ -1,7 +1,7 @@
|
||||
|
||||
/* pngset.c - storage of image information into info struct
|
||||
*
|
||||
* Last changed in libpng 1.2.30 [August 15, 2008]
|
||||
* Last changed in libpng 1.2.34 [December 18, 2008]
|
||||
* For conditions of distribution and use, see copyright notice in png.h
|
||||
* Copyright (c) 1998-2008 Glenn Randers-Pehrson
|
||||
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
|
||||
@ -21,7 +21,7 @@
|
||||
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");
|
||||
png_debug1(1, "in %s storage function", "bKGD");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
|
||||
@ -37,34 +37,9 @@ 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)
|
||||
{
|
||||
png_debug1(1, "in %s storage function\n", "cHRM");
|
||||
png_debug1(1, "in %s storage function", "cHRM");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
if (!(white_x || white_y || red_x || red_y || green_x || green_y ||
|
||||
blue_x || blue_y))
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Ignoring attempt to set all-zero chromaticity values");
|
||||
return;
|
||||
}
|
||||
if (white_x < 0.0 || white_y < 0.0 ||
|
||||
red_x < 0.0 || red_y < 0.0 ||
|
||||
green_x < 0.0 || green_y < 0.0 ||
|
||||
blue_x < 0.0 || blue_y < 0.0)
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Ignoring attempt to set negative chromaticity value");
|
||||
return;
|
||||
}
|
||||
if (white_x > 21474.83 || white_y > 21474.83 ||
|
||||
red_x > 21474.83 || red_y > 21474.83 ||
|
||||
green_x > 21474.83 || green_y > 21474.83 ||
|
||||
blue_x > 21474.83 || blue_y > 21474.83)
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Ignoring attempt to set chromaticity value exceeding 21474.83");
|
||||
return;
|
||||
}
|
||||
|
||||
info_ptr->x_white = (float)white_x;
|
||||
info_ptr->y_white = (float)white_y;
|
||||
@ -94,61 +69,38 @@ png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
|
||||
png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,
|
||||
png_fixed_point blue_x, png_fixed_point blue_y)
|
||||
{
|
||||
png_debug1(1, "in %s storage function\n", "cHRM");
|
||||
png_debug1(1, "in %s storage function", "cHRM fixed");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
|
||||
if (!(white_x || white_y || red_x || red_y || green_x || green_y ||
|
||||
blue_x || blue_y))
|
||||
#if !defined(PNG_NO_CHECK_cHRM)
|
||||
if (png_check_cHRM_fixed(png_ptr,
|
||||
white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y))
|
||||
#endif
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Ignoring attempt to set all-zero chromaticity values");
|
||||
return;
|
||||
}
|
||||
if (white_x < 0 || white_y < 0 ||
|
||||
red_x < 0 || red_y < 0 ||
|
||||
green_x < 0 || green_y < 0 ||
|
||||
blue_x < 0 || blue_y < 0)
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Ignoring attempt to set negative chromaticity value");
|
||||
return;
|
||||
}
|
||||
if (white_x > (png_fixed_point) PNG_UINT_31_MAX ||
|
||||
white_y > (png_fixed_point) PNG_UINT_31_MAX ||
|
||||
red_x > (png_fixed_point) PNG_UINT_31_MAX ||
|
||||
red_y > (png_fixed_point) PNG_UINT_31_MAX ||
|
||||
green_x > (png_fixed_point) PNG_UINT_31_MAX ||
|
||||
green_y > (png_fixed_point) PNG_UINT_31_MAX ||
|
||||
blue_x > (png_fixed_point) PNG_UINT_31_MAX ||
|
||||
blue_y > (png_fixed_point) PNG_UINT_31_MAX )
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Ignoring attempt to set chromaticity value exceeding 21474.83");
|
||||
return;
|
||||
}
|
||||
info_ptr->int_x_white = white_x;
|
||||
info_ptr->int_y_white = white_y;
|
||||
info_ptr->int_x_red = red_x;
|
||||
info_ptr->int_y_red = red_y;
|
||||
info_ptr->int_x_green = green_x;
|
||||
info_ptr->int_y_green = green_y;
|
||||
info_ptr->int_x_blue = blue_x;
|
||||
info_ptr->int_y_blue = blue_y;
|
||||
info_ptr->int_x_white = white_x;
|
||||
info_ptr->int_y_white = white_y;
|
||||
info_ptr->int_x_red = red_x;
|
||||
info_ptr->int_y_red = red_y;
|
||||
info_ptr->int_x_green = green_x;
|
||||
info_ptr->int_y_green = green_y;
|
||||
info_ptr->int_x_blue = blue_x;
|
||||
info_ptr->int_y_blue = blue_y;
|
||||
#ifdef PNG_FLOATING_POINT_SUPPORTED
|
||||
info_ptr->x_white = (float)(white_x/100000.);
|
||||
info_ptr->y_white = (float)(white_y/100000.);
|
||||
info_ptr->x_red = (float)( red_x/100000.);
|
||||
info_ptr->y_red = (float)( red_y/100000.);
|
||||
info_ptr->x_green = (float)(green_x/100000.);
|
||||
info_ptr->y_green = (float)(green_y/100000.);
|
||||
info_ptr->x_blue = (float)( blue_x/100000.);
|
||||
info_ptr->y_blue = (float)( blue_y/100000.);
|
||||
info_ptr->x_white = (float)(white_x/100000.);
|
||||
info_ptr->y_white = (float)(white_y/100000.);
|
||||
info_ptr->x_red = (float)( red_x/100000.);
|
||||
info_ptr->y_red = (float)( red_y/100000.);
|
||||
info_ptr->x_green = (float)(green_x/100000.);
|
||||
info_ptr->y_green = (float)(green_y/100000.);
|
||||
info_ptr->x_blue = (float)( blue_x/100000.);
|
||||
info_ptr->y_blue = (float)( blue_y/100000.);
|
||||
#endif
|
||||
info_ptr->valid |= PNG_INFO_cHRM;
|
||||
info_ptr->valid |= PNG_INFO_cHRM;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
#endif /* PNG_FIXED_POINT_SUPPORTED */
|
||||
#endif /* PNG_cHRM_SUPPORTED */
|
||||
|
||||
#if defined(PNG_gAMA_SUPPORTED)
|
||||
#ifdef PNG_FLOATING_POINT_SUPPORTED
|
||||
@ -156,7 +108,7 @@ void PNGAPI
|
||||
png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)
|
||||
{
|
||||
double gamma;
|
||||
png_debug1(1, "in %s storage function\n", "gAMA");
|
||||
png_debug1(1, "in %s storage function", "gAMA");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
|
||||
@ -183,7 +135,7 @@ png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point
|
||||
{
|
||||
png_fixed_point gamma;
|
||||
|
||||
png_debug1(1, "in %s storage function\n", "gAMA");
|
||||
png_debug1(1, "in %s storage function", "gAMA");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
|
||||
@ -220,7 +172,7 @@ png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)
|
||||
{
|
||||
int i;
|
||||
|
||||
png_debug1(1, "in %s storage function\n", "hIST");
|
||||
png_debug1(1, "in %s storage function", "hIST");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
if (info_ptr->num_palette == 0 || info_ptr->num_palette
|
||||
@ -263,7 +215,7 @@ png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
|
||||
int color_type, int interlace_type, int compression_type,
|
||||
int filter_type)
|
||||
{
|
||||
png_debug1(1, "in %s storage function\n", "IHDR");
|
||||
png_debug1(1, "in %s storage function", "IHDR");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
|
||||
@ -370,7 +322,7 @@ 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)
|
||||
{
|
||||
png_debug1(1, "in %s storage function\n", "oFFs");
|
||||
png_debug1(1, "in %s storage function", "oFFs");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
|
||||
@ -390,12 +342,12 @@ png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
|
||||
png_uint_32 length;
|
||||
int i;
|
||||
|
||||
png_debug1(1, "in %s storage function\n", "pCAL");
|
||||
png_debug1(1, "in %s storage function", "pCAL");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
|
||||
length = png_strlen(purpose) + 1;
|
||||
png_debug1(3, "allocating purpose for info (%lu bytes)\n",
|
||||
png_debug1(3, "allocating purpose for info (%lu bytes)",
|
||||
(unsigned long)length);
|
||||
info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length);
|
||||
if (info_ptr->pcal_purpose == NULL)
|
||||
@ -405,14 +357,14 @@ png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
|
||||
}
|
||||
png_memcpy(info_ptr->pcal_purpose, purpose, (png_size_t)length);
|
||||
|
||||
png_debug(3, "storing X0, X1, type, and nparams in info\n");
|
||||
png_debug(3, "storing X0, X1, type, and nparams in info");
|
||||
info_ptr->pcal_X0 = X0;
|
||||
info_ptr->pcal_X1 = X1;
|
||||
info_ptr->pcal_type = (png_byte)type;
|
||||
info_ptr->pcal_nparams = (png_byte)nparams;
|
||||
|
||||
length = png_strlen(units) + 1;
|
||||
png_debug1(3, "allocating units for info (%lu bytes)\n",
|
||||
png_debug1(3, "allocating units for info (%lu bytes)",
|
||||
(unsigned long)length);
|
||||
info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length);
|
||||
if (info_ptr->pcal_units == NULL)
|
||||
@ -435,7 +387,7 @@ png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
|
||||
for (i = 0; i < nparams; i++)
|
||||
{
|
||||
length = png_strlen(params[i]) + 1;
|
||||
png_debug2(3, "allocating parameter %d for info (%lu bytes)\n", i,
|
||||
png_debug2(3, "allocating parameter %d for info (%lu bytes)", i,
|
||||
(unsigned long)length);
|
||||
info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length);
|
||||
if (info_ptr->pcal_params[i] == NULL)
|
||||
@ -459,7 +411,7 @@ void PNGAPI
|
||||
png_set_sCAL(png_structp png_ptr, png_infop info_ptr,
|
||||
int unit, double width, double height)
|
||||
{
|
||||
png_debug1(1, "in %s storage function\n", "sCAL");
|
||||
png_debug1(1, "in %s storage function", "sCAL");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
|
||||
@ -477,14 +429,14 @@ png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,
|
||||
{
|
||||
png_uint_32 length;
|
||||
|
||||
png_debug1(1, "in %s storage function\n", "sCAL");
|
||||
png_debug1(1, "in %s storage function", "sCAL");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
|
||||
info_ptr->scal_unit = (png_byte)unit;
|
||||
|
||||
length = png_strlen(swidth) + 1;
|
||||
png_debug1(3, "allocating unit for info (%u bytes)\n",
|
||||
png_debug1(3, "allocating unit for info (%u bytes)",
|
||||
(unsigned int)length);
|
||||
info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, length);
|
||||
if (info_ptr->scal_s_width == NULL)
|
||||
@ -496,7 +448,7 @@ png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,
|
||||
png_memcpy(info_ptr->scal_s_width, swidth, (png_size_t)length);
|
||||
|
||||
length = png_strlen(sheight) + 1;
|
||||
png_debug1(3, "allocating unit for info (%u bytes)\n",
|
||||
png_debug1(3, "allocating unit for info (%u bytes)",
|
||||
(unsigned int)length);
|
||||
info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, length);
|
||||
if (info_ptr->scal_s_height == NULL)
|
||||
@ -522,7 +474,7 @@ 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)
|
||||
{
|
||||
png_debug1(1, "in %s storage function\n", "pHYs");
|
||||
png_debug1(1, "in %s storage function", "pHYs");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
|
||||
@ -538,7 +490,7 @@ png_set_PLTE(png_structp png_ptr, png_infop info_ptr,
|
||||
png_colorp palette, int num_palette)
|
||||
{
|
||||
|
||||
png_debug1(1, "in %s storage function\n", "PLTE");
|
||||
png_debug1(1, "in %s storage function", "PLTE");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
|
||||
@ -587,7 +539,7 @@ void PNGAPI
|
||||
png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
|
||||
png_color_8p sig_bit)
|
||||
{
|
||||
png_debug1(1, "in %s storage function\n", "sBIT");
|
||||
png_debug1(1, "in %s storage function", "sBIT");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
|
||||
@ -600,7 +552,7 @@ png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
|
||||
void PNGAPI
|
||||
png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent)
|
||||
{
|
||||
png_debug1(1, "in %s storage function\n", "sRGB");
|
||||
png_debug1(1, "in %s storage function", "sRGB");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
|
||||
@ -624,12 +576,10 @@ png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
|
||||
#ifdef PNG_FLOATING_POINT_SUPPORTED
|
||||
float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
|
||||
#endif
|
||||
#ifdef PNG_FIXED_POINT_SUPPORTED
|
||||
png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
|
||||
int_green_y, int_blue_x, int_blue_y;
|
||||
#endif
|
||||
#endif
|
||||
png_debug1(1, "in %s storage function\n", "sRGB_gAMA_and_cHRM");
|
||||
png_debug1(1, "in %s storage function", "sRGB_gAMA_and_cHRM");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
|
||||
@ -647,7 +597,6 @@ png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
|
||||
#endif
|
||||
|
||||
#if defined(PNG_cHRM_SUPPORTED)
|
||||
#ifdef PNG_FIXED_POINT_SUPPORTED
|
||||
int_white_x = 31270L;
|
||||
int_white_y = 32900L;
|
||||
int_red_x = 64000L;
|
||||
@ -657,10 +606,6 @@ png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
|
||||
int_blue_x = 15000L;
|
||||
int_blue_y = 6000L;
|
||||
|
||||
png_set_cHRM_fixed(png_ptr, info_ptr,
|
||||
int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, int_green_y,
|
||||
int_blue_x, int_blue_y);
|
||||
#endif
|
||||
#ifdef PNG_FLOATING_POINT_SUPPORTED
|
||||
white_x = (float).3127;
|
||||
white_y = (float).3290;
|
||||
@ -670,11 +615,25 @@ png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
|
||||
green_y = (float).60;
|
||||
blue_x = (float).15;
|
||||
blue_y = (float).06;
|
||||
#endif
|
||||
|
||||
png_set_cHRM(png_ptr, info_ptr,
|
||||
white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
|
||||
#if !defined(PNG_NO_CHECK_cHRM)
|
||||
if (png_check_cHRM_fixed(png_ptr,
|
||||
int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
|
||||
int_green_y, int_blue_x, int_blue_y))
|
||||
#endif
|
||||
{
|
||||
#ifdef PNG_FIXED_POINT_SUPPORTED
|
||||
png_set_cHRM_fixed(png_ptr, info_ptr,
|
||||
int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
|
||||
int_green_y, int_blue_x, int_blue_y);
|
||||
#endif
|
||||
#ifdef PNG_FLOATING_POINT_SUPPORTED
|
||||
png_set_cHRM(png_ptr, info_ptr,
|
||||
white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
|
||||
#endif
|
||||
}
|
||||
#endif /* cHRM */
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -689,7 +648,7 @@ png_set_iCCP(png_structp png_ptr, png_infop info_ptr,
|
||||
png_charp new_iccp_profile;
|
||||
png_uint_32 length;
|
||||
|
||||
png_debug1(1, "in %s storage function\n", "iCCP");
|
||||
png_debug1(1, "in %s storage function", "iCCP");
|
||||
if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)
|
||||
return;
|
||||
|
||||
@ -743,7 +702,7 @@ png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
|
||||
{
|
||||
int i;
|
||||
|
||||
png_debug1(1, "in %s storage function\n", (png_ptr->chunk_name[0] == '\0' ?
|
||||
png_debug1(1, "in %s storage function", (png_ptr->chunk_name[0] == '\0' ?
|
||||
"text" : (png_const_charp)png_ptr->chunk_name));
|
||||
|
||||
if (png_ptr == NULL || info_ptr == NULL || num_text == 0)
|
||||
@ -785,7 +744,7 @@ png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
|
||||
info_ptr->free_me |= PNG_FREE_TEXT;
|
||||
#endif
|
||||
}
|
||||
png_debug1(3, "allocated %d entries for info_ptr->text\n",
|
||||
png_debug1(3, "allocated %d entries for info_ptr->text",
|
||||
info_ptr->max_text);
|
||||
}
|
||||
for (i = 0; i < num_text; i++)
|
||||
@ -845,7 +804,7 @@ png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
|
||||
(key_len + text_length + lang_len + lang_key_len + 4));
|
||||
if (textp->key == NULL)
|
||||
return(1);
|
||||
png_debug2(2, "Allocated %lu bytes at %x in png_set_text\n",
|
||||
png_debug2(2, "Allocated %lu bytes at %x in png_set_text",
|
||||
(png_uint_32)
|
||||
(key_len + lang_len + lang_key_len + text_length + 4),
|
||||
(int)textp->key);
|
||||
@ -893,7 +852,7 @@ png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
|
||||
#endif
|
||||
}
|
||||
info_ptr->num_text++;
|
||||
png_debug1(3, "transferred text chunk %d\n", info_ptr->num_text);
|
||||
png_debug1(3, "transferred text chunk %d", info_ptr->num_text);
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
@ -903,7 +862,7 @@ png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
|
||||
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");
|
||||
png_debug1(1, "in %s storage function", "tIME");
|
||||
if (png_ptr == NULL || info_ptr == NULL ||
|
||||
(png_ptr->mode & PNG_WROTE_tIME))
|
||||
return;
|
||||
@ -918,7 +877,7 @@ void PNGAPI
|
||||
png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
|
||||
png_bytep trans, int num_trans, png_color_16p trans_values)
|
||||
{
|
||||
png_debug1(1, "in %s storage function\n", "tRNS");
|
||||
png_debug1(1, "in %s storage function", "tRNS");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
|
||||
@ -1123,7 +1082,7 @@ png_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted)
|
||||
{
|
||||
/* This function is deprecated in favor of png_permit_mng_features()
|
||||
and will be removed from libpng-1.3.0 */
|
||||
png_debug(1, "in png_permit_empty_plte, DEPRECATED.\n");
|
||||
png_debug(1, "in png_permit_empty_plte, DEPRECATED.");
|
||||
if (png_ptr == NULL)
|
||||
return;
|
||||
png_ptr->mng_features_permitted = (png_byte)
|
||||
@ -1137,7 +1096,7 @@ png_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted)
|
||||
png_uint_32 PNGAPI
|
||||
png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features)
|
||||
{
|
||||
png_debug(1, "in png_permit_mng_features\n");
|
||||
png_debug(1, "in png_permit_mng_features");
|
||||
if (png_ptr == NULL)
|
||||
return (png_uint_32)0;
|
||||
png_ptr->mng_features_permitted =
|
||||
@ -1198,7 +1157,7 @@ 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)
|
||||
{
|
||||
png_debug(1, "in png_set_read_user_chunk_fn\n");
|
||||
png_debug(1, "in png_set_read_user_chunk_fn");
|
||||
if (png_ptr == NULL)
|
||||
return;
|
||||
png_ptr->read_user_chunk_fn = read_user_chunk_fn;
|
||||
@ -1210,7 +1169,7 @@ png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr,
|
||||
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");
|
||||
png_debug1(1, "in %s storage function", "rows");
|
||||
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
|
@ -17,7 +17,7 @@
|
||||
void PNGAPI
|
||||
png_set_bgr(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_set_bgr\n");
|
||||
png_debug(1, "in png_set_bgr");
|
||||
if (png_ptr == NULL) return;
|
||||
png_ptr->transformations |= PNG_BGR;
|
||||
}
|
||||
@ -28,7 +28,7 @@ png_set_bgr(png_structp png_ptr)
|
||||
void PNGAPI
|
||||
png_set_swap(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_set_swap\n");
|
||||
png_debug(1, "in png_set_swap");
|
||||
if (png_ptr == NULL) return;
|
||||
if (png_ptr->bit_depth == 16)
|
||||
png_ptr->transformations |= PNG_SWAP_BYTES;
|
||||
@ -40,7 +40,7 @@ png_set_swap(png_structp png_ptr)
|
||||
void PNGAPI
|
||||
png_set_packing(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_set_packing\n");
|
||||
png_debug(1, "in png_set_packing");
|
||||
if (png_ptr == NULL) return;
|
||||
if (png_ptr->bit_depth < 8)
|
||||
{
|
||||
@ -55,7 +55,7 @@ png_set_packing(png_structp png_ptr)
|
||||
void PNGAPI
|
||||
png_set_packswap(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_set_packswap\n");
|
||||
png_debug(1, "in png_set_packswap");
|
||||
if (png_ptr == NULL) return;
|
||||
if (png_ptr->bit_depth < 8)
|
||||
png_ptr->transformations |= PNG_PACKSWAP;
|
||||
@ -66,7 +66,7 @@ png_set_packswap(png_structp png_ptr)
|
||||
void PNGAPI
|
||||
png_set_shift(png_structp png_ptr, png_color_8p true_bits)
|
||||
{
|
||||
png_debug(1, "in png_set_shift\n");
|
||||
png_debug(1, "in png_set_shift");
|
||||
if (png_ptr == NULL) return;
|
||||
png_ptr->transformations |= PNG_SHIFT;
|
||||
png_ptr->shift = *true_bits;
|
||||
@ -78,7 +78,7 @@ png_set_shift(png_structp png_ptr, png_color_8p true_bits)
|
||||
int PNGAPI
|
||||
png_set_interlace_handling(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_set_interlace handling\n");
|
||||
png_debug(1, "in png_set_interlace handling");
|
||||
if (png_ptr && png_ptr->interlaced)
|
||||
{
|
||||
png_ptr->transformations |= PNG_INTERLACE;
|
||||
@ -98,7 +98,7 @@ png_set_interlace_handling(png_structp png_ptr)
|
||||
void PNGAPI
|
||||
png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
|
||||
{
|
||||
png_debug(1, "in png_set_filler\n");
|
||||
png_debug(1, "in png_set_filler");
|
||||
if (png_ptr == NULL) return;
|
||||
png_ptr->transformations |= PNG_FILLER;
|
||||
png_ptr->filler = (png_byte)filler;
|
||||
@ -131,7 +131,7 @@ png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
|
||||
void PNGAPI
|
||||
png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc)
|
||||
{
|
||||
png_debug(1, "in png_set_add_alpha\n");
|
||||
png_debug(1, "in png_set_add_alpha");
|
||||
if (png_ptr == NULL) return;
|
||||
png_set_filler(png_ptr, filler, filler_loc);
|
||||
png_ptr->transformations |= PNG_ADD_ALPHA;
|
||||
@ -145,7 +145,7 @@ png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc)
|
||||
void PNGAPI
|
||||
png_set_swap_alpha(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_set_swap_alpha\n");
|
||||
png_debug(1, "in png_set_swap_alpha");
|
||||
if (png_ptr == NULL) return;
|
||||
png_ptr->transformations |= PNG_SWAP_ALPHA;
|
||||
}
|
||||
@ -156,7 +156,7 @@ png_set_swap_alpha(png_structp png_ptr)
|
||||
void PNGAPI
|
||||
png_set_invert_alpha(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_set_invert_alpha\n");
|
||||
png_debug(1, "in png_set_invert_alpha");
|
||||
if (png_ptr == NULL) return;
|
||||
png_ptr->transformations |= PNG_INVERT_ALPHA;
|
||||
}
|
||||
@ -166,7 +166,7 @@ png_set_invert_alpha(png_structp png_ptr)
|
||||
void PNGAPI
|
||||
png_set_invert_mono(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_set_invert_mono\n");
|
||||
png_debug(1, "in png_set_invert_mono");
|
||||
if (png_ptr == NULL) return;
|
||||
png_ptr->transformations |= PNG_INVERT_MONO;
|
||||
}
|
||||
@ -175,7 +175,7 @@ png_set_invert_mono(png_structp png_ptr)
|
||||
void /* PRIVATE */
|
||||
png_do_invert(png_row_infop row_info, png_bytep row)
|
||||
{
|
||||
png_debug(1, "in png_do_invert\n");
|
||||
png_debug(1, "in png_do_invert");
|
||||
/* This test removed from libpng version 1.0.13 and 1.2.0:
|
||||
* if (row_info->bit_depth == 1 &&
|
||||
*/
|
||||
@ -230,7 +230,7 @@ png_do_invert(png_row_infop row_info, png_bytep row)
|
||||
void /* PRIVATE */
|
||||
png_do_swap(png_row_infop row_info, png_bytep row)
|
||||
{
|
||||
png_debug(1, "in png_do_swap\n");
|
||||
png_debug(1, "in png_do_swap");
|
||||
if (
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
row != NULL && row_info != NULL &&
|
||||
@ -361,7 +361,7 @@ static PNG_CONST png_byte fourbppswaptable[256] = {
|
||||
void /* PRIVATE */
|
||||
png_do_packswap(png_row_infop row_info, png_bytep row)
|
||||
{
|
||||
png_debug(1, "in png_do_packswap\n");
|
||||
png_debug(1, "in png_do_packswap");
|
||||
if (
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
row != NULL && row_info != NULL &&
|
||||
@ -393,7 +393,7 @@ png_do_packswap(png_row_infop row_info, png_bytep row)
|
||||
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");
|
||||
png_debug(1, "in png_do_strip_filler");
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
if (row != NULL && row_info != NULL)
|
||||
#endif
|
||||
@ -551,7 +551,7 @@ png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
|
||||
void /* PRIVATE */
|
||||
png_do_bgr(png_row_infop row_info, png_bytep row)
|
||||
{
|
||||
png_debug(1, "in png_do_bgr\n");
|
||||
png_debug(1, "in png_do_bgr");
|
||||
if (
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
row != NULL && row_info != NULL &&
|
||||
@ -630,7 +630,7 @@ void PNGAPI
|
||||
png_set_user_transform_info(png_structp png_ptr, png_voidp
|
||||
user_transform_ptr, int user_transform_depth, int user_transform_channels)
|
||||
{
|
||||
png_debug(1, "in png_set_user_transform_info\n");
|
||||
png_debug(1, "in png_set_user_transform_info");
|
||||
if (png_ptr == NULL) return;
|
||||
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
|
||||
png_ptr->user_transform_ptr = user_transform_ptr;
|
||||
|
@ -25,7 +25,7 @@
|
||||
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");
|
||||
png_debug(1, "in png_write_info_before_PLTE");
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
|
||||
@ -99,7 +99,7 @@ png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)
|
||||
{
|
||||
png_unknown_chunk *up;
|
||||
|
||||
png_debug(5, "writing extra chunks\n");
|
||||
png_debug(5, "writing extra chunks");
|
||||
|
||||
for (up = info_ptr->unknown_chunks;
|
||||
up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
|
||||
@ -130,7 +130,7 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
|
||||
int i;
|
||||
#endif
|
||||
|
||||
png_debug(1, "in png_write_info\n");
|
||||
png_debug(1, "in png_write_info");
|
||||
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
@ -215,7 +215,7 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
|
||||
/* Check to see if we need to write text chunks */
|
||||
for (i = 0; i < info_ptr->num_text; i++)
|
||||
{
|
||||
png_debug2(2, "Writing header text chunk %d, type %d\n", i,
|
||||
png_debug2(2, "Writing header text chunk %d, type %d", i,
|
||||
info_ptr->text[i].compression);
|
||||
/* an internationalized chunk? */
|
||||
if (info_ptr->text[i].compression > 0)
|
||||
@ -268,7 +268,7 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
|
||||
{
|
||||
png_unknown_chunk *up;
|
||||
|
||||
png_debug(5, "writing extra chunks\n");
|
||||
png_debug(5, "writing extra chunks");
|
||||
|
||||
for (up = info_ptr->unknown_chunks;
|
||||
up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
|
||||
@ -296,7 +296,7 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
|
||||
void PNGAPI
|
||||
png_write_end(png_structp png_ptr, png_infop info_ptr)
|
||||
{
|
||||
png_debug(1, "in png_write_end\n");
|
||||
png_debug(1, "in png_write_end");
|
||||
if (png_ptr == NULL)
|
||||
return;
|
||||
if (!(png_ptr->mode & PNG_HAVE_IDAT))
|
||||
@ -318,7 +318,7 @@ png_write_end(png_structp png_ptr, png_infop info_ptr)
|
||||
/* loop through comment chunks */
|
||||
for (i = 0; i < info_ptr->num_text; i++)
|
||||
{
|
||||
png_debug2(2, "Writing trailer text chunk %d, type %d\n", i,
|
||||
png_debug2(2, "Writing trailer text chunk %d, type %d", i,
|
||||
info_ptr->text[i].compression);
|
||||
/* an internationalized chunk? */
|
||||
if (info_ptr->text[i].compression > 0)
|
||||
@ -370,7 +370,7 @@ png_write_end(png_structp png_ptr, png_infop info_ptr)
|
||||
{
|
||||
png_unknown_chunk *up;
|
||||
|
||||
png_debug(5, "writing extra chunks\n");
|
||||
png_debug(5, "writing extra chunks");
|
||||
|
||||
for (up = info_ptr->unknown_chunks;
|
||||
up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
|
||||
@ -413,7 +413,7 @@ png_write_end(png_structp png_ptr, png_infop info_ptr)
|
||||
void PNGAPI
|
||||
png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime)
|
||||
{
|
||||
png_debug(1, "in png_convert_from_struct_tm\n");
|
||||
png_debug(1, "in png_convert_from_struct_tm");
|
||||
ptime->year = (png_uint_16)(1900 + ttime->tm_year);
|
||||
ptime->month = (png_byte)(ttime->tm_mon + 1);
|
||||
ptime->day = (png_byte)ttime->tm_mday;
|
||||
@ -427,7 +427,7 @@ png_convert_from_time_t(png_timep ptime, time_t ttime)
|
||||
{
|
||||
struct tm *tbuf;
|
||||
|
||||
png_debug(1, "in png_convert_from_time_t\n");
|
||||
png_debug(1, "in png_convert_from_time_t");
|
||||
tbuf = gmtime(&ttime);
|
||||
png_convert_from_struct_tm(ptime, tbuf);
|
||||
}
|
||||
@ -461,7 +461,7 @@ png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
|
||||
#endif
|
||||
#endif
|
||||
int i;
|
||||
png_debug(1, "in png_create_write_struct\n");
|
||||
png_debug(1, "in png_create_write_struct");
|
||||
#ifdef PNG_USER_MEM_SUPPORTED
|
||||
png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
|
||||
(png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);
|
||||
@ -659,7 +659,7 @@ png_write_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
|
||||
}
|
||||
} while (png_libpng_ver[i++]);
|
||||
|
||||
png_debug(1, "in png_write_init_3\n");
|
||||
png_debug(1, "in png_write_init_3");
|
||||
|
||||
#ifdef PNG_SETJMP_SUPPORTED
|
||||
/* save jump buffer and error functions */
|
||||
@ -713,7 +713,7 @@ png_write_rows(png_structp png_ptr, png_bytepp row,
|
||||
png_uint_32 i; /* row counter */
|
||||
png_bytepp rp; /* row pointer */
|
||||
|
||||
png_debug(1, "in png_write_rows\n");
|
||||
png_debug(1, "in png_write_rows");
|
||||
|
||||
if (png_ptr == NULL)
|
||||
return;
|
||||
@ -738,7 +738,7 @@ png_write_image(png_structp png_ptr, png_bytepp image)
|
||||
if (png_ptr == NULL)
|
||||
return;
|
||||
|
||||
png_debug(1, "in png_write_image\n");
|
||||
png_debug(1, "in png_write_image");
|
||||
#if defined(PNG_WRITE_INTERLACING_SUPPORTED)
|
||||
/* intialize interlace handling. If image is not interlaced,
|
||||
this will set pass to 1 */
|
||||
@ -763,7 +763,7 @@ png_write_row(png_structp png_ptr, png_bytep row)
|
||||
{
|
||||
if (png_ptr == NULL)
|
||||
return;
|
||||
png_debug2(1, "in png_write_row (row %ld, pass %d)\n",
|
||||
png_debug2(1, "in png_write_row (row %ld, pass %d)",
|
||||
png_ptr->row_number, png_ptr->pass);
|
||||
|
||||
/* initialize transformations and other stuff if first time */
|
||||
@ -877,12 +877,12 @@ png_write_row(png_structp png_ptr, png_bytep row)
|
||||
png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
|
||||
png_ptr->row_info.width);
|
||||
|
||||
png_debug1(3, "row_info->color_type = %d\n", png_ptr->row_info.color_type);
|
||||
png_debug1(3, "row_info->width = %lu\n", png_ptr->row_info.width);
|
||||
png_debug1(3, "row_info->channels = %d\n", png_ptr->row_info.channels);
|
||||
png_debug1(3, "row_info->bit_depth = %d\n", png_ptr->row_info.bit_depth);
|
||||
png_debug1(3, "row_info->pixel_depth = %d\n", png_ptr->row_info.pixel_depth);
|
||||
png_debug1(3, "row_info->rowbytes = %lu\n", png_ptr->row_info.rowbytes);
|
||||
png_debug1(3, "row_info->color_type = %d", png_ptr->row_info.color_type);
|
||||
png_debug1(3, "row_info->width = %lu", png_ptr->row_info.width);
|
||||
png_debug1(3, "row_info->channels = %d", png_ptr->row_info.channels);
|
||||
png_debug1(3, "row_info->bit_depth = %d", png_ptr->row_info.bit_depth);
|
||||
png_debug1(3, "row_info->pixel_depth = %d", png_ptr->row_info.pixel_depth);
|
||||
png_debug1(3, "row_info->rowbytes = %lu", png_ptr->row_info.rowbytes);
|
||||
|
||||
/* Copy user's row into buffer, leaving room for filter byte. */
|
||||
png_memcpy_check(png_ptr, png_ptr->row_buf + 1, row,
|
||||
@ -938,7 +938,7 @@ png_write_row(png_structp png_ptr, png_bytep row)
|
||||
void PNGAPI
|
||||
png_set_flush(png_structp png_ptr, int nrows)
|
||||
{
|
||||
png_debug(1, "in png_set_flush\n");
|
||||
png_debug(1, "in png_set_flush");
|
||||
if (png_ptr == NULL)
|
||||
return;
|
||||
png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);
|
||||
@ -950,7 +950,7 @@ png_write_flush(png_structp png_ptr)
|
||||
{
|
||||
int wrote_IDAT;
|
||||
|
||||
png_debug(1, "in png_write_flush\n");
|
||||
png_debug(1, "in png_write_flush");
|
||||
if (png_ptr == NULL)
|
||||
return;
|
||||
/* We have already written out all of the data */
|
||||
@ -1010,7 +1010,7 @@ png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
|
||||
png_voidp mem_ptr = NULL;
|
||||
#endif
|
||||
|
||||
png_debug(1, "in png_destroy_write_struct\n");
|
||||
png_debug(1, "in png_destroy_write_struct");
|
||||
if (png_ptr_ptr != NULL)
|
||||
{
|
||||
png_ptr = *png_ptr_ptr;
|
||||
@ -1084,7 +1084,7 @@ png_write_destroy(png_structp png_ptr)
|
||||
png_free_ptr free_fn;
|
||||
#endif
|
||||
|
||||
png_debug(1, "in png_write_destroy\n");
|
||||
png_debug(1, "in png_write_destroy");
|
||||
/* free any memory zlib uses */
|
||||
deflateEnd(&png_ptr->zstream);
|
||||
|
||||
@ -1141,7 +1141,7 @@ png_write_destroy(png_structp png_ptr)
|
||||
void PNGAPI
|
||||
png_set_filter(png_structp png_ptr, int method, int filters)
|
||||
{
|
||||
png_debug(1, "in png_set_filter\n");
|
||||
png_debug(1, "in png_set_filter");
|
||||
if (png_ptr == NULL)
|
||||
return;
|
||||
#if defined(PNG_MNG_FEATURES_SUPPORTED)
|
||||
@ -1264,7 +1264,7 @@ png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,
|
||||
{
|
||||
int i;
|
||||
|
||||
png_debug(1, "in png_set_filter_heuristics\n");
|
||||
png_debug(1, "in png_set_filter_heuristics");
|
||||
if (png_ptr == NULL)
|
||||
return;
|
||||
if (heuristic_method >= PNG_FILTER_HEURISTIC_LAST)
|
||||
@ -1378,7 +1378,7 @@ png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,
|
||||
void PNGAPI
|
||||
png_set_compression_level(png_structp png_ptr, int level)
|
||||
{
|
||||
png_debug(1, "in png_set_compression_level\n");
|
||||
png_debug(1, "in png_set_compression_level");
|
||||
if (png_ptr == NULL)
|
||||
return;
|
||||
png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL;
|
||||
@ -1388,7 +1388,7 @@ png_set_compression_level(png_structp png_ptr, int level)
|
||||
void PNGAPI
|
||||
png_set_compression_mem_level(png_structp png_ptr, int mem_level)
|
||||
{
|
||||
png_debug(1, "in png_set_compression_mem_level\n");
|
||||
png_debug(1, "in png_set_compression_mem_level");
|
||||
if (png_ptr == NULL)
|
||||
return;
|
||||
png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL;
|
||||
@ -1398,7 +1398,7 @@ png_set_compression_mem_level(png_structp png_ptr, int mem_level)
|
||||
void PNGAPI
|
||||
png_set_compression_strategy(png_structp png_ptr, int strategy)
|
||||
{
|
||||
png_debug(1, "in png_set_compression_strategy\n");
|
||||
png_debug(1, "in png_set_compression_strategy");
|
||||
if (png_ptr == NULL)
|
||||
return;
|
||||
png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;
|
||||
@ -1429,7 +1429,7 @@ png_set_compression_window_bits(png_structp png_ptr, int window_bits)
|
||||
void PNGAPI
|
||||
png_set_compression_method(png_structp png_ptr, int method)
|
||||
{
|
||||
png_debug(1, "in png_set_compression_method\n");
|
||||
png_debug(1, "in png_set_compression_method");
|
||||
if (png_ptr == NULL)
|
||||
return;
|
||||
if (method != 8)
|
||||
@ -1451,7 +1451,7 @@ void PNGAPI
|
||||
png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
|
||||
write_user_transform_fn)
|
||||
{
|
||||
png_debug(1, "in png_set_write_user_transform_fn\n");
|
||||
png_debug(1, "in png_set_write_user_transform_fn");
|
||||
if (png_ptr == NULL)
|
||||
return;
|
||||
png_ptr->transformations |= PNG_USER_TRANSFORM;
|
||||
@ -1506,11 +1506,11 @@ png_write_png(png_structp png_ptr, png_infop info_ptr,
|
||||
#endif
|
||||
|
||||
#if defined(PNG_WRITE_FILLER_SUPPORTED)
|
||||
/* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into
|
||||
* RGB (4 channels -> 3 channels). The second parameter is not used.
|
||||
*/
|
||||
if (transforms & PNG_TRANSFORM_STRIP_FILLER)
|
||||
png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
|
||||
/* Pack XRGB/RGBX/ARGB/RGBA into * RGB (4 channels -> 3 channels) */
|
||||
if (transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER)
|
||||
png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);
|
||||
else if (transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE)
|
||||
png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
|
||||
#endif
|
||||
|
||||
#if defined(PNG_WRITE_BGR_SUPPORTED)
|
||||
|
@ -18,7 +18,7 @@
|
||||
void /* PRIVATE */
|
||||
png_do_write_transformations(png_structp png_ptr)
|
||||
{
|
||||
png_debug(1, "in png_do_write_transformations\n");
|
||||
png_debug(1, "in png_do_write_transformations");
|
||||
|
||||
if (png_ptr == NULL)
|
||||
return;
|
||||
@ -86,7 +86,7 @@ png_do_write_transformations(png_structp png_ptr)
|
||||
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");
|
||||
png_debug(1, "in png_do_pack");
|
||||
if (row_info->bit_depth == 8 &&
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
row != NULL && row_info != NULL &&
|
||||
@ -212,7 +212,7 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
|
||||
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");
|
||||
png_debug(1, "in png_do_shift");
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
if (row != NULL && row_info != NULL &&
|
||||
#else
|
||||
@ -336,7 +336,7 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
|
||||
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");
|
||||
png_debug(1, "in png_do_write_swap_alpha");
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
if (row != NULL && row_info != NULL)
|
||||
#endif
|
||||
@ -424,7 +424,7 @@ png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
|
||||
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");
|
||||
png_debug(1, "in png_do_write_invert_alpha");
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
if (row != NULL && row_info != NULL)
|
||||
#endif
|
||||
@ -514,7 +514,7 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
|
||||
void /* PRIVATE */
|
||||
png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
|
||||
{
|
||||
png_debug(1, "in png_do_write_intrapixel\n");
|
||||
png_debug(1, "in png_do_write_intrapixel");
|
||||
if (
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
row != NULL && row_info != NULL &&
|
||||
|
@ -1,7 +1,7 @@
|
||||
|
||||
/* pngwutil.c - utilities to write a PNG file
|
||||
*
|
||||
* Last changed in libpng 1.2.30 [August 15, 2008]
|
||||
* Last changed in libpng 1.2.34 [December 18, 2008]
|
||||
* For conditions of distribution and use, see copyright notice in png.h
|
||||
* Copyright (c) 1998-2008 Glenn Randers-Pehrson
|
||||
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
|
||||
@ -96,7 +96,7 @@ png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,
|
||||
{
|
||||
png_byte buf[8];
|
||||
|
||||
png_debug2(0, "Writing %s chunk, length = %lu\n", chunk_name,
|
||||
png_debug2(0, "Writing %s chunk, length = %lu", chunk_name,
|
||||
(unsigned long)length);
|
||||
if (png_ptr == NULL) return;
|
||||
|
||||
@ -392,7 +392,7 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
|
||||
|
||||
png_byte buf[13]; /* buffer to store the IHDR info */
|
||||
|
||||
png_debug(1, "in png_write_IHDR\n");
|
||||
png_debug(1, "in png_write_IHDR");
|
||||
/* Check that we have valid input data from the application info */
|
||||
switch (color_type)
|
||||
{
|
||||
@ -569,7 +569,7 @@ png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)
|
||||
png_colorp pal_ptr;
|
||||
png_byte buf[3];
|
||||
|
||||
png_debug(1, "in png_write_PLTE\n");
|
||||
png_debug(1, "in png_write_PLTE");
|
||||
if ((
|
||||
#if defined(PNG_MNG_FEATURES_SUPPORTED)
|
||||
!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) &&
|
||||
@ -595,7 +595,7 @@ png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)
|
||||
}
|
||||
|
||||
png_ptr->num_palette = (png_uint_16)num_pal;
|
||||
png_debug1(3, "num_palette = %d\n", png_ptr->num_palette);
|
||||
png_debug1(3, "num_palette = %d", png_ptr->num_palette);
|
||||
|
||||
png_write_chunk_start(png_ptr, (png_bytep)png_PLTE,
|
||||
(png_uint_32)(num_pal * 3));
|
||||
@ -629,7 +629,7 @@ png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)
|
||||
#ifdef PNG_USE_LOCAL_ARRAYS
|
||||
PNG_IDAT;
|
||||
#endif
|
||||
png_debug(1, "in png_write_IDAT\n");
|
||||
png_debug(1, "in png_write_IDAT");
|
||||
|
||||
/* Optimize the CMF field in the zlib stream. */
|
||||
/* This hack of the zlib stream is compliant to the stream specification. */
|
||||
@ -681,7 +681,7 @@ png_write_IEND(png_structp png_ptr)
|
||||
#ifdef PNG_USE_LOCAL_ARRAYS
|
||||
PNG_IEND;
|
||||
#endif
|
||||
png_debug(1, "in png_write_IEND\n");
|
||||
png_debug(1, "in png_write_IEND");
|
||||
png_write_chunk(png_ptr, (png_bytep)png_IEND, png_bytep_NULL,
|
||||
(png_size_t)0);
|
||||
png_ptr->mode |= PNG_HAVE_IEND;
|
||||
@ -699,7 +699,7 @@ png_write_gAMA(png_structp png_ptr, double file_gamma)
|
||||
png_uint_32 igamma;
|
||||
png_byte buf[4];
|
||||
|
||||
png_debug(1, "in png_write_gAMA\n");
|
||||
png_debug(1, "in png_write_gAMA");
|
||||
/* file_gamma is saved in 1/100,000ths */
|
||||
igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5);
|
||||
png_save_uint_32(buf, igamma);
|
||||
@ -715,7 +715,7 @@ png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma)
|
||||
#endif
|
||||
png_byte buf[4];
|
||||
|
||||
png_debug(1, "in png_write_gAMA\n");
|
||||
png_debug(1, "in png_write_gAMA");
|
||||
/* file_gamma is saved in 1/100,000ths */
|
||||
png_save_uint_32(buf, (png_uint_32)file_gamma);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);
|
||||
@ -733,7 +733,7 @@ png_write_sRGB(png_structp png_ptr, int srgb_intent)
|
||||
#endif
|
||||
png_byte buf[1];
|
||||
|
||||
png_debug(1, "in png_write_sRGB\n");
|
||||
png_debug(1, "in png_write_sRGB");
|
||||
if (srgb_intent >= PNG_sRGB_INTENT_LAST)
|
||||
png_warning(png_ptr,
|
||||
"Invalid sRGB rendering intent specified");
|
||||
@ -756,7 +756,7 @@ png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,
|
||||
compression_state comp;
|
||||
int embedded_profile_len = 0;
|
||||
|
||||
png_debug(1, "in png_write_iCCP\n");
|
||||
png_debug(1, "in png_write_iCCP");
|
||||
|
||||
comp.num_output_ptr = 0;
|
||||
comp.max_output_ptr = 0;
|
||||
@ -764,12 +764,9 @@ png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,
|
||||
comp.input = NULL;
|
||||
comp.input_len = 0;
|
||||
|
||||
if (name == NULL || (name_len = png_check_keyword(png_ptr, name,
|
||||
if ((name_len = png_check_keyword(png_ptr, name,
|
||||
&new_name)) == 0)
|
||||
{
|
||||
png_warning(png_ptr, "Empty keyword in iCCP chunk");
|
||||
return;
|
||||
}
|
||||
|
||||
if (compression_type != PNG_COMPRESSION_TYPE_BASE)
|
||||
png_warning(png_ptr, "Unknown compression type in iCCP chunk");
|
||||
@ -835,13 +832,10 @@ png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)
|
||||
int i;
|
||||
#endif
|
||||
|
||||
png_debug(1, "in png_write_sPLT\n");
|
||||
if (spalette->name == NULL || (name_len = png_check_keyword(png_ptr,
|
||||
png_debug(1, "in png_write_sPLT");
|
||||
if ((name_len = png_check_keyword(png_ptr,
|
||||
spalette->name, &new_name))==0)
|
||||
{
|
||||
png_warning(png_ptr, "Empty keyword in sPLT chunk");
|
||||
return;
|
||||
}
|
||||
return;
|
||||
|
||||
/* make sure we include the NULL after the name */
|
||||
png_write_chunk_start(png_ptr, (png_bytep)png_sPLT,
|
||||
@ -912,7 +906,7 @@ png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type)
|
||||
png_byte buf[4];
|
||||
png_size_t size;
|
||||
|
||||
png_debug(1, "in png_write_sBIT\n");
|
||||
png_debug(1, "in png_write_sBIT");
|
||||
/* make sure we don't depend upon the order of PNG_COLOR_8 */
|
||||
if (color_type & PNG_COLOR_MASK_COLOR)
|
||||
{
|
||||
@ -969,55 +963,42 @@ png_write_cHRM(png_structp png_ptr, double white_x, double white_y,
|
||||
PNG_cHRM;
|
||||
#endif
|
||||
png_byte buf[32];
|
||||
png_uint_32 itemp;
|
||||
|
||||
png_debug(1, "in png_write_cHRM\n");
|
||||
/* each value is saved in 1/100,000ths */
|
||||
if (white_x < 0 || white_x > 0.8 || white_y < 0 || white_y > 0.8 ||
|
||||
white_x + white_y > 1.0)
|
||||
{
|
||||
png_warning(png_ptr, "Invalid cHRM white point specified");
|
||||
#if !defined(PNG_NO_CONSOLE_IO)
|
||||
fprintf(stderr, "white_x=%f, white_y=%f\n", white_x, white_y);
|
||||
png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y,
|
||||
int_green_x, int_green_y, int_blue_x, int_blue_y;
|
||||
|
||||
png_debug(1, "in png_write_cHRM");
|
||||
|
||||
int_white_x = (png_uint_32)(white_x * 100000.0 + 0.5);
|
||||
int_white_y = (png_uint_32)(white_y * 100000.0 + 0.5);
|
||||
int_red_x = (png_uint_32)(red_x * 100000.0 + 0.5);
|
||||
int_red_y = (png_uint_32)(red_y * 100000.0 + 0.5);
|
||||
int_green_x = (png_uint_32)(green_x * 100000.0 + 0.5);
|
||||
int_green_y = (png_uint_32)(green_y * 100000.0 + 0.5);
|
||||
int_blue_x = (png_uint_32)(blue_x * 100000.0 + 0.5);
|
||||
int_blue_y = (png_uint_32)(blue_y * 100000.0 + 0.5);
|
||||
|
||||
#if !defined(PNG_NO_CHECK_cHRM)
|
||||
if (png_check_cHRM_fixed(png_ptr, int_white_x, int_white_y,
|
||||
int_red_x, int_red_y, int_green_x, int_green_y, int_blue_x, int_blue_y))
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
itemp = (png_uint_32)(white_x * 100000.0 + 0.5);
|
||||
png_save_uint_32(buf, itemp);
|
||||
itemp = (png_uint_32)(white_y * 100000.0 + 0.5);
|
||||
png_save_uint_32(buf + 4, itemp);
|
||||
|
||||
if (red_x < 0 || red_y < 0 || red_x + red_y > 1.0)
|
||||
{
|
||||
png_warning(png_ptr, "Invalid cHRM red point specified");
|
||||
return;
|
||||
}
|
||||
itemp = (png_uint_32)(red_x * 100000.0 + 0.5);
|
||||
png_save_uint_32(buf + 8, itemp);
|
||||
itemp = (png_uint_32)(red_y * 100000.0 + 0.5);
|
||||
png_save_uint_32(buf + 12, itemp);
|
||||
/* each value is saved in 1/100,000ths */
|
||||
|
||||
png_save_uint_32(buf, int_white_x);
|
||||
png_save_uint_32(buf + 4, int_white_y);
|
||||
|
||||
if (green_x < 0 || green_y < 0 || green_x + green_y > 1.0)
|
||||
{
|
||||
png_warning(png_ptr, "Invalid cHRM green point specified");
|
||||
return;
|
||||
}
|
||||
itemp = (png_uint_32)(green_x * 100000.0 + 0.5);
|
||||
png_save_uint_32(buf + 16, itemp);
|
||||
itemp = (png_uint_32)(green_y * 100000.0 + 0.5);
|
||||
png_save_uint_32(buf + 20, itemp);
|
||||
png_save_uint_32(buf + 8, int_red_x);
|
||||
png_save_uint_32(buf + 12, int_red_y);
|
||||
|
||||
if (blue_x < 0 || blue_y < 0 || blue_x + blue_y > 1.0)
|
||||
{
|
||||
png_warning(png_ptr, "Invalid cHRM blue point specified");
|
||||
return;
|
||||
}
|
||||
itemp = (png_uint_32)(blue_x * 100000.0 + 0.5);
|
||||
png_save_uint_32(buf + 24, itemp);
|
||||
itemp = (png_uint_32)(blue_y * 100000.0 + 0.5);
|
||||
png_save_uint_32(buf + 28, itemp);
|
||||
png_save_uint_32(buf + 16, int_green_x);
|
||||
png_save_uint_32(buf + 20, int_green_y);
|
||||
|
||||
png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);
|
||||
png_save_uint_32(buf + 24, int_blue_x);
|
||||
png_save_uint_32(buf + 28, int_blue_y);
|
||||
|
||||
png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#ifdef PNG_FIXED_POINT_SUPPORTED
|
||||
@ -1032,45 +1013,27 @@ png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x,
|
||||
#endif
|
||||
png_byte buf[32];
|
||||
|
||||
png_debug(1, "in png_write_cHRM\n");
|
||||
png_debug(1, "in png_write_cHRM");
|
||||
/* each value is saved in 1/100,000ths */
|
||||
if (white_x > 80000L || white_y > 80000L || white_x + white_y > 100000L)
|
||||
{
|
||||
png_warning(png_ptr, "Invalid fixed cHRM white point specified");
|
||||
#if !defined(PNG_NO_CONSOLE_IO)
|
||||
fprintf(stderr, "white_x=%ld, white_y=%ld\n", (unsigned long)white_x,
|
||||
(unsigned long)white_y);
|
||||
#if !defined(PNG_NO_CHECK_cHRM)
|
||||
if (png_check_cHRM_fixed(png_ptr, white_x, white_y, red_x, red_y,
|
||||
green_x, green_y, blue_x, blue_y))
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
{
|
||||
png_save_uint_32(buf, (png_uint_32)white_x);
|
||||
png_save_uint_32(buf + 4, (png_uint_32)white_y);
|
||||
|
||||
if (red_x + red_y > 100000L)
|
||||
{
|
||||
png_warning(png_ptr, "Invalid cHRM fixed red point specified");
|
||||
return;
|
||||
}
|
||||
png_save_uint_32(buf + 8, (png_uint_32)red_x);
|
||||
png_save_uint_32(buf + 12, (png_uint_32)red_y);
|
||||
|
||||
if (green_x + green_y > 100000L)
|
||||
{
|
||||
png_warning(png_ptr, "Invalid fixed cHRM green point specified");
|
||||
return;
|
||||
}
|
||||
png_save_uint_32(buf + 16, (png_uint_32)green_x);
|
||||
png_save_uint_32(buf + 20, (png_uint_32)green_y);
|
||||
|
||||
if (blue_x + blue_y > 100000L)
|
||||
{
|
||||
png_warning(png_ptr, "Invalid fixed cHRM blue point specified");
|
||||
return;
|
||||
}
|
||||
png_save_uint_32(buf + 24, (png_uint_32)blue_x);
|
||||
png_save_uint_32(buf + 28, (png_uint_32)blue_y);
|
||||
|
||||
png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
@ -1086,7 +1049,7 @@ png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,
|
||||
#endif
|
||||
png_byte buf[6];
|
||||
|
||||
png_debug(1, "in png_write_tRNS\n");
|
||||
png_debug(1, "in png_write_tRNS");
|
||||
if (color_type == PNG_COLOR_TYPE_PALETTE)
|
||||
{
|
||||
if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)
|
||||
@ -1141,7 +1104,7 @@ png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)
|
||||
#endif
|
||||
png_byte buf[6];
|
||||
|
||||
png_debug(1, "in png_write_bKGD\n");
|
||||
png_debug(1, "in png_write_bKGD");
|
||||
if (color_type == PNG_COLOR_TYPE_PALETTE)
|
||||
{
|
||||
if (
|
||||
@ -1149,7 +1112,7 @@ png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)
|
||||
(png_ptr->num_palette ||
|
||||
(!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) &&
|
||||
#endif
|
||||
back->index > png_ptr->num_palette)
|
||||
back->index >= png_ptr->num_palette)
|
||||
{
|
||||
png_warning(png_ptr, "Invalid background palette index");
|
||||
return;
|
||||
@ -1195,10 +1158,10 @@ png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist)
|
||||
int i;
|
||||
png_byte buf[3];
|
||||
|
||||
png_debug(1, "in png_write_hIST\n");
|
||||
png_debug(1, "in png_write_hIST");
|
||||
if (num_hist > (int)png_ptr->num_palette)
|
||||
{
|
||||
png_debug2(3, "num_hist = %d, num_palette = %d\n", num_hist,
|
||||
png_debug2(3, "num_hist = %d, num_palette = %d", num_hist,
|
||||
png_ptr->num_palette);
|
||||
png_warning(png_ptr, "Invalid number of histogram entries specified");
|
||||
return;
|
||||
@ -1235,7 +1198,7 @@ png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)
|
||||
int kflag;
|
||||
int kwarn=0;
|
||||
|
||||
png_debug(1, "in png_check_keyword\n");
|
||||
png_debug(1, "in png_check_keyword");
|
||||
*new_key = NULL;
|
||||
|
||||
if (key == NULL || (key_len = png_strlen(key)) == 0)
|
||||
@ -1244,7 +1207,7 @@ png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)
|
||||
return ((png_size_t)0);
|
||||
}
|
||||
|
||||
png_debug1(2, "Keyword to be checked is '%s'\n", key);
|
||||
png_debug1(2, "Keyword to be checked is '%s'", key);
|
||||
|
||||
*new_key = (png_charp)png_malloc_warn(png_ptr, (png_uint_32)(key_len + 2));
|
||||
if (*new_key == NULL)
|
||||
@ -1303,7 +1266,7 @@ png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)
|
||||
}
|
||||
}
|
||||
|
||||
png_debug1(2, "Checking for multiple internal spaces in '%s'\n", kp);
|
||||
png_debug1(2, "Checking for multiple internal spaces in '%s'", kp);
|
||||
|
||||
/* Remove multiple internal spaces. */
|
||||
for (kflag = 0, dp = *new_key; *kp != '\0'; kp++)
|
||||
@ -1338,7 +1301,7 @@ png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)
|
||||
if (key_len > 79)
|
||||
{
|
||||
png_warning(png_ptr, "keyword length must be 1 - 79 characters");
|
||||
new_key[79] = '\0';
|
||||
(*new_key)[79] = '\0';
|
||||
key_len = 79;
|
||||
}
|
||||
|
||||
@ -1358,12 +1321,9 @@ png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,
|
||||
png_size_t key_len;
|
||||
png_charp new_key;
|
||||
|
||||
png_debug(1, "in png_write_tEXt\n");
|
||||
if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)
|
||||
{
|
||||
png_warning(png_ptr, "Empty keyword in tEXt chunk");
|
||||
png_debug(1, "in png_write_tEXt");
|
||||
if ((key_len = png_check_keyword(png_ptr, key, &new_key))==0)
|
||||
return;
|
||||
}
|
||||
|
||||
if (text == NULL || *text == '\0')
|
||||
text_len = 0;
|
||||
@ -1403,7 +1363,7 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
|
||||
png_charp new_key;
|
||||
compression_state comp;
|
||||
|
||||
png_debug(1, "in png_write_zTXt\n");
|
||||
png_debug(1, "in png_write_zTXt");
|
||||
|
||||
comp.num_output_ptr = 0;
|
||||
comp.max_output_ptr = 0;
|
||||
@ -1411,9 +1371,8 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
|
||||
comp.input = NULL;
|
||||
comp.input_len = 0;
|
||||
|
||||
if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)
|
||||
if ((key_len = png_check_keyword(png_ptr, key, &new_key))==0)
|
||||
{
|
||||
png_warning(png_ptr, "Empty keyword in zTXt chunk");
|
||||
png_free(png_ptr, new_key);
|
||||
return;
|
||||
}
|
||||
@ -1460,23 +1419,22 @@ png_write_iTXt(png_structp png_ptr, int compression, png_charp key,
|
||||
PNG_iTXt;
|
||||
#endif
|
||||
png_size_t lang_len, key_len, lang_key_len, text_len;
|
||||
png_charp new_lang, new_key;
|
||||
png_charp new_lang;
|
||||
png_charp new_key = NULL;
|
||||
png_byte cbuf[2];
|
||||
compression_state comp;
|
||||
|
||||
png_debug(1, "in png_write_iTXt\n");
|
||||
png_debug(1, "in png_write_iTXt");
|
||||
|
||||
comp.num_output_ptr = 0;
|
||||
comp.max_output_ptr = 0;
|
||||
comp.output_ptr = NULL;
|
||||
comp.input = NULL;
|
||||
|
||||
if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)
|
||||
{
|
||||
png_warning(png_ptr, "Empty keyword in iTXt chunk");
|
||||
if ((key_len = png_check_keyword(png_ptr, key, &new_key))==0)
|
||||
return;
|
||||
}
|
||||
if (lang == NULL || (lang_len = png_check_keyword(png_ptr, lang, &new_lang))==0)
|
||||
|
||||
if ((lang_len = png_check_keyword(png_ptr, lang, &new_lang))==0)
|
||||
{
|
||||
png_warning(png_ptr, "Empty language field in iTXt chunk");
|
||||
new_lang = NULL;
|
||||
@ -1552,7 +1510,7 @@ png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset,
|
||||
#endif
|
||||
png_byte buf[9];
|
||||
|
||||
png_debug(1, "in png_write_oFFs\n");
|
||||
png_debug(1, "in png_write_oFFs");
|
||||
if (unit_type >= PNG_OFFSET_LAST)
|
||||
png_warning(png_ptr, "Unrecognized unit type for oFFs chunk");
|
||||
|
||||
@ -1578,14 +1536,14 @@ png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
|
||||
png_charp new_purpose;
|
||||
int i;
|
||||
|
||||
png_debug1(1, "in png_write_pCAL (%d parameters)\n", nparams);
|
||||
png_debug1(1, "in png_write_pCAL (%d parameters)", nparams);
|
||||
if (type >= PNG_EQUATION_LAST)
|
||||
png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");
|
||||
|
||||
purpose_len = png_check_keyword(png_ptr, purpose, &new_purpose) + 1;
|
||||
png_debug1(3, "pCAL purpose length = %d\n", (int)purpose_len);
|
||||
png_debug1(3, "pCAL purpose length = %d", (int)purpose_len);
|
||||
units_len = png_strlen(units) + (nparams == 0 ? 0 : 1);
|
||||
png_debug1(3, "pCAL units length = %d\n", (int)units_len);
|
||||
png_debug1(3, "pCAL units length = %d", (int)units_len);
|
||||
total_len = purpose_len + units_len + 10;
|
||||
|
||||
params_len = (png_uint_32p)png_malloc(png_ptr,
|
||||
@ -1596,12 +1554,12 @@ png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
|
||||
for (i = 0; i < nparams; i++)
|
||||
{
|
||||
params_len[i] = png_strlen(params[i]) + (i == nparams - 1 ? 0 : 1);
|
||||
png_debug2(3, "pCAL parameter %d length = %lu\n", i,
|
||||
png_debug2(3, "pCAL parameter %d length = %lu", i,
|
||||
(unsigned long) params_len[i]);
|
||||
total_len += (png_size_t)params_len[i];
|
||||
}
|
||||
|
||||
png_debug1(3, "pCAL total length = %d\n", (int)total_len);
|
||||
png_debug1(3, "pCAL total length = %d", (int)total_len);
|
||||
png_write_chunk_start(png_ptr, (png_bytep)png_pCAL, (png_uint_32)total_len);
|
||||
png_write_chunk_data(png_ptr, (png_bytep)new_purpose,
|
||||
(png_size_t)purpose_len);
|
||||
@ -1637,7 +1595,7 @@ png_write_sCAL(png_structp png_ptr, int unit, double width, double height)
|
||||
char buf[64];
|
||||
png_size_t total_len;
|
||||
|
||||
png_debug(1, "in png_write_sCAL\n");
|
||||
png_debug(1, "in png_write_sCAL");
|
||||
|
||||
buf[0] = (char)unit;
|
||||
#if defined(_WIN32_WCE)
|
||||
@ -1662,7 +1620,7 @@ png_write_sCAL(png_structp png_ptr, int unit, double width, double height)
|
||||
total_len += png_strlen(buf + total_len);
|
||||
#endif
|
||||
|
||||
png_debug1(3, "sCAL total length = %u\n", (unsigned int)total_len);
|
||||
png_debug1(3, "sCAL total length = %u", (unsigned int)total_len);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_sCAL, (png_bytep)buf, total_len);
|
||||
}
|
||||
#else
|
||||
@ -1677,7 +1635,7 @@ png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width,
|
||||
png_byte buf[64];
|
||||
png_size_t wlen, hlen, total_len;
|
||||
|
||||
png_debug(1, "in png_write_sCAL_s\n");
|
||||
png_debug(1, "in png_write_sCAL_s");
|
||||
|
||||
wlen = png_strlen(width);
|
||||
hlen = png_strlen(height);
|
||||
@ -1692,7 +1650,7 @@ png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width,
|
||||
png_memcpy(buf + 1, width, wlen + 1); /* append the '\0' here */
|
||||
png_memcpy(buf + wlen + 2, height, hlen); /* do NOT append the '\0' here */
|
||||
|
||||
png_debug1(3, "sCAL total length = %u\n", (unsigned int)total_len);
|
||||
png_debug1(3, "sCAL total length = %u", (unsigned int)total_len);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_sCAL, buf, total_len);
|
||||
}
|
||||
#endif
|
||||
@ -1711,7 +1669,7 @@ png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit,
|
||||
#endif
|
||||
png_byte buf[9];
|
||||
|
||||
png_debug(1, "in png_write_pHYs\n");
|
||||
png_debug(1, "in png_write_pHYs");
|
||||
if (unit_type >= PNG_RESOLUTION_LAST)
|
||||
png_warning(png_ptr, "Unrecognized unit type for pHYs chunk");
|
||||
|
||||
@ -1735,7 +1693,7 @@ png_write_tIME(png_structp png_ptr, png_timep mod_time)
|
||||
#endif
|
||||
png_byte buf[7];
|
||||
|
||||
png_debug(1, "in png_write_tIME\n");
|
||||
png_debug(1, "in png_write_tIME");
|
||||
if (mod_time->month > 12 || mod_time->month < 1 ||
|
||||
mod_time->day > 31 || mod_time->day < 1 ||
|
||||
mod_time->hour > 23 || mod_time->second > 60)
|
||||
@ -1779,7 +1737,7 @@ png_write_start_row(png_structp png_ptr)
|
||||
|
||||
png_size_t buf_size;
|
||||
|
||||
png_debug(1, "in png_write_start_row\n");
|
||||
png_debug(1, "in png_write_start_row");
|
||||
buf_size = (png_size_t)(PNG_ROWBYTES(
|
||||
png_ptr->usr_channels*png_ptr->usr_bit_depth, png_ptr->width) + 1);
|
||||
|
||||
@ -1879,7 +1837,7 @@ png_write_finish_row(png_structp png_ptr)
|
||||
|
||||
int ret;
|
||||
|
||||
png_debug(1, "in png_write_finish_row\n");
|
||||
png_debug(1, "in png_write_finish_row");
|
||||
/* next row */
|
||||
png_ptr->row_number++;
|
||||
|
||||
@ -1988,7 +1946,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
|
||||
int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
|
||||
#endif
|
||||
|
||||
png_debug(1, "in png_do_write_interlace\n");
|
||||
png_debug(1, "in png_do_write_interlace");
|
||||
/* we don't have to do anything on the last pass (6) */
|
||||
#if defined(PNG_USELESS_TESTS_SUPPORTED)
|
||||
if (row != NULL && row_info != NULL && pass < 6)
|
||||
@ -2159,7 +2117,7 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
|
||||
int num_p_filters = (int)png_ptr->num_prev_filters;
|
||||
#endif
|
||||
|
||||
png_debug(1, "in png_write_find_filter\n");
|
||||
png_debug(1, "in png_write_find_filter");
|
||||
/* find out how many bytes offset each pixel is */
|
||||
bpp = (row_info->pixel_depth + 7) >> 3;
|
||||
|
||||
@ -2768,8 +2726,8 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info)
|
||||
void /* PRIVATE */
|
||||
png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row)
|
||||
{
|
||||
png_debug(1, "in png_write_filtered_row\n");
|
||||
png_debug1(2, "filter = %d\n", filtered_row[0]);
|
||||
png_debug(1, "in png_write_filtered_row");
|
||||
png_debug1(2, "filter = %d", filtered_row[0]);
|
||||
/* set up the zlib input buffer */
|
||||
|
||||
png_ptr->zstream.next_in = filtered_row;
|
||||
|
Loading…
Reference in New Issue
Block a user